Catálogo de publicaciones - libros

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 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 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.