Composition Filters & Compose*
/ WebHome / Composer.ComposeStarDocumentation
Composition Filters & Compose* 
This thesis is organized as follows. In chapter 2 some background and the problem statement (2.4) are introduced. A small summary about Aspect Oriented Programming (2.1), an overview of the Composition Filters Model and the previous its implementations (2.2),and some work that is related to this one (2.5) make part of this background. In chapter 3 the Compose* System is presented. The requirements of the project (3.1), its design (3.2), and implementation (3.3). Finally, in chapter 4, the product of this project is evaluated (4.1), some concluding remarks (4.2) and proposals for future work (4.3).thesisCarlosNoguera.pdf
This thesis presents a solution for detecting [conflicts in the purpose or side-effects of the aspects]. In order to detect such conflicts a higher level of abstraction is needed. An abstract model is used to encapsulate the areas where aspects conflict. The transformation from aspects to a model is extremely difficult when aspects are expressed in a full programming language like AspectJ?. In this case one has to be able to reason about the actual source code and to extract the relevant information.Master_Thesis_Pascal_Durr.pdf
Concerns accepting all the methods of one of its internal or external objects is is a sub-type of that type called concern subtyping. It is desirable to be able to use this concern where one of its super types are expected. The objective of this thesis is to bridge the interface mismatch in such a way that .NET compilers may compile Compose* projects while retaining their type checking capabilities and to allow concern subtyping.frederik_thesis.pdf
The first part of this thesis discusses the design decisions and implementation that is used to achieve two objectives: firstly, to make the exchange of data between modules possible. Secondly, to allow the Composition Filters specifications to be used as the main input into Compose*. The second part discusses what features in the Composition Filters model are lacking and which can be improved. It also discusses how they can be integrated in the Composition Filters specification, and how several of these features can be implemented in the Compose* design.vinkes.thesis.pdf
The objective of this thesis is to find a solution to reason about composition filters at compile-time. Our approach transforms the filter set to a Message-Action Tree. This tree represents the filter set by mapping incoming messages and conditions to a set of actions. These actions describe the triggered filters, message substitution, and signature matches. Compile-time modules use this Message-Action Tree to reason about the given filter set. This approach is implemented as a tool called: Filter Reasoning Engine (FIRE).MasterThesis_RaymondBosman.pdf
This thesis describes a new superimposition selector language based on predicate logic. Selectors written in this language specify where filtermodules have to be superimposed based on the static structure of an application. The selector language is independent of any implementation language because it uses an abstract language model to represent the language model used in Compose*.mastersthesis_whavinga.pdf
Since the Meta-filter enables a programmer to do practically anything with a message, it is no longer possible to reason with the behavior of the filter. This means that conflicts that might occur between filters can no longer be detected. In this thesis the definition of Advice Types (ACT) is enhanced and a solution is presented to specify the behavior of the ACT so that the system can reason about the definition of the meta-filter. Also, the run-time filtering system is extended to support the definition of ACTs.MasterThesisTomStaijen.pdf
The Compose* project offers aspect-oriented programming in Microsoft .NET through the composition filters model. Using the filters a developer can specify the weaving points but only to a certain level. For example; using the ‘set**’ filtering to find all the methods with the word ‘sett’ in their name will also select methods like ‘setupp’. We only want to select methods which are actually setting (assigning) a value to a variable. This type of semantic information is not directly available. There is an implementation in Compose* where the developer can specify the resource usage in a method using custom attributes. This information is currently only used to detect possible semantic conflicts between aspects. This thesis describes how to automatically extract semantic information from Common Intermediate Language (CIL) assemblies using static code analysis. In particularly information about resources (read/write operations), method calls, control flow and branching has been gathered from the compiled source code with the use of existing tools. The derived behavioral information about a program can be used to specify more detailed weaving points in Compose* and to aid in the detection of potential conflicts among aspects.thesis_mdwvanoudheusden.pdf
AOP shows improvements in modularity, despite some shortcomings in expressiveness. Some of the shortcomings are the arranged patterns problem and the problem of jumping aspects. The arranged patterns problem is caused by tight coupling between a concern and the program. This tight coupling harms evolvability of the program and the reusability of the concern. Jumping aspects is a crosscutting phenomenon which occurs because code needs to be added to components depending on their usage context. The problem with manually coding an applicability control-mechanism into concern code, is that one is patching the weak expressiveness of the join point model. To solve these shortcomings in this thesis, a fine-grained join point model is proposed which represents join points by events emitted during program execution. A pattern language is presented to match events against predefined patterns. This allows for context-sensitive crosscutting beyond the level of object interfaces. Events are monitored at run-time by a local monitor which can receive events from its associated object, therefore encapsulation of objects is respected. Events are checked for matches using finite state automata and by remembering state in between method calls to an object. If a pattern matches, a set of event filters is evaluated to determine which advice to invoke. A constraint model is proposed, not only to resolve conflicts at shared join points, but also to prevent conflicts depending on the result of earlier invoked concerns.mastersthesis_olaf_conradi.pdf
Compose* is a research programming language, this means that the syntax changes more often then an industrial programming language. For each new feature an addition is made to the syntax and this has lead to the situation that the syntax has several redundant parts. In order to get the syntax streamlined again and to fix some major issues an analysis and redesign of the Compose* language is in place. The analysis of the language will form the basis for the Compose* Annotated Reference Manual and will cover both syntax and semantics. The redesign will focus on increasing reusability and expressiveness while keeping the syntax as concise as possible. Reusability of code written in Compose* will be improved with the introduction of filter module parameters. These can be compared with parameters as in an object-oriented programming language. The increase of expressiveness is achieved with replacing the old filter specification with a new canonical form.thesis_dirk_doornenbal.pdf
Compose* is a project that provides aspect-oriented programming for object-oriented languages by using the composition filters model. In particular, Compose*.NET is an implementation of Compose* that provides aspect-oriented programming to Microsoft Visual Studio languages. The compilation process of Compose*.NET contains multiple compilation modules. Each of them has their own responsibilities and duties such as parsing, analysis tasks and weaving. However, all of them suffer from the same problem. They do not support any kind of incrementality. This means that they perform all of their operations in each compilation without taking advantage of the results and efforts of previous compilations. This unavoidably results in compilations containing many redundant repeats of operations, which slow down compilation. To minimize these redundant operations and hence, speed up the compilation, Compose* needs an incremental compilation process. Therefore, we have developed a new compilation module called INCRE. This compilation module provides incremental performance as a service to all other compilation modules of Compose*. This thesis describes in detail the design and implementation of this new compilation module and evaluates its performance by charts of tests.thesis_drspenkelink.pdf
Software design patterns describe design solutions for recurring problems. Many wellknown software design patterns exist for the object-oriented paradigm. These patterns can be applied and implemented for a concrete problem context. The implementation of the pattern is an instantiation of the pattern that depends on the object-oriented programming language and its language constructs. The implementation of patterns often results in crosscutting code, because pattern code is often scattered over several application classes and tangles with application behavior. Aspect-oriented programming allows to modularize crosscutting concerns and improves separation of concerns. Currently, aspect-oriented programming is being applied to object-oriented design patterns. This has the potential to modularize crosscutting pattern code and to improve pattern implementations. Two approaches we consider in this thesis are AspectJ? and Compose*. This thesis discusses characteristics of several patterns and identifies problems that exist in object-oriented Java implementations. These problems consist of problems inherent to all patterns, and problems specific to certain patterns. The use of aspect-oriented languages may solve some of the problems related to Java implementations. Therefore we discuss whether AspectJ? and Compose* can improve Java design pattern implementations. From the discussion about pattern characteristics and problems we discuss complete pattern implementations in AspectJ? and Compose*. Also, the relation between languages and design patterns is discussed.MasterThesisStephanHuttenhuis.pdf
Recent research has shown that crosscutting concerns are not an object-oriented problem, but that such concerns are also troublesome in C. This thesis presents the development of an aspect-oriented weaver for C, based on the Composition Filters approach.ThesisJWteWinkel.pdf
The behavior of computer programs can be hard to understand because of the execution complexity of a program. Because of the composition of programs with composition filters and/or other aspect oriented languages the execution in computer programs can be even more complex and therefore even more difficult to understand. Besides the increased difficulty we also found that the conventional debugging tools and techniques are less suitable for use within aspect oriented programming. This report will concentrate on improving the representation, editing, compiling, and debugging of composition filter programs while remaining extensible and programming language independent. The primary focus will be on the debugging of composition filter programs within the Compose* framework. We approached the breakpoint issue by allowing the programmer to set breakpoints on the behavior of a program, to allow the programmer to see how the execution of the implementation behaves. This behavior of the program can be specified with use of the proposed LTL breakpoints. We approached the comprehensibility problem by a proposed Composition Filter representation. Because of the sound conceptual model of Composition Filters, if the side effects of a filter are limited to a message, the behavior becomes stutter equivalent. This stutter equivalent behavior can be used to reduce validations and allows a representation of a complete filters evaluation at a joinpoint.thesis_rolf_huisman.pdf
Aspect oriented programming improves the quality of software by allowing a better separation of concerns. Composition filters is a delegation based AOP approach. It introduces advice by filtering messages sent between objects. The declarative syntax of composition filters opens possibilities for powerful reasoning about the behavior of a set of filters. This reasoning includes control flow analysis. But control flow analysis is only the basis of a much more powerful reasoning technique, called message flow analysis. Message flow analysis reasons about the behavior of a filter set for a specific message. It is a combination of control flow analysis and data flow analysis on the message entity. Message flow analysis brings opportunities for powerful conflict detection techniques, analyzing concern signature modifications, inlining of a set of filters and more. This thesis presents a new approach to message flow analysis, called the message flow simulation approach. This new approach improves upon existing approaches, like the message-action tree approach, by providing better granularity, traceability and efficiency. This thesis also works out four different applications of filter reasoning. First, it explains how consistency reasoning can do better reachability analysis and how the results from message flow analysis are used to create a cause and effect relationship between consistency conflicts. Second, it explains how message flow analysis is used to analyze signature modification. Third, it explains how message flow analysis makes behavioral reasoning more precise and more efficient. Finally, it explains how message flow analysis is used to translate a filter set to executable code, which can be woven in the base program.Thesis_AJdeRoo.pdf
Compose* is a project that aims at enhancing the power of component- and object-based programming,so that software becomes easier to structure and modularize, hence easier to develop,maintain and extend. In particular, Compose* offers aspect-oriented programming through the composition filters model. One goal of the Compose* project is to familiarize a large audience with the concept of the composition filters model. Currently, Compose* runs on the .NET platform and C platform. This thesis describes in detail the process of porting Compose* to the Java platform, resulting in Compose*/J. Since Compose* is a language and platform independent solution, some of the key Java features might not be supported by the composition filters model. Therefore, this thesis also investigates the possibility of supporting specific Java features in Compose*/J. First, it discusses the possibilities for modularizing exception handling with composition filters. Second, it discusses the possibilities for expressing crosscutting concerns on inner classes. Finally, it discusses the possibilities and benefits for weaving on Java interfaces.thesis_rdspenkelink.pdf
Although the composition filter model solves some problems, it introduces new problems. The base program is modified by multiple concerns scattered across files. Concerns can affect multiple objects and messages. Objects and messages can be affected by multiple concerns. This results in a more difficult to understand system for the developer. Which can lead to broken programs because of conflicts in the filter constructions. Filters can create relations between two join points. These relations can be a source for filter conflicts. These conflicts are very difficult to find, because they are the result of code scattered cross multiple files and concerns. This thesis presents an approach that will enable the ability to reason about the filter constructions beyond the scope of a single join point. This approach will aid the existing filter reasoning in Compose*, and enable reasoning about the relations between concerns. With the improved reasoning the program can be more thoroughly analyzed for problems. This thesis also presents models for the visualization of various parts of the composition filter program. This will provide the developer graphical feedback of the system under design. It will make it easier for the developer to understand how and what filters affect the program.thesis_michiel_hendriks.pdf
This thesis consists of two parts. First, it presents a new solution to add support for signature modification to the compilation process of Compose*/.NET. Second, it presents an evaluation of extending the filter analysis part of Compose* to include full behavioral analysis of the program. The old solution that added support for signature modification to Compose*/.NET was found to be incompatible with the standard .NET 2.0 compilers. Furthermore, it is language dependent and lacks the support for self-referencing types. The current implementation of Compose*/.NET 2.0+ does not support signature modification. A new solution is presented, that improves on the existing Compose*/.NET 2.0+ implementation. The improved compilation process introduces support for signature modification, is compatible with the .NET 2.0 compilers, is language independent and bettermaintainable than the previous solution. It does not add support for self-referencing types. This thesis also presents an evaluation of extending the behavioral analysis performed by Compose*. The behavior of a type can be altered by the applied composition filters. The current behavioral analysis is limited to the behavior of composition filters. It describes this behavior with the resource-operation model. The behavioral analysis could be extended to include the behavior of the source code. This would enable Compose* to detect composition filters that introduce conflicting behavior to a type. The resource-operation model was found to be too generic and too abstract to be used to describe the behavior of a program. Extending the existing behavioral analysis to include analysis of source code is therefore difficult to achieve. An alternative is presented that extends the behavioral analysis to detect possible behavioral conflicts. This analysis is more limited than full behavioral analysis, but is easier to implement.ThesisRolfJongeling.pdf
Attachment  | Action | Size | Date | Who | Comment |
|---|---|---|---|---|---|
 ChapterCompFiltsCRCfull.pdf | manage | 547.2 K | 10 Sep 2003 - 13:28 | LodewijkBergmans | chapter in forthcoming AOP book |
