J&: Nested Inheritance and Intersection for Java

The goal of the J& project is a type-safe programming language that makes code reuse easier and safer. In conventional languages, extending a large, complex system requires either duplicating code or writing boilerplate or glue code. This means writing and maintaining code are difficult and tedious. We want type-safe, modular, scalable extensibility. In other words, the work required to modularly add a new feature tends to be proportional to the size of the feature, and extensions cannot introduce type errors.

J& (pronounced “jet”) is an extension of Java that increases code extensibility and reuse using nested inheritance. Nested inheritance supports inheritance of packages and classes while allowing classes nested within to be overridden. Nested inheritance is a powerful mechanism for safely and modularly extending code.

J& is an outgrowth of work on the Polyglot extensible compiler framework. Polyglot has been ported to J&. An earlier version of the language was known as Jx.

Downloads

An initial release of the J& compiler is now available, released October 2006.

Papers and reports

Sharing Classes between Families , Xin Qi and Andrew C. Myers, to appear, PLDI'09, June 2009.
Masked Types for Sound Object Initialization, POPL'09, January 2009. Xin Qi and Andrew C. Myers.
Programming Languages for Scalable Software Extension and Composition, Nathaniel Nystrom, Ph.D. thesis, Cornell University Department of Computer Science. November 2006.
J&: Software Composition with Nested Intersection, Nathaniel Nystrom, Xin Qi, and Andrew C. Myers, OOPSLA 2006, pp. 21–36. [ Full technical report ]
Scalable Extensibility via Nested Inheritance, Nathaniel Nystrom, Stephen Chong, and Andrew C. Myers, OOPSLA 2004, pp. 99–115

Support

The development of J& has been supported by a number of funding sources, including DARPA Contract F30602-99-1-0533, monitored by USAF Rome Laboratory, ONR Grant N00014-01-1-0968, NSF Grants CNS-0208642, CNS-0430161, and CCF-0133302, an Alfred P. Sloan Research Fellowship, and an Intel Research Ph.D. Fellowship.

Contributors

Example: Composing compilers with nested intersection.

The base compiler package is extended in two different ways using inheritance, adding new classes and class members (bold) in the subpackages pair and sum, which implement extended compilers. When intersected in the package pair & sum, the class hierarchies contained in the two packages are composed. The resulting compiler incorporates both language extensions.