GenVoca generators synthesize software systems by composing components from reuse libraries. GenVoca components are designed to export and import standardized interfaces, and thus be plugcompatible, interchangeable, and interoperable with other components. In this paper, we examine two different but important issues in software system synthesis. First, not all syntactically correct compositions of components are semantically correct. We present simple, efficient, and domainindependent algorithms for validating compositions of GenVoca components. Second, components that export and import immutable interfaces are too restrictive for software system synthesis. We show that the interfaces and bodies of GenVoca components are subjective, i.e., they mutate and enlarge upon instantiation. This mutability enables software systems with customized interfaces to be composed from components with “standardized ” interfaces. 1

. In this paper we deal with object-oriented component integration issues. We argue that traditional framework customization techniques are inappropriate for componentbased programming since they lack support for non-invasive, encapsulated, dynamic customization. We propose a new language construct, called a pluggable composite adapter, for expressing component gluing. A pluggable composite adapter allows the separation of customization code from component implementation, resulting in better modularity, flexible extensibility, and improved maintenance and understandability. We also discuss alternative realizations of the construct. 1. Introduction Component software, i.e., software that is an assembly of individual, independently developed parts, is becoming the predominant architecture. We consider two factors as the driving force behind this development. First, as indicated in [22] component software represents a middle path between the two extremes that predominate traditional sof...

Virtual classes are class-valued attributes of objects. Like virtual methods, virtual classes are defined in an object’s class and may be redefined within subclasses. They resemble inner classes, which are also defined within a class, but virtual classes are accessed through object instances, not as static components of a class. When used as types, virtual classes depend upon object identity – each object instance introduces a new family of virtual class types. Virtual classes support large-scale program composition techniques, including higher-order hierarchies and family polymorphism. The original definition of virtual classes in BETA left open the question of static type safety, since some type errors were not caught until runtime. Later the languages Caesar and gbeta have used a more strict static analysis in order to ensure static type safety. However, the existence of a sound, statically typed model for virtual classes has been a long-standing open question. This paper presents a virtual class calculus, vc, that captures the essence of virtual classes in these full-fledged programming languages. The key contributions of the paper are a formalization of the dynamic and static semantics of vc and a proof of the soundness of vc. Categories and Subject Descriptors D.3.3 [Language Constructs and Features]: Classes and objects, inheritance, polymorphism; F.3.3 [Studies of Program Constructs]: Object-oriented constructs,

Since a binding-time analysis determines how an off-line partial evaluator will specialize a program, the accuracy of the binding-time information directly determines the degree of specialization. We have designed and implemented a binding-time analysis for an imperative language, and integrated it into our partial evaluator for C, called Tempo [11]. This binding-time analysis includes a number of new features, not available in any existing partial evaluator for an imperative language, which are critical when specializing existing programs such as operating system components [27,28]. ffl Flow sensitivity. A different binding-time description is computed for each program point, allowing the same variable to be considered static at one program point and dynamic at another. ffl Context sensitivity. Each function call is analyzed with the context of the call site, generating multiple binding-time annotated instances of the same function definition. ffl Return sensitivity. A different bi...

Distributed real-time and embedded (DRE) applications have become critical in domains such as avionics (e.g., flight mission computers), telecommunications (e.g., wireless phone services), tele-medicine (e.g., robotic surgery), and defense applications (e.g., total ship computing environments). DRE applications are increasingly composed of multiple systems that are interconnected via wireless and wireline networks to form systems of systems. A challenging requirement for DRE applications involves supporting a diverse set of quality of service (QoS) properties, such as predictable latency/jitter, throughput guarantees, scalability, 24x7 availability, dependability, and security that must be satisfied simultaneously in real-time. Although a growing number of DRE applications are based on QoS-enabled commercial-o#-theshelf (COTS) hardware and software components, the complexity of managing long lifecycles (often years) remains a key challenge for DRE application developers. For example, substantial time and e#ort is spent retrofitting DRE applications when their COTS technology infrastructure changes.

ine generic software architectures. In ACM Computing Surveys, vol. 27, no. 2, June 1995, pp. 262-264. y Authors' address: Institut fur Informatik (IAM), Neubruckstrasse 10, CH-3012 Bern, Switzerland. Tel: +41 31 631.4618, Fax: +41 31 631.3965, E-mail: oscar, meijler @iam.unibe.ch, WWW: http://iamwww.unibe.ch/¸scg Generalizing from successful approaches to software composition, we see that the notion of a framework has a much broader interpretation. We can then understand component-oriented development in terms of the following three levels: ffl The Framework Level: A generic software architecture is a description of a class of software architectures in terms of component interfaces, composition mechanisms, and composition rules. A framework is a generic software architecture together with a set of generic software component

This article outlines an approach that avoids these problems by choosing a retrieval method that utilizes minimal repository structure to effectively support the process of finding software components. The approach is demonstrated through a pair of proof-ofconcept prototypes: PEEL, a tool to semiautomatically identify reusable components, and CodeFinder, a retrieval system that compensates for the lack of explicit knowledge structures through a spreading activation retrieval process. CodeFinder also allows component representations to be modified while users are searching for information. This mechanism adapts to the changing nature of the information in the repository and incrementally improves the repository while people use it. The combination of these techniques holds potential for designing software repositories that minimize up-front costs, effectively support the search process, and evolve with an organization's changing needs.

Designers often seek modular architectures for complex systems so that their systems better accommodate expected changes, have parts that can be developed and evolved without further coordination, and to ease the understanding of complex designs through abstraction of details hidden within modules. However, current design modeling techniques do not effectively support design modularization and evolution analysis. In this paper, we present a framework to enable automatic and quantifiable software modularization and evolution analyses for high-level design abstractions. The framework contributes a model to substantiate the concept of information hiding as a measurable criterion for software designs, an algorithm to extract the dependence structure of an abstract design, and an approach to quantitatively analyzing the changeability of a design. We have imported existing engineering techniques and economic analysis into software, and made these abilities formalized and automated. We illustrate and demonstrate the potential utility of our modeling and analysis techniques by modeling and analyzing several design examples.

. Creating applications using object-oriented frameworks is done at a relatively low abstraction level, leaving a large gap with the high abstraction level of a design. This makes the use of a framework difficult, and allows design and realization to diverge. Design patterns are more specific elements of design, and thus reduce this gap. We even bridge this gap by making design patterns and the classes that play a role within them into special purpose software components. System realization becomes a matter of composing special purpose class-components. We also introduce a system, FACE, which supports the visual composition of such specifications. 1 Introduction When comparing the development of applications using frameworks [6] to the development of applications using libraries or from scratch, using a framework is ---after a learning period--- significantly less labour intensive [19]. Thus frameworks have a large commercial value. Still, the use and evolution of a framework...

Data flow analysis is a versatile technique that can be used to address a variety of analysis problems. Typically, data flow analyzers are hand-crafted to solve a particular analysis problem. The cost of constructing analyzers can be high and is a barrier to evaluating alternative analyzer designs. In this paper, we describe an architecture that facilitates the rapid prototyping of data flow analyzers. With this architecture, a developer chooses from a collection of pre-existing components or, using high-level component generators, constructs new components and combines them to produce a data flow analyzer. In addition to support for traditional data flow analysis problems, this architecture supports the development of analyzers for a class of combined data flow problems that offer increased precision. This architecture allows developers to investigate quickly and easily a wide variety of analyzer design alternatives and to understand the practical design tradeoffs better. We describ...