Component-Based Software Engineering

Ideally in the deployment phase, components should be composable, and their composition checked. Current component models fall short of this ideal. Most models do not allow composition in the deployment phase. Moreover, current models use only deployment descriptors as deployment contracts. These descriptors are not ideal contracts. For one thing, they are only for specific containers, rather than arbitrary execution environments. In any case, they are checked only at runtime, not deployment time. In this paper we present an approach to component deployment which not only defines better deployment contracts but also checks them in the deployment phase.

The most important contribution to the success or failure of a software project comes from the choice of the programming languages being used and their support in the target environment. The choice of a suitable implementation language is not a guarantor for success, but an unsuitable language may result in a long, error-prone, and costly implementation, often resulting in an unstable product. In this paper, we present GLoo, a framework for modeling and reasoning about

open-ended

language mechanisms for object- and component-oriented software development. At the heart of GLoo is a small

dynamic composition language

that provides abstractions to (i) define and/or import reusable software components, (ii) introduce new compositional language abstractions, and (iii) build executable and reusable component-oriented specifications. To demonstrate its flexibility and extensibility, we then present an encoding of the

traits

concept as an example of how to add support for a new and readily available language abstraction to the GLoo framework.

Most methods for designing component-based systems and verifying their compatibility address only the syntactic compatibility of components; no analysis of run-time behavior is made. Those methods that do address run-time behavior suffer from

state-explosion

: the exponential increase of the number of global states, and hence the complexity of the analysis, with the number of components. We present a method for designing component-based systems and verifying their behavioral compatibility and temporal behavior that is not susceptible to state explosion. Our method is mostly automatic, with little manual deduction required, and does not analyze a large system of connected components at once, but instead analyzes components two-at-a-time. This pair-wise approach enables the automatic verification of temporal behavior, using model-checking, in time polynomial in the number and size of all components. Our method checks that behavior of a pair of interacting components conforms to given properties, specified in temporal logic. Interaction of the components is captured in a product of their behavioral automata, which are provided as a part of each component’s interface. We demonstrate the effectiveness of our method by applying it to the design and verification of a component-based elevator control algorithm.

We present a novel approach which facilitates formal verification of component-based software application families using model checking. This approach enables effective compositional reasoning by facilitating formulation of component properties and their environment assumptions. This approach integrates bottom-up component verification and top-down system verification based on the concept of application family architectures (AFA). The core elements of an AFA are architectural styles and reusable components. Reusable components of a family are defined in the context of its architectural styles and their correctness properties are verified in bottom-up component compositions. Top-down system verification utilizes architectural styles to guide decomposition of properties of a system into properties of its components and formulation of assumptions for the component properties. The component properties are reused if already verified; otherwise, they are verified top-down recursively. Architectural style guided property decomposition facilitates reuse of verified component properties. Preliminary case studies have shown that our approach achieves order-of-magnitude reduction on verification complexities and realizes major verification reuse.

The Analytic Hierarchy Process (AHP) has been successfully used in the past for the selection of components, as presented in case studies in the literature. In this paper, an empirical study using AHP to rank components is presented. The components used in the study are for data compression; each implements one of the Arithmetic Encoding (AREC), Huffman coding (HUFF), Burrows-Wheeler Transform (BWT), Fractal Image Encoding (FRAC), and Embedded Zero-Tree Wavelet Encoder (EZW) algorithms. The ranking is a semi-automated approach that is based on using rigorously collected data for the components’ behavior; selection criteria include maximum memory usage, total response time, and security properties (e.g., data integrity). The results provide a clear indication that AHP is appropriate for the task of selecting components when several criteria must be considered. Though the study is limited to select components based on multiple non-functional criteria, the approach can be expanded to include multiple functional criteria.

This paper presents a software component search engine, from the early specification and design steps to two experiments performed to evaluate its performance. After the experience gained from the use of this first version, several improvements were introduced. The current version of the engine combines

text mining

and

facet-based

search. The experiments indicated, so far, that using these two techniques together is better than using them separately. From the experience obtained in these experiments and in industrial tests, we point out possible improvements and future research directions, which are presented and discussed at the end of the paper.

One of the distinguishing features of distributed systems is the importance of the interaction mechanisms that are used to define how the sequential components interact with each other. Given the complexity of the behavior that is being described and the large design space of various alternatives, choosing appropriate interaction mechanisms is difficult. In this paper, we propose a component-based specification approach that allows designers to experiment with alternative interaction semantics. Our approach is also integrated with design-time verification to provide feedback about the correctness of the overall system design. In this approach, connectors representing specific interaction semantics are composed from reusable building blocks. Standard communication interfaces for components are defined to reduce the impact of changing interactions on components’ computations. The increased reusability of both components and connectors also allows savings at model-construction time for finite-state verification.

