Java Layers

Publications
Conference Papers
Technical Reports
Dissertation
Miscellaneous

JL Download
Quick Reference 

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 compositions.

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 focus.

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. 

Adam Brown, a PhD. student, has used JL to build our flexible widgets library and participated in numerous design discussions. 

Saurabh Boyed, an undergraduate student, has also used JL and provided valuable feedback to the rest of the team.

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 Checking facility. 

The Java Layers component model is based on Don Batory's GenVoca 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 multiple classes.  

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 subtyping.

Click here 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 capabilities:

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 JL. 

1. 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 technical report). 
   
   
2. 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 2001).
   
   Description of the new JL syntax and language features.  Schmidt's ACE framework for client/server applications is reengineered in JL and the two approaches are compared.  Presentation slides are here.
   
   
3. Object-Oriented Frameworks and Product-Lines
   by Don Batory, Richard Cardone and Yannis Smaragdakis.  1st Software Product-Line Conference, August 2000, Denver.
   
   The relationship between software product-lines, object-oriented frameworks and the programming methodology of stepwise refinement is explored. 
       
4. 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 and GenVoca.

1. The Specification of the Sibling Design Pattern
   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.
    
2. Static Virtual Types in Java Layers
   by Richard Cardone and Calvin Lin.  Technical report CS-TR-00-25, Computer Sciences Department, University of Texas, 2000.
   
   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. 
   
   
3. 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.

1. My Ph.D. proposal, presented on 1/16/01.
   The presentation slides are here.
2. Java Layers Language Presentation (12/7/00)
   by Richard Cardone and Calvin Lin (PowerPoint).