Abstract: Aspect-oriented programming provides the programmer with means to cross-cut conventional program structures, in particular the class hierarchies of object-oriented programming This paper studies the use of aspect orientation in structuring syntax directed compilers implemented as attribute grammars Specifically, it describes a method for specifying definitions of related attributes as 'aspects' and treating them as first-class objects, that can be stored, manipulated and combined It is hoped that this embedding of an aspect-oriented programming style in Haskell provides a stepping stone towards a more general study of the semantics of aspect-oriented programming

Abstract: This paper introduces GRS-based AOP which explains a large subclass of AOP weavers as graph rewrite systems (GRS). The corresponding class of AOP problems has a formal background since it inherits all features of graph rewrite systems such as criteria for termination, confluence, and unique normal forms. In particular, it it shown that different kinds of rewrite rules form different weaver classes. At least two of them (EARS and XGRS weavers) have simple semantics since they always yield unique weaving results.

Abstract: 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.

Abstract: Generative and Component-Based Software Engineering are approaches to reuse. Within both approaches the scope of reuse can vary between general purpose and application specific. We argue for scoping the reusable assets based on a product line. Domain analysis methods provide processes for determining the common and varying requirements for a product line. However, we experienced that existing methods have problems concerning applicability and instantiation support. Therefore, we have developed the Customizable Domain Analysis (CDA) method. CDA is customizable to the project context where it will be applied. This ensures that the method and workproducts used for modeling are appropriate for the specific needs. CDA also provides full instantiation support for specifying systems in the product line.

Abstract: The architecture of a component based environment for constructing scientific applications - generally referred to as a Problem Solving Environment (PSE), is described. Each component is a self-contained program, and may be a sequential code developed in C, Fortran or Java, or may contain internal parallelism using MPI or PVM libraries. A user visually constructs an application by combining components from a local or remote repository as a data flow graph. Components are self-documenting, with their interfaces defined in XML, which enables a user to search for components suitable to a particular application, enables a component to be configured when instantiated, enables each component to register with an event listener and facilitates the sharing of components between repositories. The data flow graph is also encoded in XML, and sent to a resource manager for executing the application on a workstation cluster, or a heterogeneous environment made of workstations and high performance parallel machines. Components in the PSE can also wrap legacy codes. We also describe the architecture and implementation of a molecular dynamics application based on the Lennard-Jones code [18], containing MPI calls, executed on a cluster of workstations, and based on our generic component model. A user can submit simulation data to the application remotely using a Java based user interface. Users need not download any softwares for the simulation and do not need to know the exact implementation.

Abstract: Current models for software components have made component-based software engineering practical. However, these models are limited in the sense that their support for the characterization/specification of software components primarily deals with syntactic issues. To avoid mismatch and misuse of components, more comprehensive specification of software components is required, especially in a scenario where components are dynamically discovered and used at run-time over corporate intranets and the Internet. Our approach to software component specification aims at comprehensive interface modelling/packaging for software components. It deals with the semantic, usage, quality as well as syntactic aspects of software component specification.

Abstract: Frameworks elevate encapsulation and reuse to the level of large-grained components, namely groups of collaborating classes. The abstract collaboration defined in a framework is easily customized by an application through static subclassing. However, this implies nonindependent development of the application and framework models and excludes the possibility of dynamically deploying the framework. We propose the dynamic composite adapter design pattern, which employs the use of Java inner classes to achieve dynamic, modular, non-invasive, component adaptation. We also present a new scoping construct for succinctly defining dynamic adaptation of Java components.

Abstract: Despite the obvious advantages of reuse implied by component technology, component based development has not taken off yet. Problems that inhibit general reuse include incomplete component contracts and (undocumented) dependencies of a component on the environment, which makes it hard to assess whether a component will behave in a particular setting as expected. In principle, a black-box approach to component deployment should be favored. In practice, however, we require information that cannot be described solely in terms of externally visible properties of components. For instance, non-functional properties (e.g., space and time requirements), environmental dependencies, and variation points (e.g., places where a component may be adapted or extended) do require insight in the internal construction of a component. In this paper, a grey-box approach to component deployment is discussed. It is based on a scenario-based technique called Use-Case-Maps (UCM), which uses scenarios to describe how several components operate at a high abstraction level. UCM is an informal notation. Its strong point is to show how things work generally. In order to reason about component compositions, we have augmented UCMs with formal specifications of component interfaces. These interface specifications have been borrowed from the concurrent, object-oriented language BCOOPL (Basic Concurrent Object-Oriented Programming Language). A BCOOPL interface is more than just a set of operations, it also describes temporal orderings of operations and the parties that are allowed to invoke a particular operation. The combination of UCMs and BCOOPL interfaces gives us the opportunity to document intra and inter component behavior at a high, but formal abstraction level.

Abstract: A trend in current research is towards component-based systems, where applications are built by combining re-usable fragments or components. In this paper we argue the case for building programming languages from components. We describe Vanilla, a component-based architecture for language tools. The core of Vanilla is a set of components, each implementing the type checking and behaviour of a single language feature, which are integrated within a well-structured framework to provide a programming language interpreter. Features may be extensively re-used across a variety of languages, allowing rapid prototyping and simplifying the exploration of new constructs. We describe the design and implementation of the system, and draw some general conclusions from the experience of building with components.

