Raul Silaghi

Integrating CBSE, SoC, MDA, and AOP in a software development method

Component-based software engineering, separation of concerns, model-driven architecture, and aspect-oriented programming are four active research areas tat have been around for several years now. In this paper, we present how these four paradigms can be put together in the context of a new software development method and we show how they can complement each other are different stages in the development life-cycle of enterprise, middleware-mediated applications. Different software development methods, such as Fondue, Catalysis, KobrA, and the Rational Unified Process, are also analyzed, pointing out their differences and limitations. In the end, requirements for a dedicated tool infrastructure that would support the new development approach are discussed.

Parallax, or Viewing Designs Through a Prism of Middleware Platforms

It is becoming more and more evident that the major hindrance to the proliferation and adoption of the MDA vision in the large is the current lack of tool support. Parallax, based on aspect-oriented support and through a well-defined system of plug-ins, addresses this issue by providing a framework that enables developers to incorporate middleware-specific concerns in their designs, and to view their enhanced designs through a prism of middleware platforms and see how middleware-specific concerns are actually implemented at the code level. Moreover, developers and middleware vendors can contribute and enrich Parallax by implementing and providing the community with new plug-ins for their favorite middleware infrastructures.

Critical Evaluation of the EJB Transaction Model

Enterprise JavaBeans is a widely-used technology that aims at supporting distributed component-based applications written in Java. One of the key features of the Enterprise JavaBeans architecture is the support of declarative distributed transactions, without requiring explicit coding. In this paper, after a brief introduction of the concepts and mechanisms related to the EJB Transaction Model, we provide guidelines for their consistent use. We then evaluate the EJB Transaction Model on an Auction System case study. The encountered limitations are presented, and possible work-arounds are proposed for the auction system. We conclude with suggestions for enhancing the current EJB Transaction Model.

Parallax - An Aspect-Enabled Framework for Plugin-Based MDA Refinements Towards Middleware

MDA has been around for more than three years already. Nevertheless, besides the lack of a standard model transformation language to support the MDA vision, there is even a lack of tool support to implement the platform-specific mappings promoted by the same MDA. For quite some years now, tool vendors have offered the possibility to generate code for different programming languages, but the spectrum of tools is very limited when it comes to generating code for different middleware infrastructures. Parallax, based on aspect-oriented support and through a well-defined system of plug-ins, addresses this issue by providing a framework that enables developers to first (re)configure their designs and enhance them with middleware-specific concerns at different MDA levels of abstraction, and then adapt the implementation of these concerns to different middleware infrastructures and see how they are actually implemented at the code level. Moreover, developers and middleware vendors can contribute and enrich Parallax by implementing and providing the community with new plugins for its favorite middleware infrastructures.

An MDA-Based approach for inferring concurrency in distributed systems

When dealing with distributed systems, one of the most important problems that has to be addressed is concurrency. Distributed systems are inherently concurrent, distributed objects being implicitly “shared” between all participating clients, and explicit concurrency control must be enforced if consistency is to be preserved. From an MDA perspective to software development, we show in this paper how concurrency resulting from distribution can be inferred in an automatic way, provided that a small set of design conventions are strictly adhered to. A simple PIM-level concurrency profile is considered in order to illustrate how the inference algorithm evolves on a concrete example and how an initial distributed design is automatically refined according to the proposed concurrency profile.

“Weaving” MTL model transformations

Model transformations are the core of the MDA approach to software development. As specified by the OMG, model transformations should act on any kind of model of any kind of metamodel, which implies the possible “reflective” use of model transformations, i.e., model transformations acting on model trans formations. However, this requires transformation developers to be familiar with the metamodel of the transformation language itself, which is not always the case. In order to overcome such a frustrating impediment for the MTL language, and inspired by AOP approaches, we have designed and implemented an MTL weaver that modifies MTL transformations according to some weaving behavior, which is specified as special MTL transformations, called MTL-aspects, using an AOP-like extension to the MTL language. Both the weaver and the language extension are presented in this paper, and an example is used to show how transformation developers can take advantage of the proposed language extension constructs in order to write “reflective” model transformations in MTL without requiring any previous knowledge of the MTL metamodel itself.

MDA refinements along middleware-specific concern-dimensions

Over the last decades, middleware has become an integral part in the development of distributed enterprise systems. Nevertheless, currently existing software engineering methods continue to have a strong focus on functional requirements, ignoring more or less nonfunctional concerns, such as middleware-specific concerns, which have to be addressed sooner or later when designing and implementing distributed systems. Following an MDA approach to software development, the Enterprise Fondue method proposes a hierarchy of UML profiles as a means for addressing middleware-specific concerns at different MDA-levels of abstraction, along with model transformations to incrementally refine existing design models according to the proposed profiles. Tool support is provided through the Parallax framework, which assists developers in the Enterprise Fondue refinement process and enables them to modularize middleware-specific crosscutting concerns into aspect-promoting Eclipse plug-ins.

Model-driven engineering of middleware-mediated distributed systems

Existing software engineering methods tend to have a strong focus on functional requirements, ignoring more or less non-functional concerns, such as middleware-specific concerns, which have to be addressed sooner or later when designing and implementing distributed systems. Following an MDA approach to software development, the Enterprise Fondue method proposes a hierarchy of UML profiles as a means for addressing middleware-specific concerns at different MDA-levels of abstraction, along with model transformations to incrementally refine existing design models according to the proposed profiles. Tool support is provided through the Parallax framework, which assists developers in the Enterprise Fondue refinement process and enables them to modularize middlewarespecific crosscutting concerns into aspect-promoting Eclipse plug-ins.

Refining designs along middleware-specific concern-dimensions at different MDA-levels of abstraction

For the MDA approach to software development to become a reality for distributed enterprise systems, MDA needs to provide both modeling support for middleware-specific concerns and tool support for helping developers refine their designs along such concern-dimensions at different MDA-levels of abstraction. In order to address these issues, the MDA-compliant Enterprise Fondue method proposes a hierarchy of UML profiles as a means for addressing middleware-specific concerns at different MDA-levels of abstraction, along with model transformations to incrementally refine existing design models according to the proposed profiles. Tool support is provided through the Parallax framework, which enables developers to modularize crosscutting concerns into aspect-promoting Eclipse plug-ins.

Porting OMTTs to CORBA

The Common Object Request Broker Architecture standardizes a platform- and programming-language-independent distributed object computing environment. It also provides a standard for several distributed services. The Object Transaction Service provides an object-oriented framework for distributed transaction processing, especially for Online Transaction Processing in business applications. The current CORBA OTS allows multi-threading inside a transaction, leaving, however, thread coordination to the application programmer, which can be dangerous. Based on the Open Multithreaded Transaction model, we present in this paper the design of a Thread Synchronization Coordinator, ThreadSyncCoordinator, which provides the desired thread control inside a multithreaded transaction. A blocking commit protocol ensures that once in a transaction, a thread cannot leave before the outcome of the transaction has been determined, guaranteeing the ACID properties for multi-threaded transactions. We also show how the ThreadSyncCoordinator can be used to design and implement complex applications, e.g., an Online Auction System, in an elegant way.