Abstract: A crucial issue in the design of Component-Based (CB) applications is the ability to early guarantee that the system under development will satisfy its Quality of Service requirements. In particular, we need rigorous and easy-to-use techniques for predicting and analyzing the performance of the assembly based on the properties of the constituent components. To this purpose, we propose the CB-SPE framework: a compositional methodology for CB Software Performance Engineering (SPE) and its supporting tool. CB-SPE is based on, and adapts to a CB paradigm, the concepts and steps of the well-known SPE technology, using for input modeling the standard RT-UML PA profile. The methodology is compositional: it is first applied by the component developer at the component layer, achieving a parametric performance evaluation of the components in isolation; then, at the application layer, the system assembler is provided with a step- wise procedure for predicting the performance of the assembled components on the actual platform. We have developed the CB-SPE tool reusing as much as possible existing free tools. In this paper we present the realized framework, together with a simple application example.

Abstract: A stepwise approach is proposed to predict the performance of component compositions. The approach considers the major factors influencing the performance of component compositions in sequence: component operations, activities, and composition of activities. During each step, various models – analytical, statistical, simulation – can be constructed to specify the contribution of each relevant factor to the performance of the composition. The architects can flexibly choose which model they use at each step in order to trade prediction accuracy against prediction effort. The approach is illustrated with an example about the performance prediction for an Automobile Navigation System.

Abstract: This paper describes the experience of building component-oriented applications with a framework that supports run-time adaptation in response to the dynamic availability of functionality provided by constituent components. The framework’s approach is to define a service-oriented component model, which is a component model that includes concepts from service orientation and an execution environment that provides automatic adaptation mechanisms. This paper focuses on an example scenario and two real-wold examples where this framework has been used.

Abstract: Scientific computing on massively parallel computers presents unique challenges to component-based software engineering (CBSE). While CBSE is at least as enabling for scientific computing as it is for other arenas, the requirements are different. We briefly discuss how these requirements shape the Common Component Architecture, and we describe some recent research on quality-of-service issues to address the computational performance and accuracy of scientific simulations.

Abstract: Software component technologies have not yet been generally accepted by embedded-systems industries. In order to better understand why this is the case, we present a set of requirements, based on industrial needs, that are deemed decisive for introducing a component technology. The requirements we present can be used to evaluate existing component technologies before introducing them in an industrial context. They can also be used to guide modifications and/or extensions to component technologies, to make them better suited for industrial deployment. One of our findings is that a major source of requirements is non-technical in its nature. For a component technology to become a viable solution in an industrial context, its impact on the overall development process needs to be addressed. This includes issues like component life-cycle management, and support for the ability to gradually migrate into the new technology.

Abstract: Safety critical embedded real-time systems represent a class of systems that has attracted relatively little attention in research addressing component based software engineering. Hence, the most widely spread component technologies are not used for resource constrained safety critical real-time systems. They are simply to resource demanding, to complex and to unpredictable. In this paper we show how to use component based software engineering for low footprint systems with very high demands on safe and reliable behaviour. The key concept is to provide expressive design time models and yet resource effective run-time models by statically resolve resource usage and timing by powerful compile time techniques. This results in a component technology for resource effective and temporally verified mapping of a component model to a commercial real-time operating system.

Abstract: Embedded systems must be cost-effective. This imposesstrict requirements on the resource consumption of their applications. It is therefore desirable to be able to determine the resource consumption of applications as early as possible in its development. Only then, a designer is able to guarantee that an application will fit on a target device.

Abstract: Components, especially commercial-off-the-shelf (COTS) components, are mainly for inter-organizational reuse. One of the essential tasks in component-based development (CBD) is to locate and reuse the right components that provide the functionality and interface required by component consumers. However, if a candidate component provides a limited applicability and customizability so that it does not completely satisfy the functionality and interface needed, then a component consumer cannot reuse the component in application development. We call it a partial matching problem in component acquisition. To resolve this problem, we propose smart connectors that fill the gap between candidate components and the specification of components required. By using connectors, partially matched components become reusable in application development without sacrificing the component consumer’s requirements. Consequently, the effort and cost to develop new components and applications can be greatly reduced. In this paper, we propose four types of connectors, and each connector type is specified with its applicable situation and instructions to design correct connectors.