In this paper, we propose a novel approach towards integrating the ideas behind Aspect-Oriented and Component-Based Software Development. Our approach aims at achieving a symmetric, unified component architecture that treats aspects and components as uniform entities. To this end, a novel component model is introduced that does not employ specialized aspect constructs for modularizing crosscutting concerns. Instead, an expressive configuration language is provided that allows to describe both regular and aspect-oriented interactions amongst components. This paper presents the ongoing FuseJ research, a first experiment for realizing this symmetric and unified aspect/component architecture.

A great deal of languages have emerged and have demonstrated the advantages that Aspect-Oriented Programming offers. For this reason, the aspect-oriented approach is being introduced into the early phases (analysis and design) of the software life cycle. In this work, we present an Aspect-Oriented Architecture Description Language (AOADL) to specify software architectures of complex, dynamic and distributed software systems. This AOADL follows the PRISMA approach, which integrates the advantages of Component-Based Software Development (CBSD) and Aspect-Oriented Software Development (AOSD). The PRISMA AOADL combines components and aspects in an elegant and novel way achieving a better management of crosscutting-concerns. In addition, it is independent of the technology, and it has great expressive power in order to facilitate the automatic code generation from its specifications. In this work, we demonstrate how PRISMA AOADL improves the management, maintainability and reusability of software architectures introducing the notion of aspect in its ADL.

This paper presents AOKell, a framework for engineering component-based systems. This framework implements the Fractal model, a hierarchical and dynamic component model. The novelty of this paper lies in the presentation of AOKell, an implementation of the Fractal model with aspects. Two dimensions can be isolated with Fractal: the functional dimension, which is concerned with the definition of application components, and the control dimension, which is concerned with the technical services (e.g. lifecycle, binding, persistence, etc.) that manage components. The originality of AOKell is, first, to provide an aspect-oriented approach to integrate these two dimensions, and second, to apply a component-based approach for engineering the control dimension. Hence, AOKell is a reflective component framework where application components are managed by other, so-called, control components and where aspects glue together application components and control components.

Although the CBSE has a great success in software engineering, only large scale companies use it through their research and development department. Small and medium size enterprises still have some hesitations that deprives them of the various advantages offered by CBSE. This is mainly due to the economic constraints that large companies don’t have. How can we make them benefit from this technology? Do they have to develop their own models? Should they obtain a modified version of this technology? What will happen to the code that already exists? What are the costs of such migration? How to proceed? In this paper we present an experiment carried out in using CBSE within the framework of a partnership between a small and medium-sized enterprise and an academic research team. We present the results and the way in which this migration has been performed, by hoping that this would be an answer to the above questions.

Software components bring in an interesting alternative to the traditional, centralized, approach to software development. The core idea is indeed to enable the (end) user to build and customize his own application, by assembling pre-existing (“off the shelf”) components. However, picking predefined, off-the-shelf components raises the question of the suitability of these components to a peculiar use. In this setting, the ability to supervise and adapt components appears to be crucial, in order to make the component-oriented approach to software design really effective.

The fact that a component is and must remain a black box for its clients makes a significant difference as regards instrumentation, and thus supervision of components. This paper introduces a supervision service fitted for software components. The main features of this service are that:

–it proposes an instrumentation protocol that keeps the opacity of components, with respect to their implementation, whilst it allows to instrument components independently from their design.

– it facilitates the supervision of components by providing a simple coupling between the component’s internal control, and the control provided by the user of the component, based on user-specified criteria.

This paper motivates the interest of such a supervision service, outlines its implementation, and illustrates its use.

The possibilities currently offered to conduct business at an electronic level are immense. Service providers offer access to their attendances through components placed on the Internet; such components can be combined to build applications, which can themselves be used as components by further business units. The final leg of the way to this paradigm has been paved by the advent of service-oriented architectures in general, and Web Services in particular.

With protocols existing for any parties to communicate, the most critical ingredient to the success of a business idea remains the task of choosing one’s business partners. At a technical level, this translates to the issue of identifying

which

components represent the most adequate services to build a final application.

While each middleware technology and system proposed in the past has been described with its scheme for “looking up” components, this paper chooses the more difficult approach of trying to distill the fundamentals of component lookup. We propose a generic model of component lookup — applicable to settings as diverse as tagged sets, classic white pages, or even method dispatch — and its implementation. We illustrate our model through various examples of existing lookup schemes. It turns out that in our generic context the common distinction between name-based and type-based lookup becomes rather artificial.

This paper presents a software product line architecture where applications are assembled by installing a set of plugins on a common software base. In this architecture, the software base embeds a lightweight workflow engine that guides the main flow of control and data of the application. This architecture eliminates the problem of scattered flow of data and control and facilitates plugin substitution. This architecture is currently being used to build a biomedical engineering research application on top of the Eclipse platform.

