Andreas Speck

Aspect Composition Applying the Design by Contract Principle

The composition of software units has been one of the main research topics in computer science. This paper addresses the composition validation problem evolving in this context. It focuses on the composition for a certain kind of units called aspects. Aspects are a new concept which is introduced by aspect-oriented programming aiming at a better separation of concerns. Cross-cutting code is captured and localised in these aspects. Some of the cross-cutting features which are expressed in aspects cannot be woven with other features into the same application since two features could be mutually exclusive. With a growing number of aspects, manual control of these dependencies becomes error-prone or even impossible. We show how assertions can be useful in this respect to support the software developer.

Feature Interaction in Composed Systems

The history of computer science has shown that decomposing software applications helps managing their complexity and facilitates reuse, but also bears challenging problems still unsolved, such as the assembly of the decomposed features when non-trivial feature interactions are involved. Examples of features include concerns or aspects, black box or white box components, and functional and non-functional requirements. Approaches such as object-oriented and component-based software development, as well as relatively new directions such as aspect-oriented programming, multi-dimensional separation of concerns and generative programming, all provide technical support for the definition and syntactical assembly of features, but fall short on the semantic level, for example in spotting meaningless or even faulty combinations. At previous ECOOPs, OOPSLAsand GCSEs dedicated events have been organised around the aforementioned technologies, where we experienced a growing awareness of this feature interaction problem. However, feature interaction is often merely dismissed as a secondary problem, percolating as an afterthought while other issues are being addressed. The intention of this workshop was to be the first co-ordinated effort to address the general problem of feature interaction in composed systems separately from other issues.

Aspects in Distributed Environments

We illustrate how to combine CORBA as a distributed system with aspect-oriented programming (AOP) and the resulting positive impacts. In particular, we focus on the question how AOP can be applied to a CORBA application aiming at a better separation of concerns. The paper shows with implementation examples a practical way to package the distribution issues of a CORBA application into separated aspects (with AspectJ). This supports the distributed application design and leads to increased flexiblity.

RoboSiM: Java 3D robot visualization

The programming language Java has made it possible to develop device independent software. The authors introduce a robot visualization system implemented in Java. This graphical user interface is part of their robot simulation and monitoring system (RoboSiM). Currently two versions of the visualization exist, a Java 1.1 based system and its successor realized in Java 3D. Both applets display real or virtual robot arms and enable the user to manipulate this arm. Due to the support of distributed computing by Java and its platform independence, the Java GUI may run on different local and remote systems. Therefore the same robot may be controlled by a local user or via Intranet or Internet with the same applet. The GUI applet communicates directly with the control or simulation computer. In contrast to the Java 1.1 user interface, the Java 3D robot visualization is much more detailed. Compared with other visualization systems the Java 3D applet is very realistic. Therefore the Java display is a capable alternative to the traditional visualization.

Developer-friendly verification of process-based systems

System quality is a key issue in modern systems development. Tool support is essential for checking the system quality efficiently. This is particularly true with respect to the dynamic interactions of the processes within a system. A first generation of checkers - model checkers - provide a basic technology for the verification of process-based systems. Conventional model checkers bear two drawbacks concerning mainly their user-friendliness which impede their broad application. First, model checkers in general do not support the graphical representation of rules (specifications). Although a model may be described with a graphical notation, the specification which has to be checked against the model is generally still text-based. This makes the usage of the checker difficult for process modeling experts. Second, the expressiveness concerning the verification model semantics to be checked is limited to states which are connected by transitions. However, many system development models (e.g. the business process model we use as example) embrace more element types. These are unsupported by the conventional model checkers resulting in a loss of verification precision. The checking system we present in this paper integrates both novelties: the graphical notation for a user-friendly specification and an extended specification language together with a corresponding verifier which supports the checking of many different types of elements (although the paper presents the approach with only two types). The integration is realized by an XML-based transformation system which links the graphical editor to the checking tool.

A Version Model for Aspect Dependency Management

With Aspect-Oriented Programming (AOP) a new type of system units is introduced (aspects). One observed characteristic of AOP is that it results in a large number of additional (coarse-grained to fine-grained) system units (aspects) ready to be composed to the final application. With this growing number of system units the dependencies between them become vast and tangling. This results in the necessity of an improved management of the dependencies between these system units. Our paper investigates this problem, proposes a more general model (version model) to capture different facettes of AOP as well as a partial solution towards unit consistency based on versions.

Implementing collaboration-based designs using aspect-oriented programming

The collaboration based approach is a powerful means to develop modularised systems by stepwise refinement. The authors introduce a novel approach to realise a collaboration based design. Our approach is based on the well known observation that the knowledge about inter-object collaborations cannot be localised within objects but cross-cuts many objects. Such cross-cutting concerns are effectively addressed by applying the separation of concerns principle. We have therefore employed aspect oriented programming (AOP) to build collaboration based designs. We illustrate and discuss our aspect oriented approach both for the horizontal (i.e. the collaborations) and vertical (i.e. the refinements) dimensions. Although the example implementations are based on AspectJ0.4beta7 from Xerox PARC, the approach is generic enough to be implemented using other AOP techniques.

Reusable industrial control systems

Industrial control hardware may be reused for several purposes. The same industrial PC type may control the drives of a portal system, act as a programmable logic controller, or control any other device. Moreover the same piece of hardware may control different device types at the same time in concurrency. In this paper, we discuss four successive software engineering approaches to exploit the possibilities provided by the control hardware: an object-oriented architecture, an architectural pattern, a control framework, and an architectural model for component-based frameworks. Each of these approaches provides means of different levels to structure a system and to reuse concepts, patterns, or real code. All presented approaches are used to build control systems controlling different types of robot arms and other devices. Additionally, in the component-based system a new component has been introduced to enable a network connection of the control system.

InterMarket - towards intelligent mobile agent e-marketplaces

This paper presents work-in-progress towards the development of an intelligent mobile agent-based e-marketplace system called InterMarket. InterMarket aims at enabling mobile access and automated trading in e-marketplaces based on integration of mobile agents and intelligent decision-making agents offered as an add-on component to a commercial e-marketplace platform. The paper overviews the proposed solution and approach for InterMarket, and relates it to the existing research on mobile e-commerce agents and intelligent agent-mediated e-commerce.

Checkable graphical business process representation

There are different model types to model business processes, like ARIS models, BPMN or UML activity diagrams. These models are well elaborated. Moreover, almost all commercial systems or web-based systems are driven by their dynamic behavior which needs to be described precisely by the business process models. The challenge is the validation of these business process models against behavioral dynamic rules. However, the question is what is to be checked in detail and how this is represented in the models and how the results of the checks are displayed. In the paper we present a graphical representation supporting the checking business process models. A graphical specification of business rules and regulations is presented which allows to display both the business process models and the rules in one graphical editor. Both models are transformed into a formal language which may be processed by a verification tool - a model checker in our case. The graphical representation is realized with Eclipse which allows to integrate different other verification systems and to extend the current implementation.