Abstract: This paper discusses various classifications of component interoperability errors. These classifications aim at supporting the automation of component adaptation. The use of software components will only demonstrate beneficial, if the costs for component deployment (i.e., acquisition and composition) are considerably lower than those for custom component development. One of the main reasons for the moderate progress in component-based software engineering are the high costs for component deployment. These costs are mainly caused by adapting components to bridge interoperability errors between unfitting components. One way to lower the costs of component deployment is to support component adaptation by tools, i.e., for interoperability checks of (semi-)automated adaptor generation. This automation of component adaptation requires a deep understanding of component interoperability errors. In particular, one has to differentiate between different classes of interoperability errors, as different errors require different adaptors for resolving. Therefore, the presented classification of component interoperability errors supports the automation of component adaptation by aiding automated interoperability problem detection and semi-automated adaptor generation. The experience gained from already implemented solutions for a specific class of interoperability errors provides hints for the solution of similar problems of the same class.

Abstract: In this paper, we describe a methodology for the design and the development of component-based real-time systems. In our model, a component consists of a set of concurrent real-time threads that can communicate by means of synchronized operations. In addition, each component can specify its own local scheduling algorithm. We also discuss the support that must be provided at the operating system level, and present an implementation in the SHaRK operating system.

Abstract: There is a conceptual gap between the way we currently articulate requirements and the reuse-driven paradigm embodied in component-based system development. The principal challenge in requirements engineering for component-based systems is to develop models and methods that allow us make the best use of the available component technology by balancing aspects of requirements and business concerns, with the architectural assumptions and capabilities embodied in blackbox software components. This paper proposes a method for requirements engineering based on the notion of viewpoints that provides an explicit framework for expressing component-based system requirements from initial formulation through to detailed specification.

Abstract: Component-based technologies make it possible to decompose complex software systems into functional software components. Unfortunately, most component technology does little to address non-functional Quality of Service (QoS) requirements that concern the run-time execution of the software. We are developing a technique to enable one to satisfy QoS requirements of software systems by decomposing and assembling Qoskets similar to the way systems are decomposed into functional components. A qosket is a packaged unit of reusable QoS-related behavior and policy. These qoskets are integrated into a component-based application to enable dynamic, adaptive QoS management. We present our design and describe our initial prototype. We conclude with a set of open questions and directions for future work.

Abstract: In distributed and mobile environments, the connections among the hosts on which a software system is running are often unstable. As a result of connectivity losses, the overall availability of the system decreases. The distribution of software components onto hardware nodes (i.e., deployment architecture) may be ill-suited for the given target hardware environment and may need to be altered to improve the software system's availability. The critical difficulty in achieving this task lies in the fact that determining a software system's deployment that will maximize its availability is an exponentially complex problem. In this dissertation, we motivate, present, and evaluate an automated, flexible, software architecture-based solution for disconnected operation that increases the availability of the system during disconnection. We provide a set of models, algorithms, techniques, and tools for improving a distributed, mobile system's availability via redeployment, by enabling the system to (1) monitor its operation; (2) estimate its deployment architecture; and (3) effect that architecture automatically. While the focus of this dissertation research is on improving system availability, our methodology is extensible to support other non-functional properties that may be relevant in a given distributed system. This dissertation is evaluated empirically, by conducting a series of benchmark tests and applying the methodology to example applications. The dissertation concludes with a set of open research questions that will frame our future work.