| CACM-oct2001.pdf | manage | 141.4 K | 15 Sep 2003 - 08:45 | LodewijkBergmans | published in omm. of the CACM, October 2001 |
| ch12_composition_filters.pdf | manage | 284.1 K | 15 Sep 2003 - 09:14 | LodewijkBergmans | in Software Architectures and Component Technology |
| CF_overview_chap2.pdf | manage | 684.3 K | 15 Sep 2003 - 09:26 | LodewijkBergmans | |
| frederik_thesis.pdf | manage | 834.3 K | 06 May 2004 - 12:13 | DurrP | The master thesis of Frederik Holljen |
| Master_Thesis_Pascal_Durr.pdf | manage | 1334.9 K | 06 May 2004 - 12:15 | DurrP | Master thesis of Pascal Durr |
| thesisCarlosNoguera.pdf | manage | 552.5 K | 14 Sep 2004 - 08:44 | LodewijkBergmans | |
| GrammarExplained.pdf | manage | 317.2 K | 14 Sep 2004 - 08:47 | LodewijkBergmans | Explanation of the grammar |
| vinkes.thesis.pdf | manage | 1334.9 K | 07 Nov 2004 - 10:52 | ChristianVinkes | |
| MasterThesis_RaymondBosman.pdf | manage | 1113.4 K | 15 Nov 2004 - 10:40 | DurrP | Master thesis of Raymond Bosman |
| mastersthesis_whavinga.pdf | manage | 2483.2 K | 23 Aug 2005 - 15:08 | HavingaW | Masters thesis of Wilke Havinga |
| MasterThesisTomStaijen.pdf | manage | 1103.5 K | 24 Nov 2005 - 12:16 | DurrP | Master Thesis Tom Staijen |
| salinas_thesis.pdf | manage | 1084.9 K | 02 Feb 2006 - 14:25 | DirkDoornenbal | Thesis of Patricio Salinas |
| bergmans.phd.pdf | manage | 3418.1 K | 23 Aug 2006 - 13:33 | MichielHendriks | Ph.D. thesis of Lodewijk Bergmans |
| thesis_mdwvanoudheusden.pdf | manage | 3123.1 K | 31 Aug 2006 - 11:26 | MichielVanOudheusden | Thesis of Michiel van Oudheusden |
| mastersthesis_olaf_conradi.pdf | manage | 1654.9 K | 04 Sep 2006 - 14:41 | OlafConradi | Master's thesis of Olaf Conradi |
| ComposeStargrammar0.5f.pdf | manage | 73.5 K | 11 Oct 2006 - 15:43 | DirkDoornenbal | 2 page grammar reference card for release 0.5.5 |
| thesis_dirk_doornenbal.pdf | manage | 2896.8 K | 02 Nov 2006 - 13:30 | DirkDoornenbal | Master's thesis of Dirk Doornenbal |
| thesis_drspenkelink.pdf | manage | 1976.7 K | 28 Nov 2006 - 09:59 | DennisSpenkelink | Thesis of Dennis Spenkelink |
| MasterThesisStephanHuttenhuis.pdf | manage | 1420.9 K | 29 Nov 2006 - 10:56 | StephanHuttenhuis | Master's thesis of Stephan Huttenhuis |
| ThesisJWteWinkel.pdf | manage | 4626.3 K | 18 Dec 2006 - 19:25 | OlafConradi | Master's thesis of Johan te Winkel |
| Thesis_AJdeRoo.pdf | manage | 2759.4 K | 11 Apr 2007 - 13:13 | ArjanDeRoo | Thesis of Arjan de Roo |
| thesis_rdspenkelink.pdf | manage | 1656.4 K | 05 Jul 2007 - 11:15 | RoySpenkelink | Thesis of Roy Spenkelink |
| thesis_michiel_hendriks.pdf | manage | 3470.6 K | 27 Aug 2007 - 11:02 | MichielHendriks | Thesis Michiel Hendriks |
| thesis_rolf_huisman.pdf | manage | 2139.3 K | 12 Mar 2008 - 11:12 | MichielHendriks | Master thesis of Rolf Huisman |
| ThesisRolfJongeling.pdf | manage | 2160.5 K | 29 Aug 2008 - 10:00 | MichielHendriks | Master thesis van Rolf Jongeling |