Our plan is based on dividing objects in programs into one of three core ownership capabilities: Immutable values can be shared freely within and between concurrent threads but cannot be updated; Isolated objects can be updated and transferred between threads but can only have one unique reference; and local objects that can be accessed, updated, and shared only within a single thread. These capabilities form an ownership hierarchy (Imm < Iso < Local) that constrains interobject references: an immutable object can only refer to other immutable objects; an isolated object can refer to other isolated or immutable objects; and a local object can refer to immutable objects, isolated objects, and other local objects.

Gradual concurrency:
correctness,
simplicity,
and performance
via dynamic ownership

Today's phones and laptops have ten or more processor cores, while datacentres have tens of millions. To use all these cores effectively, programs increasingly have to be concurrent, i.e. with multiple simultaneous threads of execution. Most of today's concurrent programs, however, are written in low-level langauges which provide no correctness guarantees, while contemporary concurrent research languages rely on static type systems which programmers find hard to use. This scholarship project will develop a novel theory of gradual concurrent dynamic ownership. Using langauges based on this theory, programmers will be able to write concurrent programs that are safe, simple, and efficient

For further information email James Noble at creative research & programming.