Final day of the conference (is this the latest blog post ever? Probably. Consider it an un-expected Christmas gift):
Homogeneous Family Sharing – Xin Qi
Xin talked about extending sharing from classes to class families in the J& family of languages. Sharing is a kind of bidirectional inheritance, and is a language-level alternative to the adapter design pattern. The work includes formalism, soundness proof, and implementation using Polyglot. Dispatch is controlled by the view of an object, the view can be changed by a cast-like operation.
I didn’t quite get shadow classes, but I think they are like further bound classes in Tribe.
Finally, their families are open, as in open classes, so the programmer can add classes to families post hoc.
Mostly Modular Compilation of Crosscutting Concerns by Contextual Predicate Dispatch – Shigeru Chiba
Chiba presented a halfway language between OOP and AOP called GluonJ. The idea is that it should be a more modular version of aspects (I think). However, it was found to be not as modular to check and compile as standard OOP. The language supported cross-cutting concerns with predicate dispatch and an enhanced overriding mechanism.
Ownership and Immutability in Generic Java – Yoav Zibin
Yoav talked about work that combined ownership and immutability in a single system using Java’s generics. It is nice work, but I’m afraid I was too busy being nervous about being next up to write any notes.
Tribal Ownership – Nick Cameron (me!)
I talked about work with James Noble and Tobias Wrigstad on using a language with virtual classes (Tribe) to support object ownership (i.e., ownership types without the extra type annotations) for free (that is, no additional programmer syntax overhead). I really like this work, it all seems to come together so neatly, which I find pretty satisfying. I really do think virtual classes are extraordinarily powerful and yet easy enough for programmers to understand. Hopefully, they’ll make it into a mainstream language before too long…
A Time-Aware type System for Data-Race Protection and Guaranteed Initialization – Nicholas Matsakis
Nicholas introduced a language (Harmony) where intervals of ‘time’ are represented in the type system to make the language time-aware. This can be used to prevent race conditions in concurrent programs and for other uses (including some non-concurrent ones), such as allowing new objects time to establish their invariants. Intervals are scoped and an ordering may be specified by the programmer; the runtime or compiler may reorder execution subject to this ordering. Checking is modular and is flow insensitive.