Concurrent Programming Research Group
 Home  |  Members  |  Presentations  |   Publications  |   Courses  |   Resources  |
 

Welcome to the Concurrent Programming Research Group

In the field of concurrent programming languages, problems known as code tangling and code crosscutting have received a large attention. Synchronization and scheduling code can hardly be factored out of the functional code using traditional code reuse mechanism such as inheritance, and ends up tangled with the functional code. Tangled code is hard to understand, impede code reusability and may leave a negative impact on adaptability, system performance and reliability.

Aspect Oriented Software Development

Aspect-Oriented Software Development seeks to modularize those crosscutting concerns and aims at supporting the bottom line of separation of concerns. It is an extension to other software development paradigms that allows capturing and modularizing concerns that cut across a software system into modules called aspects. AOSD advocates the need to treat aspects as first class entities throughout the software development cycle.
The Concurrent Programming research Groups dedicates itself to investigate research areas in the field of AOSD:

  • Aspect-Oriented Modeling
  • Analysis of Aspect-Oriented Software
  • Aspect-Oriented Software Testing
  • Dynamic Aspect Weaving

Projects

Aspect Interference Detector (AID)
Aspect Interference Detector (AID) is a framework that detects potential interference among the aspects and between the aspects and the base model in Aspect Oriented Modeling (AOM). AID is composed of two components to report syntactical interference among the aspects and semantical interference between the aspects and the base model. The syntactical interference is based on the model structure and targets the UML class, sequence, and state diagrams. Three types of interference are detected based on the model's syntactics, shared joinpoints, conflicts, and dependency. If two aspects match the same joinpoint, or one aspect matches elements in the base model that were introduced by another aspect, then the two aspects share a joinpoint. If an aspect creates elements that are required for another aspect to match its joinpoint, then the aspect is considered an enabling aspect. If an aspect creates elements that prevent another aspect from matching its joinpoints, then it is considered a conflicting aspect. The solution is implemented by extending the Attributed Graph Grammar(AGG) and written in Java. The semantical detection of interference is based on model checking. The AID ensures that an aspect does not invalidate existing system specifications that are defined in Computational Tree Logic (CTL). The AID implements a modular approach to model check the aspect's model without weaving the aspect to the base model.

Motorola WEAVR
The Motorola WEAVR is an industrial strength Aspect-Oriented Software Development tool that supports weaving of UML 2.0 behavioral models. Model weaving has multiple advantages compared to code-level weaving. Modeling languages allow a system to be defined according to different decompositions. Different views of the system focus on different properties, while omitting others. Crosscutting concerns can therefore be coordinated with a base system according to different joinpoint models. The implementation of an aspect is often more natural according to one decomposition compared to another. Model weaving allows aspects to be defined according to the perspective of the system that fits the problem definition the best. The abstractions provided by the different perspectives are lost at the level of the code. There is therefore a strong motivation to fully coordinate crosscutting concerns at the model level. The Motorola WEAVRsupports a classic joinpoint model based on objects and methods for UML 2.0, but also introduces a novel joinpoint model for state machine diagrams. Woven behavior models do not have a user friendly representation and are not supposed to be manually inspected. Model weaving is therefore only possible in the context of Model-Driven Engineering or fully automated translation of models into executable artifacts. We are pleased to provide academic licenses for the WEAVR, for research purposes, upon request.

Download DAC++/NDAC++
Dynamic Aspect C++ compiler (DAC++) represents an extension to the C++ compiler toward the support of Dynamic Aspects. DAC++ supports C++ language object oriented capabilities but adds to it the dynamic aspect oriented support. Dynamic aspects allow application to evolve easily over time. DAC++ represents the first Dynamic Aspect Oriented system that supports a rich feature set of aspect oriented capabilities for C++ language. Dynamic Aspect C++ that supports the following features: Dynamic Aspects, Dynamic pointcut expressions, class-based aspects, three types of advices support, strong context exposure, two weaving modes and multiple aspects interaction. Network Dynamic Aspect C++ (NDAC++) represents the second stage of DAC++. This represents extending C++ toward the support of inter-process and network aspects. NDAC++ allows easy implementation and evolution of many network applications and network designs. In addition, NDAC++ helps in implementing network applications that can be easily managed.

Download Aspect-Oriented Statecharts Framework
The aspect-oriented statechart framework allows one to specify behavior for an object via Harel's statecharts. The framework is capable of taking individual objects implemented in this manner and composing them in orthogonal regions to achieve the weaving of individual concerns. Events generated in one orthogonal region are broadcast to the other orthogonal regions, thus providing a communication mechanism between the regions. The framework allows an event to be reinterpreted from a 'core' event to an aspect 'event' that has meaning in a separately developed statechart. In normal statecharts, the order that the orthogonal regions handle a broadcast event is non-deterministic. In our framework we introduce determinism by allowing one orthogonal region (described by an aspect statechart) to handle an event before or after another region (described by a core statechart). This produces the flow altering constructs necessary for weaving crosscutting concerns together.

Download Executable Choreography Framework
The Executable Choreography Framework provides a support architecture for the incremental development of applications that target highly dynamic service-oriented environments. The approach builds on top of collaboration-based analysis techniques applied to the development of distributed systems. The authors introduce Contextual Aspect-Sensitive Services (CASS) as being services whose instance interfaces can dynamically be adapted by Service Refinement Layers, using aspect weaving. A service refinement layer encapsulates distributed aspects that cut across service container boundaries. It modularizes the structure and the collaborative behavior of composite services. A service-oriented support architecture exploiting dynamic AOP technology is presented. The architecture provides built-in support for remote pointcuts and a service-oriented joinpoint meta-model. Service refinement layers can be used to compose and choreograph Web Services, and have the potential to define much more advanced collaboration scenarios than can be specified with state-of-the-art web service orchestration languages such as BPEL.

Download Dynamic Weaver Framework
A language independent framework for Dynamic Aspect-Oriented Programming


Download Mailslots
An Aspect-Oriented IPC technique for UNIX
Winner of the IBM Linux Scholar Challenge, 2002

Download Requirement-Based Automated Aspect Verification
Automated aspect testing

Mailing List Subscriptions

aosd@mailer.iit.edu

Mailing list intended for announcements relevant to the IIT Concurrent Programming Research Group such as upcoming group meetings, conferences, calls for papers, as well as major publications in the field of concurrent programming and AOSD. Subscribe

 
 
This website is still under construction -
Please send suggestions and comments to Thomas Cottenier : cotttho@iit.edu