The goal of Java Layers (JL) is to help make programming easier and
less expensive. The idea is to simplify application development and
evolution by increasing the flexibility and the reusability
of code. JL extends Java by implementing a software component
model in which applications are constructed incrementally in
layers. Applications are built by composing components, and applications are changed by specifying new
A quick read of this Introduction is a good way to begin. After
that, the quickest way to get the information you seek depends on your
For those who want to jump right into the language extensions, the Quick
Reference Guide describes what a Java programmer needs to know to
use JL. Downloading the JL compiler
or reading the specification sections in my
dissertation would be the
next step along this track.
For those who want to understand the software engineering issues
surrounding JL, the ICSE paper provides a good
overview. Our first technical report
also provides background and motivation for JL research. If you
are still interested, there are other publications
listed below that you might find interesting.
Brown, a PhD. student, has used JL to build our flexible
widgets library and participated in numerous design
Saurabh Boyed, an undergraduate student, has also used JL and provided valuable feedback to the rest of
We thank Sean
McDirmid for many interesting discussions about JL and his work on Jiazzi,
a component system that generalizes the use of packages in Java.
We are also grateful to Kartik Agaram and Thomas Wahl for their interest in
this work and for their contributions to the design of JL's Semantic
The Java Layers component model is based on Don
model. The GenVoca model consists of software components called layers,
a way to specify layer compositions, and a programming methodology that
emphasizes the stepwise refinement of code. A layer
encapsulates the complete implementation of a single design
feature. Design features, or simply
features, are high-level requirements
that define some application attribute or capability.
For example, applications might have
features that make them secure, portable, fail-safe, able to use
multiple protocols, dependant on certain libraries, etc. In JL,
each such feature is encapsulated in a single programming
construct. This encapsulation often includes code that
would be packaged separately using current object-oriented techniques. A JL layer,
for instance, can contain Java code for multiple methods or even
JL retains the important concepts of the GenVoca model while refining
GenVoca for use in domain-independent, object-oriented
environments. JL's component model specializes the GenVoca model
by (1) allowing all types to be treated as layers, and by (2) defining
layer compositions as instantiations of parametric types. JL's
component model extends the GenVoca model by (3) addressing how layers
are initialized, and (4) by incorporating semantic checking into
to see a simple JL example.
The JL language starts by extending Java with constrained parametric
polymorphism. JL's heterogeneous
implementation of parametric types is similar to a number current
proposals for extending Java [Agesen97, Bracha98]. One important
feature of JL's implementation of parametric types is its support for mixins. On top of this foundation, JL adds the following
My dissertation describes each of these language
and compiler extensions in detail.
See the Quick Reference Guide for a
summary of the language features implemented in the current version of
- Using Mixins to Build Flexible Widgets
by Richard Cardone, Adam Brown, Sean
McDirmid and Calvin Lin. Accepted for publication, 1st
International Conference on Aspect-Oriented Software Development (AOSD
2002), April 22-26, 2002, Enschede, The Netherlands.
We demonstrate how JL language features make programming with mixins
convenient by building GUI libraries for cell phones, Palm
devices and PCs from a common code-base. We also define the Sibling design pattern,
which encapsulates changes to a class and its superclasses in a
mixin layer (there's also a Sibling Pattern
- Comparing Frameworks and Layered Refinement
by Richard Cardone and Calvin Lin. Proceedings of the 23rd International Conference on Software
Engineering, pages 285-294, May 12-19, 2001 (ICSE
Description of the new JL syntax and language features. Schmidt's
framework for client/server applications is reengineered in JL and
the two approaches are compared. Presentation slides are here.
- Object-Oriented Frameworks and Product-Lines
by Don Batory,
Richard Cardone and Yannis
Software Product-Line Conference, August 2000, Denver.
The relationship between software product-lines, object-oriented
frameworks and the programming methodology of stepwise refinement is
- On the Relationship of Aspect-Oriented
Programming and GenVoca
by Richard Cardone. Proceedings of the 9th Workshop on
Institutionalizing Software Reuse (WISR9),
January 7-9, 1999, at the University of Texas.
A brief discussion of the similarities and differences between AOP
- The Specification of the Sibling Design
by Adam Brown,
Richard Cardone, Sean
McDirmid and Calvin Lin. Technical report CS-TR-02-11,
Computer Sciences Department, University of Texas, 2002.
Formalizes the Sibling pattern described in the Fidget paper listed
above (Using Mixins to Build Flexible Widgets).
The Sibling pattern can coordinate changes to multiple classes in the
same inheritance hierarchy. When used in deeply conforming mixin
layers, changes to nested classes can be reflected in sibling classes.
- Static Virtual Types in Java Layers
by Richard Cardone and Calvin Lin. Technical report
CS-TR-00-25, Computer Sciences Department, University of Texas,
Describes how a simple, static form of virtual typing can be
implemented in a parametrically polymorphic version of Java.
We discuss the need for virtual types and the tradeoffs of
integrating virtual types into a statically typed, object-oriented
language. Though our discussion is couched in terms of Java
Layers, the design can be used in more general settings.
- Java Layers: Extending Java to
Support Component-Based Programming
by Richard Cardone, Don
Batory and Calvin Lin. Technical report CS-TR-00-11,
Computer Sciences Department, University of Texas, 2000.
Describes the original JL syntax and system implementation.
The concepts are still applicable, but the language has been
improved since this paper was written.
My dissertation describes the latest
design, implementation and evaluation of Java Layers. My defense
slides are also available.
- My Ph.D. proposal, presented on 1/16/01.
The presentation slides are here.
- Java Layers Language Presentation
by Richard Cardone and Calvin Lin (PowerPoint).
Last modified: 05/09/2002 11:00 AM