Java Layers

Team Members
Component Model
JL Language

Conference Papers
Technical Reports

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.

Getting Started

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. 

Team Members

bullet Calvin Lin, Assistant Professor
bullet Richard Cardone, PhD. candidate 

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. 

JL Component Model

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.

JL Language

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:

bullet Deep Conformance
bullet Limited Virtual Typing
bullet Semantic Checking
bullet Constructor Propagation
bullet Class Hierarchy Optimization 

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. 


Conference/WorkShop Papers

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

Technical Reports

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


Last modified: 05/09/2002 11:00 AM