Lasagne/J

Project Home Page

 

Welcome...

What is Lasagne/J

Lasagne/J is an extension of the Java programming language that makes dynamic evolution of collaborating objects possible. With Lasagne/J the observable behavior of a group of collaborating objects can evolve without requiring any modifications to the source code of their respective classes. This means that neither access to source code nor the existence of foreseen hotspots hooks within the classes of evolving objects are required for changing the observable behavior of an existing group of collaborating objects.

 

The Idea Behind the Language Extension

Lasagne/J is based on the idea of crosscutting dynamic class-widening by propagating superimposition of generic wrappers. In it very essence, this means that new features can be added to an existing system simply by dynamically superimposing new behavior on objects that are already present within the system. This dynamic superimposition of behavior is crosscutting. That is, the behavior of any object participating in a collaboration will be updated if there exist at least one behavioral refinement that applies to the object when it participate in that particular collaboration. Furthermore each crosscutting superimposition of behavior is done in isolation. Thus different clients can maintain their own specific view on the same object collaboration. Behavioral refinements for individual objects are defined as generic wrappers of their respective classes. Generic wrappers are organized into packages that each defines an extension for an existing group of objects. An extension may affect one or more collaborations for a group of objects.

 

Lasagne/J in Software Development

The dynamic crosscutting class-widening that Lasagne/J brings to Java is useful in a variety of software development and evolution scenarios, including:

 

  • Application evolution, especial unanticipated integration of additional features by development teams operating with varying degrees of independence.
  • Dynamic adaptation; inclusion of new features on-demand.
  • Dynamic reconfiguration; dynamic change of system behavior.
  • Simultaneous update of server systems with multiple features, where each feature is to be kept separate, while on-line.
  • Development of systems in which it is advantageous for code modularity to mirror additive requirements.
  • Unplanned integration of separately written features, possible by third parties, into new applications with extended functionality.

 

Related Research Areas

The usage domain of the Lasagne/J language extension is multi dimensional and touch upon the same problems as many mainstream research areas.

 

Aspect Oriented Programming. Various aspects, like Logging for instance, can be superimposed on existing objects using Lasagne/J. Please see the Logging example in the Separation of Concerns trail of the Lasagne/J tutorial.

 

Subjectivity. With Lasagne/J different objects can have their own perspective on the same object. Hence, the behavior of an object will depend on the context in which it is used. Please see the Visitor design pattern example in the Design Patterns trail of the Lasagne/J tutorial.

 

 

Collaboration-based Design. Collaboration-based (or role-based) designs decompose an object-oriented application into a set of classes and a set of collaborations. Each application class encapsulates several roles, where each role embodies a separate aspect of the class’ behavior. In Lasagne/J different roles of an application class can be implemented as generic wrappers that wraps a commonly shared object. Hence, distinct and largely independent aspects of an application can now be expressed by a group of related wrappers and their collaborations. Wrappers that implement a logically distinct part of the application are placed in the same package.

While collaboration-based designs cleanly capture different aspects of application behavior, their implementations often fail to preserve this modularity due to the shortcomings of the chosen implementation language. Lasagne/J, however, preserves this modularity as different aspects of application behavior are organized within separate packages of related generic wrappers.

 

Dynamic Adaptation and Reconfiguration. A system’s behavior can be modified at runtime through the means of adaptation and reconfiguration. Reflective middleware systems have long used adaptation and reconfiguration technologies to inspect and change their own behavior during execution. The need for change within those systems is often triggered by the need to meet new quality of service (QoS) requirements or integrate unforeseen features such as new protocols or secure communication on-demand. The tutorial trail Changing the Engine While the Car is in Motion shows how Lasagne/J helps developers to build systems that can change behavior without being stopped, updated, and restarted.

 

Unanticipated Evolution. Lasagne/J makes the unanticipated evolution of legacy systems possible. Legacy systems can evolve without any modifications to their respective code bases. This means that neither source-code access or hotspots hooks within the code are required for changing the behavior of an existing system. New behavior is dynamically superimposed on the objects within the system at runtime.

 

The Team…

People Involved

Bo N. Jørgensen from the SWEAT research group at University of Southern Denmark.

Eddy Truyen from the DistriNet research group at KULeuven.

 

 

Publications...

