Events

MDAFA 2004 paper presentation: Context-Driven Model Refinement
When:	2004-06-29 12:30:05
Where:	Linköping, Sweden
Link:	http://www.ida.liu.se/~henla/mdafa2004/
Posted by:	Dennis Wagelaar
ABSTRACT An important drive for Model-Driven Software Development is that many software applications have to be deployed on a variety of platforms and within a variety of contexts in general. In order to reuse software within different contexts, it is necessary to abstract away from the context. Using software models, e.g. described in UML, one can abstract from specific platforms. A software model can then be refined, given the context in which it should run. In UML models, however, it is not possible to abstract away from the pre-defined language constructs - most notably modularisation constructs - since stereotypes only allow for extending them. This prematurely eliminates alternative model refinements, which can unjustly prevent the software from working within specific contexts. In addition, model refinements must currently be chosen manually. As the number of elements to be refined and the number of possible refinements increases, this becomes less feasible. We propose a context-driven modelling framework that can automatically choose and apply model refinements. It uses a modelling language based upon generic concepts. A number of possible refinements can be defined for each of these concepts. These refinements are annotated with context data that specify the constraints within which the refinement will work. Refinements are chosen and applied automatically based upon this context data.

DARES 2004 paper presentation: Towards a Context-Driven Development Framework for Ambient Intelligence
When:	2004-03-23 10:00:00
Where:	Tokyo, Japan
Link:	http://dares.enst-bretagne.fr/dares2004/
Posted by:	Dennis Wagelaar
ABSTRACT Portable and embedded devices form an increasingly large group of computers, often referred to as Ambient Intelligence (AmI). This new variety in computing platforms will cause a corresponding diversity in software/hardware platforms and other context factors. Component-based middleware platforms offer a uniform environment for software, but they do not take away specific context differences, such as hardware resources, user identity/role and logical/physical location. Specialised component versions and/or configurations have to be made for each computing context if that computing context is to be used to its full extent. This is because the fine differences between component versions cannot be separated into finer components with the current component models. Aspect-oriented programming and generative programming technologies can be used to provide the fine-grained modularity that is necessary. In addition, the diversity of component-based platforms themselves form an extra reason for different component versions. We propose using a context-driven framework for the development of AmI components, which is based upon a gradual refinement mechanism. This refinement mechanism can cope with the course-grained differences between component models as well as the fine-grained differences between computing configurations. The slides for this presentation are available in the following formats: [OpenOffice] [Adobe PDF]

SEA 2003 paper presentation: A Concept-Based Approach to Software Design
When:	2003-11-03 00:00:00
Where:	Marina del Rey, USA
Link:	http://iasted.org/conferences/2003/marina/sea.htm
Posted by:	Dennis Wagelaar
ABSTRACT The initial design of software systems is modelled using conceptual design language elements. When a refined version of the design is made, each of the original (conceptual) elements is replaced by the refined element(s). Other feasible refinements are eliminated prematurely. This paper presents a software design approach, called CoCompose, that allows for defining several, layered, alternative refinements for each element in a design. The refinements are represented as structures of existing design language constructs, which makes it possible to address advanced software development technologies such as aspect-oriented programming, component-based development and design patterns without introducing new design language constructs. CoCompose uses an automated translation process to determine which refinements to use and to generate an implementation. The slides for this presentation are available in the following formats: [OpenOffice] [Adobe PDF]

