AspectJ is an aspect-oriented extension to the Java™ programming language.

AspectJ enables the clean modularization of crosscutting concerns such as: design patterns, error checking and handling, synchronization constraints and performance optimizations.

HyperJ uses extra-linguistic mechanisms to specify the methods that are built into a join point. Join points are method invocations, and any method body can participate in any method call. No changes to existing languages are need and it supports an open-ended set of extensions. Disadavanges include little support for idiomatic extension patterns.

A very provocative mechanism for organizing the units of a program. Taken to extremes, it might provide a sound theortical basis for program composition.

Multi-dimensional separation of concerns enables the simultaneously encapsulation of all kinds of concerns in a software system. This specifically includes overlapping and interacting concerns. In contrast, object-oriented languages support the separation of object (or class) concerns, while functional languages permit the separation of function concerns. A wide range of other kinds of important concerns, such as features, aspects, units of change, versions, configurations, families or variants, etc., cannot be encapsulated at all. Further, many concerns overlap and interact with one another (i.e., they are not orthogonal); for example, a unit of change (one concern) may affect several classes (object concerns).

Hyperspaces are concern spaces with special structure and capabilities. They support our approach to multi-dimensional separation of concerns.

The composition filters object model introduces input and output composition filters which affect the received and sent messages respectively. The composition filters object model is class based: for an application consisting of a number of objects, all objects with common characteristics are instances of the same class. Objects are only specified on class level; this supports the creation of multiple instances and reuse through the inheritance mechanism.

Piccola is a small composition language based on the Pi Calculus. It has a small syntax and a minimal set of features needed for specifying different styles of software composition. The core features of Piccola are communicating agents, which perform computations, and forms, which are the communicated values. Forms are a special notion of extensible, immutable records. Forms and agents allow Piccola to unify components, static and dynamic contexts and arguments for invoking services.

Generative Programming (GP) is about designing and implementing software modules which can be combined to generate specialized and highly optimized systems fulfilling specific requirements. The goals are to (a) decrease the conceptual gap between program code and domain concepts (known as achieving high intentionality), (b) achieve high reusability and adaptability, (c) simplify managing many variants of a component, and (d) increase efficiency (both in space and execution time).

Adaptive software is object-oriented software that has been developed to support evolutionary development. Such software automatically adapts to changing contexts. Contexts may be behavior, implementation class structures, synchronization structures, object migration structures, etc. Adaptive programs are structure-shy, using only minimal information about the implementation-specific class structure to define behavior. The advantage of the structure-shy programs is that they express their intent at a high level of abstraction.

Stratification allows multiple levels of abstraction (strata) to organized and used in a systematic manner. Top level stata tend to resemble the outcome of a requirement analysis. The next stratum is created by refining interactions between the components of the higher level. The relationship between the strata is one of interaction refinement, which often introduces further components. All levels of abstraction are useful in a certain context. Someone trying to understand the overall structure of the system is best served with a high level view, while others may gain more from looking at the lower-level abstractions. As a consequence, stratified architectures do not single out one of the above views as the architecture, but deal with the entirety of all levels of abstraction. Each abstraction level is complete in its own right.

The gbeta language provides generics as an extension to the BETA language. These extensions allow a number of compositional behaviors within a convential language structure. One advantage is that the full compiler type validation system is available at composition time.