The widespread use of embedded systems mandates the development of industrial software design methods based on formal models (frameworks) and prefabricated components. This paper presents a formal specification of the

C

OMDES framework, focusing on the main architectural issues and the specific line of reasoning that was followed while developing a hierarchy of executable models describing relevant aspects of system structure and behaviour. The above framework has been used to systematically define a hierarchy of reusable and reconfigurable components – simple and composite function blocks, reconfigurable state machines and function units – implementing the executable models presented in the paper.

The use of software component models has become popular during the last decade, in particular in the development of software for desktop applications and distributed information systems. However, such models have not been widely used in the domain of embedded real-time systems. There is a considerable amount of research on component models for embedded real-time systems, or even narrower application domains, which focuses on source code components and statically configured systems. This paper explores an alternative approach by laying the groundwork for a component model based on binary components and targeting the broader domain of embedded real-time systems. The work is inspired by component models for the desktop and information systems domains in the sense that a basic component model is extended with a set of services for the targeted application domain. A prototype tool for supporting these services is presented and its use illustrated by a control application.

New content and service providers emerge every day. Each player offers new software components or services to support their technology. In these multi-vendor environments there is a genuine need for integration and interoperability. Integration and interoperability is a first step, once this is achieved components can seamlessly use services from different providers, and that is when service policies come into play. A policy mechanism allows fine grained control over the service usage. The OSGi Service Platform allows seamless integration of components and services but lacks a well defined mechanism for dynamic service policy management. Two approaches are presented for enhancing the OSGi Service Platform with policies. The first approach extends the platform while the second one adapts the plug-in components. Finally they are compared and evaluated against multiple requirements; usability, performance, transparency and backward compatibility.

Designing architectures requires the balancing of multiple system quality objectives. In this paper, we present techniques that support the exploration of the quality properties of component-based architectures deployed on multiprocessor platforms. Special attention is paid to real-time properties and efficiency of resource use. The main steps of the process are (1) a simple way of modelling properties of software and hardware components, (2) from the component properties, a model of an execution architecture is composed and analyzed for system-level quality attributes, (3) for the composed system, selected execution scenarios are evaluated, (4) Pareto curves are used for making design trade-offs explicit. The process has been applied to several industrial systems. A Car Radio Navigation system is used to illustrate the method. For this system, we consider architectural alternatives, show their specification, and present their trade-off with respect to cost, performance and robustness.

The adoption of a “high level” perspective in the design of a component-based application, without considering the specific features of some underlying supporting platform, has the advantage of focusingon the relevant architectural aspects and reasoning about them in a platform independent way, omitting unnecessary details that could even not be known at the earliest development stages.On the other hand, many of the details that are typically neglected in this high-level perspective must necessarily be taken into account to obtain a meaningful evaluation of different architectural choices in terms of extra-functional quality attributes, like performance or reliability. Toward the reconciliation of these two contrasting needs, we propose a model-based approach whose goal is to support the derivation of sufficiently detailed prediction models from high level models of component-based systems, focusing on the prediction of performance and reliability. We exploit for this purpose a refinement mechanism based on the use of model transformation techniques.

We investigate the impact of Operating System’s Virtual Memory Managers (VMMs) on performance of enterprise applications. By taking various popular branches of the Linux kernel and modifying their VMM settings, one can see the effects it introduces on ECPerf J2EE Benchmark. JBoss application server is used to run ECPerf. Our tests show that even the change of one parameter in VMM can have significant performance impacts. Performance of various kernel branches is compared. Parameter sensitivity and influence of specific settings are presented.

During an architectural evolution of a component-based software, certain quality attributes may be weakened. This is due to the lack of an explicit definition of the links between these non-functional characteristics and the architectural decisions implementing them. In this paper, we present a solution that aims at assisting the software maintainer during an evolution activity on his demand. It requires the definition of a documentation during development, organized in the form of bindings between formal descriptions of architectural decisions and their targeted quality attributes. Through an assistance algorithm, the approach uses this documentation in order to notify the maintainer of the possible effects of architectural changes on quality requirements. We also present a prototype tool which automates our proposals. This tool and the overall approach has been experienced on a real-world software in order to validate them.

Most large software systems are architected as component-based systems. In such systems, components are developed and tested separately. As components cooperate for providing services, testing of a component also reveals defects in other components. In this paper we study the role testing of other components plays in finding defects in a component by analyzing defect data of an earlier version of Windows. Our analysis shows that testing of other components often is the largest source of finding defects in a component. The analysis also shows that though many components reveal defects in a component, often a small set of components – the Test Buddies – exists whose testing reveals the vast majority of the defects found by testing other components. The Test Buddies of a component are those with a heavy interaction with the component and represent the high priority customers for testing. The Test Buddy information for a system can be determined by the test data of an earlier release, and then can be used in different ways to improve the testing.