AOSD 2003 Demo: From Aspect-Oriented Design with Concepts to Aspect-Oriented Programming with Composition Filters
When:	2003-03-20 16:00:00
Where:	Boston, USA
Link:	http://aosd.net/archive/2003/program/d8.shtml
Posted by:	Dennis Wagelaar
Dates: - Thu March 20, 16:00 - 17:30 - Fri March 21, 09:00 - 10:30 Presenters: - Lodewijk Bergmans (University of Twente) - Dennis Wagelaar (Vrije Universiteit Brussel) Composition Filters are an extension to the object-oriented model that address a number of modeling obstacles that conventional object-oriented techniques cannot address or can only solve with poorly maintainable designs. The Composition Filters approach can be classified as an aspect-oriented approach, which integrates aspects and classes, retains strong encapsulation, and supports composability. ComposeJ is a tool that takes Java classes and (separate) composition filters specifications, and transforms the Java classes so that they implement the behavior as specified in the composition filters specification. Like OOP, the benefits of Aspect-Oriented Programming can only be exploited through appropriate design methods & tool support; CoCompose is a design tool that addresses this. The main characteristic of CoCompose is that it is visual, concern-oriented (i.e. supports the modeling of software as independent, possibly crosscutting, concerns) tool that allows for recursive definition and reuse of concerns. Concerns in the design phase may be similar to entities or classes, or to single operations, or even to complete design pattern templates. A single concern may in fact have several implementation forms; during code generation, the best possible (interoperating) combination of forms is selected. Thus, CoCompose works as a design tool that can generate the 'best' possible program from a concern-based design (if the concerns include one or more implementations). During the demonstration, we will show how the design of a particular example problem can be approached in a concern-oriented manner and modeled with CoCompose. We will demonstrate how CoCompose can generate implementations in several programming languages (esp. Java and composition filters). One of the important points of this demonstration is to argue that, even with the ability ot generate code, the composability of the target language is important in order to retain the structure of the design, and hence the ability to revise and extend the design in an incremental manner. In particular, we will look at generated Composition Filters code, illustrate that it is structurally close(r) to the design, and explain the basic Composition Filter mechanism. We will demonstrate our tool Compose/J that translates combined Composition Filters/Java code into pure Java code. One of the interesting features of Compose/J that we will highlight (and show) is the ability of generating optimized (i.e. inlined) code from a declarative specification.

OOPSLA 2002 Demo: Towards Seamless Aspect-Oriented Design & Programming with CoCompose & ComposeJ
When:	2002-11-07 15:00:00
Where:	Seattle, USA
Link:	http://oopsla.acm.org/fp/files/dem-25.html
Posted by:	Dennis Wagelaar
Lodewijk Bergmans University of Twente Mehmet Aksit University of Twente Dennis Wagelaar University of Twente Richard van de Stadt University of Twente Hans Wichman TRIMM Luigi Savarese University of Twente Composition Filters are an extension to the object-oriented model that address a number of modeling obstacles that conventional object-oriented techniques cannot address or can only solve with poorly maintainable designs. The Composition Filters approach can be classified as an aspect-oriented approach, which integrates aspects and classes, retains strong encapsulation, and supports composability. ComposeJ is a tool that takes Java classes and (separate) composition filters specifications, and transforms the Java classes so that they implement the behavior as specified in the composition filters specification. Like OOP, the benefits of Aspect-Oriented Programming can only be exploited through appropriate design methods & tool support; CoCompose is a design tool that addresses this. The main characteristic of CoCompose is that it is visual, concern-oriented (i.e. supports the modeling of software as independent, possibly crosscutting, concerns) tool that allows for recursive definition and reuse of concerns. Concerns in the design phase may be similar to entities or classes, or to single operations, or even to complete design pattern templates. A single concern may in fact have several implementation forms; during code generation, the best possible (interoperating) combination of forms is selected. Thus, CoCompose works as a design tool that can generate the best possible program from a concern-based design (if the concerns include one or more implementations). During the demonstration, we will show how the design of a particular example problem can be approached in a concern-oriented manner and modeled with CoCompose. We will demonstrate how CoCompose can generate implementations in several programming languages. In particular, we will look at generated Composition Filters code, illustrate that it is structurally close to the design, and explain the basic Composition Filter mechanism. We will demonstrate our tool Compose/J that translates combined Composition Filters/Java code into pure Java code.