Abstract: In this paper we report on a case study of correct automatic assembly of software components. We show the application of our tool (called Synthesis) for correct components assembly to a software system in the area of CSCW (Computer Supported Cooperative Work). More specifically we consider a product data management (PDM) cooperative system which has been developed by the company Think3 in Bologna, ITALY (www.think3.com). In the area of CSCW, the automatic enforcing of desired interactions among the components forming the system requires the ability to properly manage the dynamic interactions of the components. Moreover once a customer acquires a CSCW system, the vendor of the CSCW system has to spend many further resources in order to integrate the CSCW system with the client applications used by the customer organization. Thus the full automation of the phase of integration code development has a great influence for a good setting of a CSCW system on the market. We present the application of our approach and we describe our experience in automatic derivation of the code which integrates the components forming the PDM cooperative system above mentioned. The case study we treat in this paper represent the first attempt to, successfully, apply Synthesis in real-scale contexts.

Abstract: This paper proposes a conceptual framework for the reliability assessment of software components that incorporates test case execution and output evaluation. Determining an operational profile and test output evaluation are two difficult and important problems that must be addressed in such a framework. Determining an operational profile is difficult, because it requires anticipating the future use of the component. An expected result is needed for each test case to evaluate the test result and a test oracle is used to generate these expected results. The framework combines statistical testing and test oracles implemented as self-checking versions of the implementations. The framework is illustrated using two examples that were chosen to identify the issues that must be addressed to provide tool support for the framework.

Abstract: This work reports the development of the Concerto platform, which is dedicated to supporting the deployment of resource-aware parallel Java components on heterogeneous distributed platforms, such as pools of workstations in labs or offices. Our work aims at proposing a basic model of a parallel Java component, together with mechanisms and tools for managing the deployment of such a component on a distributed platform. Moreover, we strive to provide components with means to perceive their runtime environment, so they can for example dynamically adapt themselves to changes occurring in this environment. The Concerto platform was designed in order to allow the deployment of parallel components on a distributed platform. It additionally defines and implements an open and extensible framework for distributed resource discovery and monitoring in such an execution environment.

Abstract: Current peer-to-peer architectures are hardly resistant against unanticipated exceptions such as the failure of single peers. This can be justified by the absence of sophisticated models for exception detection and resolution in peer-to-peer architectures. On the other hand, existing generic models for such self-adaptable architectures are rather theoretical and less suitable for the usage by end-users. In this work, strategies for a new self-adaptability model in peer-to-peer architecture are presented incorporating the component technology as the conceptual foundation. The claim of this approach is that through the intuitive nature of the component technology the process of self-adaptability becomes more applicable and more comprehendible even for less experienced end-users.

Abstract: The challenge of managing the development and evolution of complex, component-based software is increasingly being recognized as the development of such systems becomes more common. This paper attempts to understand the relevance of current management best practices by utilizing a simple meta-model to illustrate the impact that architectural complexity and reusable components have on management patterns. The model serves as a heuristic device and supports the view that products based on a framework of reusable software components pose new challenges and have to be managed simultaneously at a number of different levels. This provides a rationale for the Release Matrix, a generalization of a software release plan, previously proposed as a technique for managing software product lines. The Release Matrix has practical applications for tracking the evolution of complex component-based systems and is shown via the model to be a natural consequence of increased architectural complexity and component reuse. This paper has relevance for developers seeking simple techniques to help them manage challenging component-based programs, as well as researchers interested in the conceptual basis and limits of current management practices.

Abstract: Component containers provide a deployment environment for components in a component-based system. Containers supply a variety of services to the components that are deployed in them, such as persistence, enforcement of security policies and transaction management. Recently, containers have shown a large amount of potential for aiding in the predictable assembly of component-based systems. This paper describes an augmentation to the component container, called the Container-Managed Exception Handling (CMEH) Framework, which provides an effective means for deploying exception handling mini-components into a component-based system. This framework promotes a more effective handling of exceptional events, as well as a better separation of concerns, yielding a more robust component assembly.

Abstract: For over thirty years now, software components have been perceived as being essential stepping stones towards flexible and maintainable software systems But where do the components come from? Once we have the components, how do we put them together? And when we are missing components, how should we synthesize them?

Abstract: An important part of the software engineering process in today’s component technologies is the integration of business logic and infrastructure services. In this paper, we investigate the current situation regarding transaction management services and discuss existing problems. We then present a conceptual framework for a model-based transaction service configuration approach and explain its constituent parts. The framework is based on metamodelling and thus can directly be used for efficient development of tool support.

