Abstract: The composition of software units has been one of the main research topics in computer science. This paper addresses the composition validation problem evolving in this context. It focuses on the composition for a certain kind of units called aspects. Aspects are a new concept which is introduced by aspect-oriented programming aiming at a better separation of concerns. Cross-cutting code is captured and localised in these aspects. Some of the cross-cutting features which are expressed in aspects cannot be woven with other features into the same application since two features could be mutually exclusive. With a growing number of aspects, manual control of these dependencies becomes error-prone or even impossible. We show how assertions can be useful in this respect to support the software developer.

Abstract: Software evolution demands continuous adaptation of software systems to continuously changing requirements. Our goal is to cope with software evolution by automating program transformation and system reconfiguration. We show that this can be achieved with a static metaprogramming facility and a library of suitable metaprograms. We show that former approaches of program transformations are not sufficient for large object oriented systems and outline two base transformations that fill the gap.

Abstract: Product instantiation is one of the less frequently studied activities in the domain of software product lines. In this paper, we present the results of a case study at Axis Communication AB on product instantiation in an industrial product line, i.e. five problems and three issues. The problems are concerned the insufficiency of functional commonality, features spanning multiple components, the exclusion of unwanted features, the evolution of product line components and the handling of initialization code. The issues discuss architectural compliance versus product instantiation effort, quick-fixes versus properly engineered extensions and component instantiation support versus product instantiation effort. The identified problems and issues are based on the case study, but have been generalized to apply to a wider context.

Abstract: Template techniques in C++ allow a modest degree of generative programming: creating specialized code for specialized problems. This use of templates has been controversial; indeed, one of the oft-cited reasons for migrating to Java is that it provides a simpler language, free of complexities such as templates. The essence of generative programming in C++ is not templates - the language feature - but rather the underlying algorithms in the compiler (template instantiation) which unintentionally resemble an optimization called partial evaluation [12,18]. By devising a partial evaluator for Java, we reproduce some of the generative programming aspects of C++ templates, without extending the Java language. The prototype compiler, called Lunar, is capable of doing "expression templates" in Java to optimize numerical array objects.

Abstract: Over the recent years aspect-oriented programming (AOP) has found increasing interest among researchers in software engineering. Aspects are abstractions which capture and localise cross-cutting concerns. Although persistence has been considered as an aspect of a system, persistence of aspects has been largely ignored. This paper identifies several scenarios where aspect persistence is an essential requirement. A model for aspect persistence and an initial prototype based on AspectJ (0.6beta2) are presented. Various open issues are also pointed out.

Abstract: The increasing number of available software components and competing interoperability standards render the selection, composition, and configuration of software components increasingly complex. In order to support the domain expert in these processes comprehensive, comparable, and sufficiently abstract component descriptions are required. In this paper, we abstract from the specifics of the component models COM, EJB, and CCM, and propose a unifying component description language for integrated descriptions of structure and behaviour of software components and component-based software systems.

Abstract: Software patterns draw on the work of the architect Christopher Alexander, which in turn builds on foundations that may be more suitable to software than the architectural metaphors themselves Patterns have a longstanding identity in the scientific community as results of a phenomenon called symmetry breaking Symmetry breaking can be defined formally in terms of group theory We establish formal group-theoretic foundations for several object-oriented programming models and show, by formal constructs and by analogy to other fields, that software patterns reduce to symmetry breaking Such formalisms may be useful as a foundation for pattern taxonomies, and to differentiate patterns as a design discipline from heuristics, rules, and arbitrary microarchitectures

Abstract: Component-orientation is an emerging paradigm that promises components that are usable as prefabricated black-boxes. But components have the problem that they should be changeable and flexibly adaptable to a huge number of different application contexts and to changing requirements. We will argue, that sole parameterization - as the key variation technique of components - is not suitable to cope with all required change scenarios. A proper integration with multiple other paradigms, such as object-orientation, the usage of a scripting language as a flexible component glue, and the exploitation of high-level interception techniques can make components be easier (ex)-changeable and adaptable. These techniques can be applied without interfering with the component's internals.

Abstract: The behavior of a system comprised of collaborating components tend to be difficult to analyze, especially if the system consists of a large number of concurrently operating components. We propose a scenario-based approach for analyzing component compositions that is based on Use Case Maps (UCMs), but is extended with a few additional constructs for modeling component interfaces and connections. UCMs provide a high level, behavioral view on a system that is easy to comprehend by humans. However, UCMs do not have well-defined semantics. For this reason, UCMs are augmented with formal component interface specifications as used in the concurrent, object-oriented programming language BCOOPL. The combination of UCMs and BCOOPL interface specifications enables formal analysis of component compositions. This involves two steps. In the first step, UCMs and BCOOPL interface specifications are translated into a BCOOPL program. In the second step, the interactions between components are analyzed for system properties like deadlock and reachability. An important result of the combination is that the complexity, which arises when concurrently collaborating components are brought together, is tamed by considering only those usages of components that are actually specified in UCM scenarios.

