ECOOP / Posters

The “official” poster session will be during the Welcome Party on Wednesday evening which will take place at the Maritim Konferenzhotel. Poster authors will be present next to their poster board to meet with attendees and discuss their work. However, posters will be displayed in the coffee break area around the main conference hall during the entire main conference, Wednesday to Friday to allow interactions through out the conference. Poster authors will be available as time permits.

HAD: Extending UML for the modelling of Hybrid Control Systems

Marcellin Nkenlifack

This poster proposes extensions in UML to facilitate the modeling of Hybrid Control Systems. The extensions are motivated by experiences in the use of UML in the design of the model base of a simulator for hybrid control systems. The extensions focus on three aspects of UML: modification of Activity Diagrams to incorporate discrete and continuous signals at the inputs and outputs, convertibility between a UML specification of a hybrid model and a Grafcet of the system, incorporation of structures for specifying causal relationships between components of a control system. The proposals are a contribution towards the ultimate objective of having a UML which is specifically adapted to the formalisms and concepts of Automatic Control Engineering.

Could Message Hierarchies Contemplate?

Edward Curry

The goal of this research is to define enhancements for enterprise messaging systems allowing them to be more adaptable to their runtime environment. Research focuses on hierarchical channels or topics within publish/subscribe systems. Hierarchical channels are used for routing situations that are more or less static. Hierarchical channels require that the channel namespace schema be both well defined and universally understood. The responsibility for choosing a channel in which to publish is left to the publishing application. The channel selection logic is integrated in the publisher’s application code. This results in a tight coupling between the channel hierarchy and publisher’s code, making changes in the hierarchy difficult and restricting the ability of the hierarchy to evolve and change.
A reflective system is one that provides a representation of its own behaviour that is amenable to inspection and adaptation, and is causally connected to the underlying behaviour it describes. Moving the responsibility of the channel selection logic from the publishing client to the middleware will allow the application of reflective techniques in channel hierarchies. This shift in responsibility to the service allows the application of reflective and adaptive techniques to dynamically grow and improve the hierarchy to meet the needs of its changing environment and operating conditions.

OCLE – an UML Tool Supporting the Development of OO Applications Using MDA

Dan Chiorean

The Object-Oriented Development Environments have certain features that allow the creation of class diagrams. In the majority of the cases, these tools support an underlying developing platform and an OO language used for implementation. The models that are built are mostly design or implementation models. In this case, the UML support is merely in diagram representation. The first checks that are made on these models, take place during the compilation stage. The objective of this poster is to present an OCL environment integrated into an UML tool called OCLE; environment that supports the usage of MDA based methodologies. The main advantages of using such an environment, is the ability to build platform independent models, the ability to check the models in the early phases of the application development and the possibility to automatically transform the models against a set a rules.

Dialogue-Based Aspect-Oriented Refactoring

Jan Hannemann

This poster outlines the motivation, challenges and current state of our work in the area of dialogue-based aspect-oriented refactorings. We plan to develop a proof-of-concept generic AOP refactoring tool as a plugin for the Eclipse IDE that will be able to support developers in aspect-oriented refactorings. The tool will be instantiated for the AspectJ language. The focus will be on design pattern refactorings, which represent complex higher-level refactorings with alternatives and tradeoffs that require developer interaction. To show that it can help support common refactoring tasks, the tool will be applied in a large-scale refactoring project.

A Typestate System for Simultaneous and Changing Data Structure Participation

Patrick Lam

We present a new typestate system in which the type of an object is determined, in part, by its participation in a program's data structures. The type of an object changes as the nature of its participation in the data structures changes over the course of the object's lifetime in the program's execution. Our system is unique in that it can accurately characterize sharing patterns that arise when objects participate in and move between multiple data structures simultaneously. Because each object's typestate completely characterizes its sharing relationships, we can verify module independence, check that a complicated typestate change always runs to completion, and succintly summarize the effects of procedures, all without the need to perform any pointer or heap analyses. This poster presents our typestate system and a soundness proof for this system.

Use Case Modularity Using Aspects

Manali Bhole

Why is "Use Case modularity" important? In systems where use case modularity is not maintained, modifying or adding a new use case, due to modifications in the business requirements or due to system evolution, will cause modifications to occur in many software components. These modifications to the existing software modules can be avoided if each use case can be realized into a separate module during the implementation phase. Thus the system is modularized according to use cases captured in requirements analysis. This is also known as Use Case Driven Development. How AOP comes to help us with Use Case driven development?
In AOP we have a Join Point Model, which allows code from aspects (advice) to be interweaved with code from an OO program (called "base program") at specific points during the base program's execution (called join points).This idea maps very closely to the 'extend' relationship as it is defined between use cases and extension points. The extension points are like join points where code from the extending use case can be woven into the base use case.

Overview: Event-Based Dynamic Distributed systems Visualization

Carlos Varela

OverView is an event-based architecture for dynamic online distributed system visualization. It consists of three layers: a visualization layer, an event profiling layer that communicates with distributed Java Virtual Machines, and a data mapping layer. An entity specification language is used to map high-level concurrency abstractions into corresponding lower-level Java threads, network connections, and objects.

top