Abstract: Current definitions of "software component" are based on abstract data types -- collections of functions together with local data. This paper addresses two ways in which this definition is inadequate: it fails to allow for lightweight components -- those for which a function call is too ineffcient or semantically inappropriate -- and it fails to allow for generative components -- those in which the component embodies a method of constructing code rather than actual code. We argue that both can be solved by proper use of existing language technologies, by using a higher-order meta-language to compositionally manipulate values of type Code, syntactic fragments of some object language. By defining' a client as a function from a component to Code, components can be defined at a very general level without much notational overhead. In this paper, we illustrate this idea entirely at the source-code level, taking Code to be string. Operating at this level is particularly simple, and is useful when the source code is not proprietary. In a companion paper, we define Code as a set of values containing machine-language code (as well as some additional structure), allowing components to be delivered in binary form.

Abstract: Software applications, mostly consisting of an algorithm applied to domain knowledge, are hard to maintain and to reuse as a result of their hard coded combination We propose to follow the principles of aspect-oriented programming, separating the domain from the algorithm and describing them in a logic and conventional programming language respectively In this paper, we report on an experiment that was conducted to validate this hypothesis, and to investigate the requirements of a programming environment for this configuration An already existing environment that uses a logic meta-language to reason about object-oriented systems, SOUL, is used as a starting point for this experiment The result is a working implementation in SOUL, which validates our ideas, reveals mechanisms that require more research, and points to other features that should be included

Abstract: A well-known problem in program generation is scoping. When identifiers (i.e., symbolic names) are used to refer to variables, types, or functions, program generators must ensure that generated identifiers are bound to their intended declarations. This is the standard scoping issue in programming languages, only automatically generated programs can quickly become too complex and maintaining bindings manually is hard. In this paper we present generation scoping: a language mechanism to facilitate the handling of scoping concerns. Generation scoping offers control over identifier scoping beyond the scoping mechanism of the target programming language (i.e., the language in which the generator output is expressed). Generation scoping was originally implemented as an extension of the code template operators in the Intentional Programming platform, under development by Microsoft Research. Subsequently, generation scoping has also been integrated in the JTS language extensibility tools. The capabilities of generation scoping were invaluable in the implementation of two actual software generators: DiSTiL (implemented using the Intentional Programming system), and P3 (implemented using JTS).

Abstract: A novel argument binding mechanism that can be used with STL algorithm invocations is proposed. Without using any adaptors, binding can be applied directly to pointers to nonmember functions, pointers to const and nonconst member functions and STL function objects. The types and number of arguments in the functions to be bound can be practically arbitrary; argument list lengths up to few dozens of elements can be supported. The unbound arguments are expressed as special placeholders in the argument list; they can appear for any argument position. Hence, binding sites preserve the resemblance to the function prototype of the underlying function, leading to simple and intuitive syntax. Binding can be applied recursively. This results in a versatile function composition mechanism. The binding mechanism is effcient in the sense that it induces very little or no runtime cost.

Abstract: Recursive types definitions and pattern-matching are two useful built-in features of functional languages There is no such mechanism in the Java language In this article, we investigate different implementations to support these features in Java First, we review methods to define recursive types Then, we expose several approaches allowing to simulate pattern-matching on structures of these types Finally, we present re-use techniques for algorithms featuring this mechanism

Abstract: Reusable software based on design patterns typically utilizes "expensive" language features like object composition and polymorphism. This limits their applicability to areas where effciency in the sense of code size and runtime is of minor interest. To overcome this problem our paper presents a generative approach to "streamline" pattern-based object-oriented software. Depending on the actual requirements of the environment the source code is optimized with a transformation tool. The presented technique provides "scalable" software structures and thus reconciles reusability with effciency of pattern-based software.

Abstract: Automatic Programming (AP) systems have been used in a great variety of ways since the early days of software engineering. They have been used in AI related research approaches with the aim to generate computer programs from informal, incomplete, natural language-like specifications as well as in more pragmatic approaches related to 4th level languages. Terms such as "application generator", "transformational system", "code synthesizer", "generative software development" were used for naming various approaches to AP. This paper presents a categorization scheme for AP systems. In this categorization scheme, a clear distinction is made between the AI related, hard AP- and soft AP systems. After that, a broad range of AP systems as well as their position in the categorization scheme is presented. Finally we discuss the relation between AP and software reuse.

Abstract: Generative programming is widely used both to develop new programming languages and to extend existing ones with domain-specific sub-languages. This paper describes McMicMac, a framework for generative programming. McMicMac uses tree-transforming macros as language specifications, and enhances them with inherited and synthesized attributes. The enhanced transformers can describe general compilation tasks. Families of these specifications are grouped into mixin-like collections called vocabularies. Programmers can define new languages by composing these vocabularies. We have implemented McMicMac for Scheme and used it to build several systems, including the DrScheme programming environment. The principles of McMicMac carry over to other languages and environments.