The Concepts and Technologies Behind Lasagne/J

 

Jørgensen B.N.: Enhancing Java with Support for Simultaneous Independent Extensibility of Collaborating Objects. To appear in the proceedings of IASTED International Conference on Software Engineering (SE 2004)

 

Jørgensen B.N.: Language Support for Incremental Integration of Independent Developed Components In Java. To appear in the proceedings of ACM Symposium on Applied Computing (SAC 2004)

 

Jørgensen B.N., Truyen E.: Evolution of Collective Object Behavior in Presence of Simultaneous Client-Specific Views. In: Proceedings of the 9th international Conference on Object-Oriented Information OOIS’03. Lecture Notes in Computer Science, Vol. 2817. Springer Verlag, (2003) 18-32

 

Truyen E., Vanhaute B., Joosen W., Verbaeten P., (Katholieke, Universiteit Leuven, Belgium) and Jørgensen B.N. (Southern University of Denmark, Denmark).: Dynamic and Selective Combination of Extensions in Component-Based Applications. In: Proceedings of the 23rd International Conference on Software Engineering, Toronto, Ontario, Canada, May 12-19, (2001) 233-242

 

Truyen E., Jørgensen B.N., Joosen W.: Customization of Component-based Object Request Brokers through Dynamic Reconfiguration. In: proceedings of TOOLS EUROPE 2000, Mont Saint-Michel, France, IEEE (2000) 181-194

 

Jørgensen B.N., Truyen E., Matthijs F., Joosen W.: Customization of Object Request Brokers by Application Specific Policies. In: Proceedings of Middleware 2000. Lecture Notes in Computer Science, Vol. 1795. Springer Verlag, (2000) 144-164

 

The Lasagne/J

Tutorial...

 

A practical guide
 for programmers

Tutorial Trails

The Lasagne/J tutorial is divided in two parts – one that covers the fundamentals and another that addresses more specialized use of the Lasagne/J language extension.

 

Trails Covering the Basics:

 

Getting Started with Lasagne/J. A short introduction on how to write programs with Lasagne/J.

(Start Trail)

 

Extending Object Collaborations. This trail shows how to dynamically extend the observable behavior of a group of collaborating objects.

(Start Trail)

 

State Preserving Class Widening and Shrinking. With Lasagne/J an object can expand and shrink dynamically while its state is preserved. This trail shows you how. 

(Start Trail)

 

Independent Extensibility and Type Safety. When two or more independent developed extensions are reused in the same application it may occur that the extensions define methods with identical signatures but conflicting semantics. This trail exemplifies the problem and shows how it is solved.

 (Start Trail)

 

Specialized Trails:

 

Separation of Concerns. Lasagne/J can help developers with the modularization of crosscutting concerns such as: error checking and handling, synchronization, context-sensitive behavior, performance optimizations (caching), monitoring and logging.

(Start Trail)

 

Design Patterns. The purpose of many design patterns is to provide some form of flexibility that allows some kind of change to be made in a non-intrusive fashion (i.e., without rewriting existing code).  However, this approach only works when it is possible to anticipate the hotspots in the application in advance. The Design Patterns trail gives examples of how Lasagne/J facilitates better implementation of some design patterns than is possible with standard Java.

(Start Trail)

 

Incremental Design with Layered Implementation. This trail is currently in the construction phase.

(Start Trail)

 

Changing the Engine While the Car Is in Motion. This trail is currently in the construction phase.

(Start Trail)

 

Download...

How-To Get’n’Use Lasagne/J

 

You can download the Lasagne/J compiler and runtime system here.

 

Information on how to install and use Lasagne/J is provided here.

 

Contacts…

Bug Reports

If you experience any problems using Lasagne/J please send a email to Bo Nørregaard Jørgensen at bnj@mip.sdu.dk

 

What’s next?..

The Future of Lasagne/J

Current and future research directions for Lasagne/J include the development of IDE support for visualization of relationships between generic wrappers and classes, investigation of Lasagne/J’s effect on the application development lifecycle, and continuous experiments with the language’s features.

 

Related Projects...

No Project is an Island

The runtime system of Lasagne/J uses structural reflection to make dynamic evolution of collaborating objects possible. Any object subject to evolution has its structure modified at load time using Javassist.