Predictable assembly

in component-based software development intuitively means the ability to predict effectively properties of a system, making essential use of properties of its components. A formal definition is difficult to give, because the idea is a large, vague one. As an outgrowth of an informal workshop, this paper frames a mathematical definition. A somewhat surprising consequence of the formal definition is that assembly is usually predictable, but each particular case requires engineering effort to establish.

As the number of available web services is steadily increasing, many applications are being developed by reusing web services. Accordingly, a tool to generate an adapter which integrates interfaces of several web services is proposed in this paper. The concept of the adapter for the integration of web services interface is described. The purpose of the adapter is to help developers use several web services with little effort for their application development. Then, implementation of the tool to generate an adapter is presented. The architecture of the tool, the process, and the algorithm to generate an adapter are described. The tool will help developers integrate several web services when they develop applications.

Non-functional specifications of software components are considered an important asset in constructing dependable systems, since they enable early Quality of Service (QoS) evaluations. Several approaches for the QoS analysis of component-based software architectures have been introduced. However, most of these approaches do not consider the integration into the development process sufficiently. For example, they envision a pure bottom-up development or neglect that system architects do not have complete information for QoS analyses at their disposal. We extent an existing component-based development process model by Cheesman and Daniels to explicitly include early, model-based QoS analyses. Besides the system architect, we describe further involved roles. Exemplary for the performance domain, we analyse what information these roles can provide to construct a performance model of a software architecture.

When designing applications with

Enterprise JavaBeans

(EJBs) and more specifically with

Stateful Session Beans

, a major difficulty (or even an impossibility) is being able to properly transform business models and more precisely UML 2 models, into such component types, while including the expression of their mutual compositions. This contradicts with the spirit of the emerging

Model-Driven Architecture

(MDA) software engineering paradigm based on the definition of seamless model transformations. In this scope, this paper proposes and describes an appropriate Java library in order to increase the composition power of EJBs. The proposition includes a support for a broadcast communication mode (assimilated to “horizontal composition” in the paper) which is,

a priori

, incompatible with non reentrance, a key characteristic of EJBs. Besides, “vertical composition” is the counterpart of “horizontal compo-sition”. “Vertical composition” enables the consistent hierarchical combination of composite behaviors and compound behaviors, both being specified and implemented by means of UML 2

State Machine Diagrams

.

This paper addresses the unavoidable problem of dynamic reconfig-uration in component-based system with a hierarchical component model. The presented solution is based on (1) allowing several well defined patterns of dynamic reconfiguration and on (2) introducing a

utility interface

concept, which allows using a service provided under the SOA paradigm from a component-based system. The paper is based on our experience with non-trivial case studies written for component-based systems SOFA and Fractal.

Dynamicity is an important requirement for critical software adaptation where a stop can be dangerous (e.g. for humans or environment) or costly (e.g. power plants or production lines). Adaptation at run-time is also required in context-aware applications where execution conditions often change. In this paper, we introduce

MaDcAr

, an abstract model of dynamic automatic adaptation engines for (re-)assembling component-based software.

MaDcAr

aims at being a conceptual framework for developing customizable engines reusable in multiple applications and execution contexts. Besides,

MaDcAr

provides a uniform solution for automating both the construction of application from scratch and the adaptation of existing component assemblies.

We present in this paper an approach aiming at adapting component structures instead of adapting component services. It focuses on transforming a software component from a monolithic configuration to a composite one. Among the motivations of this kind of adaptation, we note its possible application to permit flexible deployment of software components and flexible loading of component service-code according to the available resources (CPU, memory). This adaptation is based on the analysis and the instrumentation of component codes.

A component-based system consists of components linked by connectors. Data can reside in components and/or in external data stores. Operations on data, such as access, update and transfer are carried out during computations performed by components. Typically, in current component models, control, computation and data are mixed up in the components, while control and data are both communicated by the connectors. As a result, such systems are tightly coupled, making reasoning difficult. In this paper we propose an approach for encapsulating data by separating it from control and computation.

Today we see more and more services, such as entertainment or home automation, being brought to connected homes. These services are published and operated by a variety of service providers. Currently, each provider sells his own box, providing both connectivity and a closed service environment. The open service paradigm aims at mixing all services within the same box, thus opening the service delivery chain for home users. However, open service gateways still lack important mechanisms. Multiple service providers can access and use the same gateway concurrently. We must define what this use is,

i.e.

we must define a notion of

user

. Also, service providers should not interfere with each other on the gateway, except if explicitly required. In other words, we must isolate services from different providers, while still permitting on-demand collaboration. By combining all these mechanisms, we are defining a multi-user, multi-service execution environment, which we call a virtualized service gateway. We implement part of these features using OSGi technology.