Abstract. System family engineering seeks to exploit the commonalities among systems from a given problem domain while managing the variabilities among them in a systematic way. In system family engineering, new system variants can be rapidly created based on a set of reusable assets (such as a common architecture, components, models, etc.). Generative software development aims at modeling and implementing system families in such a way that a given system can be automatically generated from a specification written in one or more textual or graphical domainspecific languages. This paper gives an overview of the basic concepts and ideas of generative software development including DSLs, domain and application engineering, generative domain models, networks of domains, and technology projections. The paper also discusses the relationship of generative software development to other emerging areas such as Model Driven Development and Aspect-Oriented Software Development. 1

A fundamental tension exists in systems research and practice between (1) hiding extraneous details to simplify the system programming model, and (2) revealing crucial details to allow better customization to particular application requirements, data characteristics, or other constraints. For many modern systems, such as distributed real-time and embedded (DRE) systems and multimedia applications, this tension is even stronger: the correctness of the system depends not only on functional behavior (e.g., correctness of interfaces and the algorithms behind them) but also on quality of service (QoS) properties such as CPU speeds, frame rates, and end-to-end timeliness requirements. Satisfying both the functional and QoS requirements of modern applications running in various run-time environments requires programming models that can allow selective visibility and (re)configurability of key details in both the application and the services it uses. Although prior research and practice has focused on decoupling system properties from the application logic to facilitate modification at different points in the system lifecycle, some system properties cross-cut both (1) multiple layers (application and supporting infrastructure) and (2) multiple configuration phases in the system lifecycle. To date, there has been little support for configuring such cross-cutting concerns in a systematic and standardized way across different kinds of applications. This has resulted historically in laborious and ad hoc hand-customization of systems to meet real-world constraints, especially for DRE systems. However, the convergence of model-integrated computing with component-oriented middleware in the DRE middleware research community offers a new opportunity for automated coordination of system modifications at different

A recent emergence of small, resource-constrained, and highly mobile computing platforms presents numerous new challenges for software developers. We refer to development in this new setting as programming-in-the-small-and-many (Prism). This paper provides a description and evaluation of Prism-MW, a middleware platform intended to support software architecture-based development in the Prism setting. Prism-MW provides efficient and scalable implementation-level support for the key aspects of Prism application architectures, including their architectural styles. Additionally, Prism-MW is extensible to support different application requirements suitable for the Prism setting. Prism-MW has been applied in a number of applications and used as an educational tool in graduate-level software architecture and embedded systems courses. Recently, Prism-MW has been successfully evaluated by a major industrial organization for use in one of their key distributed embedded systems. Our experience with the middleware indicates that the principles of architecture-based software development can be successfully, and flexibly, applied in the Prism setting.

Commercial off-the-shelf (COTS) middleware is now widely used to develop distributed real-time and embedded (DRE) systems. DRE systems are themselves increasingly combined to form "systems of systems" that have diverse quality of service (QoS) requirements. Earlier generations of COTS middleware, such as Object Request Brokers (ORBs) based on the CORBA 2.x standard, do not facilitate the separation of QoS policies from application functionality, which makes it hard to configure and validate complex DRE applications. The new generation of component middleware, such as the CORBA Component Model (CCM) based on the CORBA 3.0 standard, addresses the limitations of earlier generation middleware by establishing standards for implementing, packaging, assembling, and deploying component implementations. There has been little systematic empirical study of the performance characteristics of component middleware implementations in the context of DRE systems. This paper therefore provides three contributions to the study of CCM for DRE systems. First, we describe the challenges involved in benchmarking different CORBA Component Model (CCM) implementations. Second, we describe key criteria for comparing different CCM implementations using key black-box and white-box metrics. Third, we describe the design of our CCMPerf benchmarking suite to illustrate test categories that evaluate aspects of CCM implementation to determine their suitability for the DRE domain. We demonstrate CCMPerf by using it to collect metrics from a CCM implementation designed for DRE applications.

Reproduction for personal and educational purposes is permissible. The names of actual companies and products mentioned herein may be the trademarks of their respective owners. The views presented in this paper are solely those of the authors and do not represent the views of either the University of California or Microsoft Corporation. Software technology and its related activities are examined from an industrial and economic perspective. More specifically, the distinct characteristics of software from the perspective of the end-user, the software engineer, the operational manager, the intellectual property lawyer, the owner, and the economist are identified. The overlaps and relationships among these perspectives are discussed, organized around three primary issues: technology, processes, and value relationships. Examples of the specific issues identified are licensing vs. service provider models, alternative terms and conditions of licensing, distinct roles in the supplier value chain (development, provisioning, operation, and use) and requirements value chain (user needs and requirements), and the relationship of these issues to industrial organization and pricing. The