Abstract: Despite advances in software engineering and process methodologies over the past decades, not many IT projects seem particularly well adapted to today's fast-paced world. Software developers must start to acknowledge change and even uncertainty as a given, rather than the exception that should be studiously avoided, and they must adapt their techniques accordingly.Some business domains have seen attempts to address this situation. Several workflow vendors, for instance, have been marketing change and end-user programmability as major assets of their products. But, in general, they have been strangely ignorant of (good) modern software engineering practices, and the results have not really lived up to the claims. But we may expect a revival on a grander scale: the ability to (re) define the business logic on the fly is becoming a crucial asset when businesses re-align their core processes around the Internet.The Internet is transforming the way we envision and design applications. While we could build yesterday's simple Web applications with, let's face it, primitive techniques, this is simply no longer true. High-volume databases, long-term transactions, interoperability, distributed objects, re-use, these are some of the technical issues that must be dealt with. But the real challenge will be to leverage all this technology: we must empower the user to set up, maintain and change his applications more easily.We need dynamic systems, where applications can be changed at run-time in a high-level way, preferably by end-users. Above all, we need appropriate architectural techniques. In this paper we explore the use of dynamic object models. It turns out that the basic concepts are fairly simple. As for the difficulties, we can borrow solutions from many disciplines in computer science. If we do it right, we can even make the system work for itself.

Abstract: When designing and developing software systems, there are several challenges that have to be addressed such as complexity, change management and system integrity. Trends in development processes, programming languages and software design are constantly changing. New programming paradigms have succeeded each other while the software systems have grown larger and more difficult to maintain. Component-oriented thinking provides the opportunity to re-use pre-fabricated parts to assemble software systems from tested building blocks, facilitating a rapid and consistent software development process. A component-oriented approach, however, affects both the life cycle and the development process of a software system. Therefore, a new way of viewing the life cycle as well as the development process for component-based software systems is presented in this thesis. A key issue when using a component-oriented approach is to consider both behavioral and static aspects of a software system. Furthermore, we need to be able to analyze the architecture of the enterprise as well as the software system architecture to deliver business value with information systems. System interdependencies will be placed in the foreground when integrating technical and organizational aspects of the information system. We therefore need a modeling technique suitable for focusing on semantic aspects rather than implementation-dependent issues. A suitable modeling technique is the Enterprise Modeling approach. This thesis will present a component-oriented approach to software system architectures using the Enterprise Modeling approach.

Abstract: It is well known that modifying software by hand, especially someone else's, is not only slow and tedious but so notoriously errorprone that we strive for components that never need changing - blackbox building blocks Unfortunately, we lack the omniscience required to engineer such parts, especially when our problem domains are ill-defined A promising alternative is to make each component adaptive - a simple mark-up language (eg, frame technology) converts each component's properties (ie, granularities that are meaningful within a given domain) into a default value that can be overridden or extended by other components in a rapid yet reliable manner Adaptive components constitute a gray-box strategy - black when their properties fit the context as is, otherwise white The approach works by automating the tedious and error-prone aspects of construction and modification, while localizing all the unique properties of an object or program in its root component Each root exercises complete control over the structure and content of the code that its hierarchy of components emits Such custom roots constitute only 5-15% of a typical system In other words, 85-95% reuse is the norm Along with independently gathered statistical evidence of efficacy in constructing and evolving business systems of up to 10 million lines of code, the further implications of adaptive components for software engineering are presented

Abstract: Software reuse and especially the paradigm of software components are promising approaches to increase the efficiency of software development. One of the basic problems of software reuse, however, is the tradeoff between the abstraction from project-specific aspects and the actual contribution of a reusable artifact. Stringent resource constraints further complicate the application of these approaches in domains, where efficient and therefore specialized solutions are required, e.g. in the domain of embedded systems. Generic components - designed to be adaptable to new application scenarios - allow to overcome these limitations, esp. if they automate the essential modifications. This paper presents a concept of generic components that has been developed to facilitate the construction of highly specialized embedded operating systems. Besides the illustration of the underlying concept, the paper discusses the external representation of generic components and the internal realization of the required variability and reflects some of our experiences in constructing generic components.

Abstract: Patterns have a longstanding identity in the scientific community as results of a phenomenon called symmetry breaking. This article proposes a formalism for software patterns through connections from software patterns to symmetry and symmetry breaking. Specifically, we show (1) the ties from Alexander's work to symmetry and symmetry-breaking foundations; (2) many programming languages provide constructs that support symmetry; (3) software patterns are the results of symmetry breaking, compensating for design shortfalls in programming languages. The proposed pattern formalism may be useful as a foundation for pattern taxonomies, and to differentiate patterns as a design discipline from heuristics, rules, and arbitrary micro-architectures.