Abstract: An object-oriented framework can be a key component in building products for a given application area. An application developer need only provide definitions suited to the needs of the particular application for the hook methods. With appropriate initializations, the calls to the hook methods made by the template methods defined in the framework will be dispatched to the definitions provided by the application developer, thus customizing the behavior of the template methods. Specifying and testing such frameworks present some challenges; we discuss these and develop ways to address them.

Abstract: Interface specifications play a vital role in component-based software development. A proper component interface specification acts as a contract between component developers and application developers. It defines which properties of the component are guaranteed by the component developer and can be relied on by the application developer. This allows component development and application development to be decoupled. The application developer can create applications without knowledge of the component implementation and the component developer can create and modify implementations without breaking existing application code. In addition, interface specifications can be used for several other purposes such as component verification (black-box testing) and code generation.

Abstract: Design accompanying analysis techniques for component-based embedded systems based on the dataflow paradigm are presented. The underlying signal model covers not only the value range and the time domain but also attributes of the signal data transport. Components are modelled as functions on streams of signal data. This allows to describe the behavior of dataflow components precisely by constraints. Static constraints, e.g., equality of sampling periods, may be as complex as multivariate polynomials and are enforced by a new interface type system. Dynamic constraints, e.g., describing communication protocols, are checked using a novel model checking technique based on fifo automata. The objective of these mathematically well-founded analysis techniques is to detect as many program errors as possible during design. Moreover, the component model is compositional resulting in well-defined hierarchical abstraction. Alltogether, this results in a more reliable development of complex applications in a shorter design time.

Abstract: Interface specifications play a vital role in component-based software development. A proper component interface specification acts as a contract between component developers and application developers. It defines which properties of the component are guaranteed by the component developer and can be relied on by the application developer. This allows component development and application development to be decoupled. The application developer can create applications without knowledge of the component implementation and the component developer can create and modify implementations without breaking existing application code. In addition, interface specifications can be used for several other purposes such as component verification (black-box testing) and code generation.

Abstract: According to Szyperski, “a software component is a unit of composition with contractually specified interfaces and explicit context dependencies only”. But it is well known that these contractually specified interfaces should go well beyond mere syntactic aspects: they should also involve functional, synchronization and Quality of Service (QoS) aspects. In large, mission-critical component based systems, it is also particularly important to be able to explicitly relate the QoS contracts attached to provided interfaces with the QoS contracts obtained from required interfaces. In this paper we propose a language called QoSCL (defined as an add-on to the UML2.0 component model) to let the designer explicitly describe and manipulate these higher level contracts and their dependencies. We show how the very same QoSCL contracts can then be exploited for (1) validation of individual components, by automatically weaving contract monitoring code into the components; and (2) validation of a component assembly, including getting end-to-end QoS information inferred from individual component contracts, by automatic translation to a Constraint Logic Programming language. We illustrate our approach with the example of a GPS (Global Positioning System) software component, from its functional and contractual specifications to its implementation in a .Net framework.

Abstract: Long running applications often need to adapt due to changing requirements or changing environment. Typically, such adaptation is performed by dynamically adding or removing components. In these types of adaptation, components are often added to or removed from multiple processes in the system. While techniques for such adaptations have been extensively discussed in the literature, there is a lack of systematic methods to ensure the correctness of dynamic adaptation. To redress this deficiency, in this paper, we propose a new method, based on the concept of proof lattice, for verifying correctness of dynamic adaptation in a distributed application. We use transitional-invariant lattice to verify correctness of adaptation. As an illustration of this method, we show how correctness of dynamic adaptation is obtained in the context of a message communication application.

Abstract: Specification of Quality of Service (QoS) for components can only be done in relation to the QoS the components themselves are given by imported components. Developers as well as users need support in order to derive valid data for specification respectively for checking whether a selected component complies with its specification. In this paper we introduce the architecture of a measurement framework for EJBs giving such support and discuss in detail the measurement of the well understood property of response time.