Abstract. We examine the philosophical disputes among computer scientists concerning methodological, ontological, and epistemological questions: Is computer science a branch of mathematics, an engineering discipline, or a natural science? Should knowledge about the behaviour of programs proceed deductively or empirically? Are computer programs on a par with mathematical objects, with mere data, or with mental processes? We conclude that distinct positions taken in regard to these questions emanate from distinct sets of received beliefs or paradigms within the discipline: — The rationalist paradigm, which was common among theoretical computer scientists, defines computer science as a branch of mathematics, treats programs on a par with mathematical objects, and seeks certain, a priori knowledge about their ‘correctness ’ by means of deductive reasoning. — The technocratic paradigm, promulgated mainly by software engineers, defines computer science as an engineering discipline, treats programs as mere data, and seeks probable, a posteriori knowledge about their reliability empirically using testing suites. — The scientific paradigm, prevalent in the branches of artificial intelligence, defines computer science as a natural (empirical) science, takes programs to be entities on a par with mental processes, and seeks a priori and a posteriori knowledge about them by combining formal deduction and scientific experimentation. We demonstrate evidence corroborating the tenets of the scientific paradigm, in particular the claim that program-processes are on a par with mental processes. We conclude with a discussion in the influence that the technocratic paradigm has been having over computer science.

QoS-aware component middleware solutions have been shown to be effective in reducing the programming complexity of configuring real-time aspects, with only a small reduction in the run-time performance of those configured aspects. However, many DRE systems (1) must run on real-time platforms that lack key dynamic configuration features, (2) require stringent bounds on system initialization times, (3) have limited storage available at run-time, and yet (4) still require a full range of configuration capabilities for both functional and systemic aspects. Furthermore, there are few studies to date of the design and performance of alternative component middleware configuration mechanisms. This paper makes three contributions to research on QoSaware component middleware for DRE systems. First, it describes the design of static component configuration mechanisms in the Component-Integrated ACE ORB (CIAO), to provide configurability while reducing run-time overhead and footprint, and to avoid features that are not supported by key real-time platforms. Second, this paper presents an empirical comparison of the performance and footprint of dynamic and static configuration mechanisms in CIAO, so that the most suitable configuration mechanisms can be selected according to the specific requirements of each DRE system. Third, it presents an empirical case study that compares CIAO’s static configuration mechanisms to the static configuration mechanisms in PRISM, an avionics domain-specific component middleware solution developed by Boeing.

Commercial off-the-shelf (COTS) middleware is increasingly used to develop distributed real-time and embedded (DRE) systems. DRE systems are themselves increasingly combined using wireless and wireline networks to form "systems of systems" that have diverse quality of service (QoS) requirements. Conventional COTS middleware does not facilitate the separation of QoS policies from application functionality, which makes it hard to configure and validate complex DRE applications. Component-based middleware addresses limitations of COTS middleware by establishing standards for implementing, packaging, assembling, and deploying component implementations. There has been little systematic empirical study of the performance characteristics of component middleware implementations in the context of DRE systems. This paper therefore provides three contributions to the study of component-based middleware. First, we describe the challenges involved in benchmarking different CORBA Component Model (CCM) implementations. Second, we describe key criteria for comparing different CCM implementations using key black-box and white-box metrics. Third, we describe the design of our CCMPerf benchmarking suite to illustrate test categories that evaluate aspects of CCM implementation to determine their suitability for the DRE domain. Our preliminary results underscore the importance of applying a range of metrics to quantify CCM implementations effectively.

Although component-based development (CBD) is among the predominant software engineering paradigms today, numerous issues still remain preventing business component marketplaces from taking off. For example, it is state of the practice to apply different notations and modeling languages for the specification of different aspects of a business component. Besides the fact that there is a lack of standards for holistic approaches to multi-faceted business component specification, the individual specification techniques very often are not powerful enough to allow for the reliable and efficient discovery and retrieval of matching components or the automatic deduction of statements about the semantic and syntactic compatibility of components for application composition. In this article, we argue that CBD processes can greatly benefit from the use of Semantic Web technologies for business component specification. The Resource Description Framework (RDF), for example, can provide a means to integrate existing specification approaches and add new value by superimposing a common knowledge representation layer on all specification artifacts, thus enabling semantic queries and reasoning about the properties of business components. © 2007 Elsevier B.V. All rights reserved. Keywords: Semantic Web-enabled software engineering; Business component reuse; Semantic components; Component ontology

Abstract. We discuss how emerging object-relational database mediator technology can be used to integrate academic freeware and commercial-off-the-shelf software components to create a sequence of gradually more complex and powerful, always semantically and syntactically homogeneous, database centered Image Meta-Analysis Environments. We show how this may be done by definition and utilization of a use-case-based evolutionary design and development process. This process allows subsystems to be produced largely independently by several small specialist subprojects, turning the system integration work into a high-level domain modelling task.