This paper publicly reveals, motivates, and surveys the results of an ambitious hidden agenda for applying algebra to software engineering. The paper reviews selected literature, introduces a new perspective on nondeterminism, and features powerful hidden coinduction techniques for proving behavioral properties of concurrent systems, especially renements; some proofs are given using OBJ3. We also discuss where modularization, bisimulation, transition systems and combinations of the object, logic, constraint and functional paradigms t into our hidden agenda. 1 Introduction Algebra can be useful in many dierent ways in software engineering, including specication, validation, language design, and underlying theory. Specication and validation can help in the practical production of reliable programs, advances in language design can help improve the state of the art, and theory can help with building new tools to increase automation, as well as with showing correctness of the whole e...

This paper presents a perspective of generative reuse technologies as they have evolved over the last 15 years or so and a discussion of how generative reuse addresses some key reuse problems. Over that time period, a number of different reuse strategies have been tried ranging from pure component reuse to pure generation. The record of success is mixed and the evidence is sketchy. Nevertheless, the paper will use some known metric evidence plus anecdotal evidence, personal experience, and suggestive evidence to define some of the boundaries of the success envelope. Fundamentally

Abstract. This paper argues that the current OO technology does not support reuse and configurability in an effective way. This problem can be addressed by augmenting OO analysis and design with feature modeling and by applying generative implementation techniques. Feature modeling allows capturing the variability of domain concepts. Concrete concept instances can then be synthesized from abstract specifications. Using a simple example of a configurable list component, we demonstrate the application of feature modeling and how to implement a feature model as a generator. We introduce the concepts of configuration repositories and configuration generators and show how to implement them using object-oriented, generic, and generative language mechanisms. The configuration generator utilizes C++ template metaprogramming, which enables its execution at compile-time. 1

The production of well-understood software will eventually be the responsibility of software generators. Generators will enable high-performance, customized software systems and subsystems to be assembled quickly and cheaply from component libraries. These components will be intelligent: they will encapsulate domain-specific knowledge (e.g., best practice approaches) so that their instances will automatically customize and optimize themselves to the system in which they are being used. In this paper, we explore the topics intelligent components and software generation as they pertain to the issues of software productivity, performance, reliability, and quality.

Introduction Information is the life-blood of modern society. It is largely controlled, distributed and manipulated through software systems that drive communications networks, mediate financial transactions and operate databases of almost anything from recipes, through vehicle registrations and corporate finances, to criminal records. These systems range in scope from personal organizers to networks that girdle the earth. They control access to buildings, allow researchers to communicate results and share ideas, format documents such as financial reports and this book; they monitor and control particle accelerators, production lines, nuclear reactors, satellite trajectories and ballistic missiles, as well as cash dispensers and the family car brakes. Participating in society without encountering such systems is as difficult as cutting a pound of flesh from a man's breast without shedding a jot of blood. Information can be effectively recorded, controlled and used only insofar

. Mixin-Based Programming in C++ is a powerful programming style based on the parameterized inheritance idiom and the composition of C++ templates. Type expressions describing specific inheritance hierarchies can be composed either automatically using generative programming idioms in C++ or manually. Unfortunately, the mixin-based C++ programming techniques published to date do not adequately support optional and alternative mixin classes with constructors expecting varying numbers of arguments, which are common in practice. This is because the varying base class constructors do not provide a uniform interface on which the constructors of the derived classes could rely. This paper discusses several partial solutions to this problem that were proposed to date and presents a new, complete solution. The new solution uses generative programming techniques to automatically generate the appropriate constructors, and this way it avoids the overhead and clumsiness of instantiating composed mix...

reports are available via anonymous ftp, from svrc.it.uq.edu.au in the directory /pub/techreports. Abstracts and compressed postscript files are available

Feature-oriented design improves reusability of objectoriented classes. Features are increments in program functionality and correspond to feature modules. Programs composed from feature modules can conflict to applications they interact with. In this paper, we introduce refactoring feature modules. Refactoring feature modules are a new combination of feature-oriented design and refactorings that adjust members and classes that are composed from feature modules. We show that refactoring feature modules reduce conflicts between applications and encourage software reuse.

Data Types and Algebraic Semantics The history of programming languages, and to a large extent of software engineering as a whole, can be seen as a succession of ever more powerful abstraction mechanisms. The first stored program computers were programmed in binary, which soon gave way to assembly languages that allowed symbolic codes for operations and addresses. fortran began the spread of "high level" programming languages, though at the time it was strongly opposed by many assembly programmers; important features that developed later include blocks, recursive procedures, flexible types, classes, inheritance, modules, and genericity. Without going into the philosophical problems raised by abstraction (which in view of the discussion of realism in Section 4 may be considerable), it seems clear that the mathematics used to describe programming concepts should in general get more abstract as the programming concepts get more abstract. Nevertheless, there has been great resistance to u...

This paper argues that the current OO technology does not support reuse and configurability in an effective way. This problem can be addressed by augmenting OO Analysis and Design with feature modeling and by applying generative implementation techniques. Feature modeling allows capturing the variability of domain concepts. Concrete concept instances can then be synthesized from abstract specifications. Using a simple example of a configurable list component, we demonstrate the application of feature modeling and how to implement a feature model as a generator. We introduce the concepts of configuration repositories and configuration generators and show how to implement them using object-oriented, generic, and generative language mechanisms. Interestingly, a configuration repository represents an effective approach for typing synthesized recursive classes. The configuration generator utilizes C++ template metaprogramming, which enables its execution at compile-time.