Lothar Baum

Mapping requirements to reusable components using Design Spaces

A consistent implementation of component based reuse bears several implications for the design of the software development process. For instance, requirements engineering has to be tailored to particularly elicit information necessary for selecting and configuring appropriate components. Besides sketching our approach to component based system development, the paper shows how Design Spaces can be applied to actively support reuse oriented activities. Design Spaces allow us to uniformly describe requirements on and properties of software artefacts, as well as correlations between specific properties. As a consequence, they are well suited to guide the requirements capturing towards the properties of existing components, and to map those requirements to component selections and configurations. The paper demonstrates how to consistently deploy the Design Space technique throughout the process, leading to a complete and strongly tool-supported path from requirements capture to system implementation.

Architecture-Centric Software Development Based on Extended Design Spaces

The realization of software projects can be significantly eased by extending the focus of reuse to architectural aspects instead of concentrating on separate software elements. Yet in any case, operational techniques are required to support the retrieval and selection of reusable items. To this end, we extend on the concept of design spaces which allows to describe the relevant properties of software elements in a semi-formal way. Moreover, we show how the concept of extended design spaces can be deployed in tools supporting component-and framework-based software development.

Generic components to foster reuse

Software reuse, and especially the paradigm of software components, is a promising approach to increase the efficiency of software development. One of the basic problems of software reuse, however, is the trade-off between the abstraction from project-specific aspects on the one side, and the actual contribution of a reusable component during the realization of a new system on the other side. Conventional components with fixed properties are trapped within the inherent tension between overly general and less efficient solutions satisfying a large number of niche requirements, and specifically optimized but less reusable designs for each point in the requirements space. Generic components which are designed and implemented to be mechanically adaptable to new application scenarios allow to overcome these limitations and help to drastically increase the efficiency of software development. This paper introduces the fundamental concepts of generic components and particularly discusses viable techniques to implement generic components. It furthermore shows how generic components may be instantiated automatically by tools and reports on our first experiences in using generic components for the construction of embedded operating systems.

Customization of system software for large-scale embedded applications1This work was funded by the DFG as part of the Sonderforschungsbereich SFB501, Development of Large Systems with generic Methods, Research project B5 (GENESYS) 1

Operating systems are one of the most frequently reused software components: almost every application is sitting on top of an OS which establishes the required runtime platform. It is claimed that bridging the gap between a high level application design and the OS is a costly process, especially in distributed systems. A conceptual framework is presented which aims at supporting the automatic generation of distributed runtime platforms from high-level application designs. It is based on the generic layout of operating system services, their extended description including nonfunctional properties, as well as analysis and development tools which filter out OS requirements from the application design.

Driving the composition of runtime platforms by architectural knowledge

Reusing app roved components is an a ttractive approach for the c ustomization o f runtime platforms in an economically sensible manner. However, the successful t ransition from particular requirements to a suitable architecture including appropriate components heavily relies on the expertise of t he system designers. In this paper, we propose an a rchitecture-driven approach to support runtime platform developers in the c omposition o f customized p latforms. Central to this approach is the explicit consideration of architectural aspects on an intermediate level of description. At this level, the appropriate matching o f requirements against properties of available components is controlled by formalized architectural knowledge. With SDL patterns and design spaces we present t wo techniques for performing this mapping process.

BSA: a framework for efficient accounting on wide-area networks

As global networks are being used by more and more people, they are becoming increasingly interesting for commercial applications. The success and change in direction of the World-Wide Web is a clear indication for this. However this success met a largely unprepared communications infrastructure. The Internet as an originally non-profit network did neither offer the security, nor the globally available accounting infrastructure by itself. These problems were addressed in the recent past, but in a seemingly ad-hoc manner. Several different accounting schemes sensible for only certain types of commercial transactions have been developed, which either seem to neglect the problems of scalability, or trade security for efficiency. Finally, some proposals aim at achieving near perfect security at the expense of efficiency, thus rendering those systems to be of no practical use. In contrast, this paper presents a suitably configurable scheme for accounting in a general, widely distributed client/server environment. When developing the protocol, special attention has been paid to make this approach work well in the future setting of high-bandwidth, high-latency internets. The developed protocol has been applied to a large-scale distributed application, a WWW-based software development environment.