Papers by Lodewijk Bergmans
Joop, 2005
Join point models are one of the key features in aspectoriented programming languages and tools. ... more Join point models are one of the key features in aspectoriented programming languages and tools. They provide software engineers means to pinpoint the exact locations in programs (join points) to weave in advices. Our experience in modularizing concerns in a large embedded system showed that existing join point models and their underlying program representations are not expressive enough. This prevents the selection of some join points of our interest. In this paper, we motivate the need for more fine-grained join point models within more expressive source code representations. We propose a new program representation called a program graph, over which more fine-grained join point models can be defined. In addition, we present a simple language to manipulate program graphs to perform source code transformations. This language thus can be used for specifying complex weaving algorithms over program graphs.
Constructing reusable components with multiple concerns
Separating and Managing Dependent Concerns Separating Statechart Implementations from Base Code in an Embedded System
ABSTRACT
Composing Concurrent Objects-Aplying Composition Filters for the Development And Reuse of Concurrent Object-Oriented Programming
Meta-data annotations and AOP are a powerful combination. Several aspect-oriented languages alrea... more Meta-data annotations and AOP are a powerful combination. Several aspect-oriented languages already support the use of annotations as a selection criterion in pointcut designators. Some languages also support the introduction of annotations using aspect-oriented techniques. This paper describes a combination of these techniques as they are implemented in Compose*, our aspect-oriented language. The use of a powerful selector language in Compose* is combined with a mechanism to superimpose annotations. The combination of these techniques enables us to specify the derivation of annotations. Derivation relations between annotations lead to dependencies between selector expressions.
Object-Oriented Development: Problems and Solutions
Because the eld of parallel computer systems evolves rapidly, most parallel software has the oppo... more Because the eld of parallel computer systems evolves rapidly, most parallel software has the opportunity to live longer than the hardware it was designed for. This opportunity is not always exploited in practice, because most applications are not portable between di erent parallel platforms. An attempt to solve this problem has been the development of more or less standardized methods for parallel operating systems. This approach makes software more portable, but cannot fully exploit the computational power of the hardware. This is caused by the genericity of the standardized interface between application software and operating system. Most manufacturers therefore add routines for actions that their hardware can perform more e cient, but with the penalty of reduced portability. To overcome the above problems, this Master's thesis presents ParMod, a framework for encapsulating many types of already existing parallel techniques and tools. ParMod generates an extension to hardware and rmware that is ne-tuned for e cient execution of a given application on a speci c machine. The objective of this research project is nding a generic description that captures all parallel and distributed architectures that exist or are likely to be built in the future. This description is exploited for mapping concurrent programs onto any of these architectures, without loss of e ciency. To make this possible, ParMod is generic with respect to the target architecture and source code language. Furthermore, it is possible to extend ParMod with techniques for optimizing or simulating some desired functionality in a portable way without recompilation of the ParMod system. ParMod models its problem domain in a set of orthogonal object oriented frameworks. Orthogonality makes decomposition of problems easier, while the object oriented nature of the framework allows for specialization of generic descriptions, by simply inheriting them. A part of ParMod which is actually just support of the rest of the system, but seems rather promising, is the object oriented compiler framework, which allows for desirable features like source language independent code generation and attribution, or extensibility of a language's syntax and semantics without the need to extend any other compiler part in many cases. 3 4 Bedankt Afstuderen lijkt in vele opzichten op het zoeken naar de weg in een doolhof. Je weet waar je begint, je weet waar je heen wilt, maar hoe je er komt is maar de vraag. Er zijn vele uitgangen bij leuke buitenhuisjes, maar het liefst beland je natuurlijk bij de hoofduitgang, bij het kasteel. Het doolhof zit vol met valkuilen die je tijdelijk of de nitief uit kunnen schakelen. Gelukkig hoef je het hele doolhof niet in je eentje te verkennen. Vele mensen hebben me daarbij gesteund. In de eerste plaats natuurlijk mijn ouders, Harry en Willy van Rein, die me op de wereld hebben gezet, en altijd blijk hebben gegeven van steun en vertrouwen. Ook hun steun om te gaan studeren is erg belangrijk voor me geweest. Dankzij hun heb ik ontdekt dat er zoiets als een doolhof bestaat. Verder is het prettig als je, al lopende in het doolhof, af en toe wordt bijgestuurd wanneer je een verkeerde richting in wilt slaan. Dit is mogelijk doordat die mensen al wat langer in het doolhof ronddwalen; sommige zitten er nog! Dit betreft natuurlijk mijn begeleiders: Lodewijk Bergmans, Mehmet Aksit, Pierre Janssen en Satoshi Matsuoka. Speciaal wil ik Lodewijk bedanken voor de enorme positieve houding (en dus motivatie) die hij uitstraalde, en zijn onvermoeibare bereidheid om met me mee te lopen, eventueel tot in de nauwste steegjes en kleinste uithoeken van het doolhof. Bram van der Waaij heeft me regelmatig teruggebracht naar het rechte pad in mijn doolhof, omdat ik weer eens op een luchtkasteel af liep in plaats van naar het echte kasteel aan de hoofduitgang.
This CW report contains the proceedings of ADI08, the 3rd International Workshop on Aspects, Depe... more This CW report contains the proceedings of ADI08, the 3rd International Workshop on Aspects, Dependencies and Interactions. The workshop has been organized by the authors of this report:
Aspects of AOP: Scalability and application to domain modelling
A Notation for Describing Conceptual Architectures
Issues in Multiple-Client-Multiple-Server Synchronizations
For years the Aspect Oriented Software Development community has promoted aspects as a solution t... more For years the Aspect Oriented Software Development community has promoted aspects as a solution to complexities introduced by implementing crosscutting concerns. And while a lot of research focuses on advancing the state of the art of aspect oriented programing and design, there is still no (reported) wide-spread industrial adoption of Aspect Oriented Programming. In this paper we report on an experiment to quantify the aspect-based approach to Tracing. The experiment was performed in an industrial setting at ASML. We believe that the example is a stereotypical aspect-oriented problem and as such the results of this experiment are very likely generalizable to other aspects. Participants of the experiment were requested to carry out five simple maintenance scenarios, related to Tracing. The result of this experiment demonstrates 6% and 77% reduction in development effort and errors, respectively. The statistical significance analysis has confirmed these reductions for a subset of the individual scenarios.
A considerable number of language mechanisms have been proposed during the last several years, to... more A considerable number of language mechanisms have been proposed during the last several years, to specify and implement concurrent object-oriented programs. The major concern of these proposals is to design an expressive language that provides extensible concurrent processing and synchronization features. Almost all these efforts, however, have focused on the multiple-clientsingle-server model where each server determines its synchronization semantics without cooperating with other objects. We believe that object-oriented concurrent languages must not only support a single-server model, but cooperatively synchronizing servers as well. We refer to this as multi-server synchronization. This paper first classifies multi-server synchronization in five categories. The intention here is to define a framework for evaluating current approaches and identifying the requirements for designing new languages. In addition, this paper presents a composable multi-server synchronization technique, adopting the concept of composition-filters.
Historically, programming languages have been-although benevolent-dictators: fixing a lot of sema... more Historically, programming languages have been-although benevolent-dictators: fixing a lot of semantics into built-in language constructs. Over the years, (some) programming languages have freed the programmers from restrictions to use only built-in libraries, built-in data types, or built-in type checking rules. Even though, arguably, such freedom could lead to anarchy, or people shooting themselves in the foot , the contrary tends to be the case: a language that does not allow for extensibility, is depriving software engineers from the ability to construct proper abstractions and to structure software in the most optimal way. Instead, the software becomes less structured and maintainable than would be possible if the software engineer could express the behavior of the program with the most appropriate abstractions. The new idea proposed by this paper is to move composition from built-in language constructs to programmable, first-class abstractions in the language. As an emerging result, we present the Co-op concept of a language, which shows that it is possible with a relatively simple model to express a wide range of compositions as first-class concepts.
Commercially available middleware systems today offer best-effort Quality-of-Service (QoS) to the... more Commercially available middleware systems today offer best-effort Quality-of-Service (QoS) to the application programs. Due to the natural limitation of resources and the differences between the priorities and demands of applications, middleware systems must have the capability to offer varying degrees of QoS. The QoS requirements of middleware applications can be monitored and fulfilled by configuring the middleware [1]. This could be implemented, for example, by encapsulating the specific QoS concerns of middleware within the components and by installing the most suitable component on a particular QoS demand. Unfortunately, not all the QoS concerns of a distributed system [2] can be defined and encapsulated by the interfaces of components. So-called crosscutting aspects [3] hinder the adaptation of middleware systems since the implementations of QoS support techniques cannot be restricted to the implementations of components.
It is generally acknowledged that separation of concerns is a key requirement for effective softw... more It is generally acknowledged that separation of concerns is a key requirement for effective software engineering: it helps in managing the complexity of software and supports the maintainability of a software system. Separation of concerns makes only sense if the realizations in software of these concerns can be composed together effectively into a working program. The ability to compose systems from independently developed components that can be adapted and extended easily is a long-standing goal in the software engineering discipline. However, both research and practice have shown that composability of software is far from trivial and fails repeatedly. Typically this occurs when components exhibit complex behavior, in particular when multiple concerns are involved in a single component. We believe that, to address the composability problems, we need a better understanding of the requirements involved in successful composition, and in addition define the situations where composition fails. To this aim, in this paper we introduce a number of requirements for designlevel composability and define a category of composition problems that are inherent for given composition models, which we term as composition anomalies.
Aspect-oriented programming (AOP) has received considerable interest, in particular as an extensi... more Aspect-oriented programming (AOP) has received considerable interest, in particular as an extension of object-oriented programming. However, current object-oriented software design techniques, such as UML, are not well suited to cope with aspect orientation. In this paper we discuss a design approach, called CoCompose, which supports aspect orientation and software evolution. The CoCompose design language adopts a generic concept construct for describing software systems. Design-level relationships between concepts can be expressed by applying the parameterised feature construct. Complete CoCompose models can be translated into executable programs using an automatic translation process.
Uploads
Papers by Lodewijk Bergmans