nach oben

2008 | Buch

Kapitel lesen Erstes Kapitel lesen

The Common Component Modeling Example

Comparing Software Component Models

herausgegeben von: Andreas Rausch, Ralf Reussner, Raffaela Mirandola, František Plášil

Verlag: Springer Berlin Heidelberg

Buchreihe : Lecture Notes in Computer Science

Enthalten in: Springer Professional "Wirtschaft+Technik" , Springer Professional "Technik" , Springer Professional "Wirtschaft"

Einloggen, um Zugang zu erhalten

Inhaltsverzeichnis

Frontmatter

Introduction

Abstract

Although the idea of a software component stems back to the end of the sixties, the component-based software engineering established itself to an dedicated research area during the end nineties. Nowadays, in particular the research in component models which is motivated by the verification and quality prediction of component-based systems forms such a large body of research with a plethora of specific and creative ideas that it is hard to keep the overview. Several conference and workshop series are dedicated to formal component models and their use in verification and quality prediction, such as FMCO, CBSE, FESCA, FACS and QoSA. The organisers of CoCoME came independently to the finding, that these component models are hard to compare, as each research group concentrate on different aspects of formal component modelling and quality prediction.

Andreas Rausch, Ralf Reussner, Raffaela Mirandola, František Plášil

CoCoTA – Common Component Task

Abstract

This chapter overviews the scope, goals and timeline of the modeling contest CoCoME. It also describes the input the competing teams received and, furthermore, explains how the peer reviewing process went ahead, and how the evaluation criteria were set with the aim to balance the inherently heterogeneous modeling and expressive power of different component models.

Raffaela Mirandola, František Plášil

CoCoME - The Common Component Modeling Example

Abstract

The example of use which was chosen as the Common Component Modeling Example (CoCoME) and on which the several methods presented in this book should be applied was designed according to the example described by Larman in [1]. The description of this example and its use cases in the current chapter shall be considered under the assumption that this information was delivered by a business company as it could be in the reality. Therefore the specified requirements are potentially incomplete or imprecise.

Sebastian Herold, Holger Klus, Yannick Welsch, Constanze Deiters, Andreas Rausch, Ralf Reussner, Klaus Krogmann, Heiko Koziolek, Raffaela Mirandola, Benjamin Hummel, Michael Meisinger, Christian Pfaller

Modeling Components and Component-Based Systems in KobrA

Abstract

In this chapter we present a version of the Trading System case study modeled according to the KobrA approach. KobrA is a UML-based method for describing components and component-based systems developed at the Fraunhofer Institute for Experimental Software Engineering at the beginning of the decade. The acronym stands for the term “Komponenten basierte Anwendungsentwicklung” – German for “Component-based Application Development”. KobrA has been successfully used by a number of companies in industrial settings and has given rise to numerous specializations and offshoots (e.g. MARMOT [1] and MORABIT [2]). The original version of the method [3] was developed for the UML 1.x flavor of the UML, but in this chapter we introduce an updated version optimized for use with the 2.x versions of the UML [4] and its related standards such as OCL [5]. KobrA also provides support for other advanced software engineering approaches such as product-lines, but these are beyond the scope of this chapter. Here we focus on the component-modeling aspects of the method.

Colin Atkinson, Philipp Bostan, Daniel Brenner, Giovanni Falcone, Matthias Gutheil, Oliver Hummel, Monika Juhasz, Dietmar Stoll

A Rich Services Approach to CoCoME

Abstract

Systems-of-systems integration projects present exquisite challenges for software and systems engineering researchers and practitioners. Traditional integration approaches involve time-consuming rework bearing major financial and technical risk. Service-Oriented Architectures (SOAs) have emerged as a widely accepted solution to this challenge because they use standards-based infrastructure to forge large-scale systems out of loosely-coupled, interoperable services. SOAs can create systems-of-systems by mapping existing systems into services, then orchestrating communication between the services. New functionality can be created by either adding new services or modifying communication among existing services. Because of these features, SOA projects are particularly amenable to agile development processes. Consequently, well executed SOAs can drive down financial and technical risk by improving flexibility and reducing time to market.

Barry Demchak, Vina Ermagan, Emilia Farcas, To-ju Huang, Ingolf H. Krüger, Massimiliano Menarini

Modelling with Relational Calculus of Object and Component Systems - rCOS

Abstract

This chapter presents a formalization of functional and behavioural requirements, and a refinement of requirements to a design for CoCoME using the Relational Calculus of Object and Component Systems (rCOS). We give a model of requirements based on an abstraction of the use cases described in Chapter 3.2. Then the refinement calculus of rCOS is used to derive design models corresponding to the top level designs of Chapter 3.4. We demonstrate how rCOS supports modelling different views and their relationships of the system and the separation of concerns in the development.

Zhenbang Chen, Abdel Hakim Hannousse, Dang Van Hung, Istvan Knoll, Xiaoshan Li, Zhiming Liu, Yang Liu, Qu Nan, Joseph C. Okika, Anders P. Ravn, Volker Stolz, Lu Yang, Naijun Zhan

Component-Interaction Automata Approach (CoIn)

Abstract

The aim of the CoIn approach (Component-Interaction Automata approach) is to create a framework for formal analysis of behavioural aspects of large scale component-based systems. For the modelling purpose, we use the Component-interaction automata language [1]. For the verification, we employ a parallel model-checker DiVinE [2], which is able to handle very large, hence more realistic, models of component-based systems. Verified properties, like consequences of service calls or fairness of communication, are expressed in an extended version of the Linear Temporal Logic CI-LTL.

Barbora Zimmerova, Pavlína Vařeková, Nikola Beneš, Ivana Černá, Luboš Brim, Jiří Sochor

Service-Oriented Modeling of CoCoME with Focus and AutoFocus

Abstract

Reactive distributed systems, including business information systems and embedded control systems, require systematic software engineering approaches that can manage the complexity of the system and the development. This helps to ensure resulting implementations of high quality within reasonable cost and time frames. The CoCoME POS system (see Chapter 3) is a telling example that combines elements of both system classes.

Manfred Broy, Jorge Fox, Florian Hölzl, Dagmar Koss, Marco Kuhrmann, Michael Meisinger, Birgit Penzenstadler, Sabine Rittmann, Bernhard Schätz, Maria Spichkova, Doris Wild

Modelling the CoCoME with the Java/A Component Model

Abstract

The Java/A approach aims at semantically well-founded and coherent modelling and programming concepts for components: based on sound theoretical foundations it enhances the widely used UML 2.0 component model by modular analysis and verification techniques and a Java-based architectural programming language.

Alexander Knapp, Stephan Janisch, Rolf Hennicker, Allan Clark, Stephen Gilmore, Florian Hacklinger, Hubert Baumeister, Martin Wirsing

Linking Programs to Architectures: An Object-Oriented Hierarchical Software Model Based on Boxes

Abstract

Modeling software systems has several purposes. The model provides a communication means between developers, a backbone to specify and check properties of the system, and a structure to organize, explain, and develop the implementation of the system. The focus of our approach is to address these purposes for hierarchically structured, object-oriented software systems. The hierarchical structure refers to the component instances at runtime: a runtime component may consist of a dynamically changing number of objects and other runtime components. Our modeling technique builds on and extends the concepts of class-based object-oriented languages. Runtime components are created by instantiating box classes. The modeling technique provides ports to tame object references and aliasing and to decouple components from their environment. It supports dynamic linkage, i.e. ports can be connected and disconnected at runtime. The used concurrency model is based on the join calculus.

Jan Schäfer, Markus Reitz, Jean-Marie Gaillourdet, Arnd Poetzsch-Heffter

Modelling the CoCoME with DisCComp

Abstract

Most large-scaled software systems are logically structured in subsystems resp. components to cope with complexity. These components are deployed and executed within an distributed system infrastructure. Consequently, for many reasons, like for instance multi-user support or performance issues, the components are to some extent concurrently executed within an distributed environement. Note, this also holds for the Common Component Modelling Example (CoCoME).

André Appel, Sebastian Herold, Holger Klus, Andreas Rausch

Palladio – Prediction of Performance Properties

Abstract

Palladio is a component modelling approach with a focus on performance (i.e. response time, throughput, resource utilisation) analysis to enable early design-time evaluation of software architectures. It targets modelling business information systems. The Palladio approach includes

a meta-model called “Palladio Component Model” for structural views, component behaviour specifications, resource environment, component allocation and the modelling of system usage and
multiple analysis techniques ranging from process algebra analysis to discrete event simulation.
Additionally, the Palladio approach is aligned with a development process model tailored for component-based software systems.

Early design-time predictions avoid costly redesigns and reimplementation. Palladio enables software architects to analyse different architectural design alternatives supporting their design decisions with quantitative performance predictions, provided with the Palladio approach.

Klaus Krogmann, Ralf Reussner

KLAPER: An Intermediate Language for Model-Driven Predictive Analysis of Performance and Reliability

Abstract

Automatic prediction tools play a key role in enabling the application of non-functional analysis to the selection and the assembly of components for component-based systems, without requiring extensive knowledge of analysis methodologies to the application designer. A key idea to achieve this goal is to define a model transformation that takes as input some “design-oriented” model of the component assembly and produces as a result an “analysis-oriented” model that lends itself to the application of some analysis methodology. For this purpose, we define a model-driven transformation framework, centered around a kernel language whose aim is to capture the relevant information for the analysis of non-functional attributes of component-based systems, with a focus on performance and reliability. Using this kernel language as a bridge between design-oriented and analysis-oriented notations we reduce the burden of defining a variety of direct transformations from the former to the latter to the less complex problem of defining transformations to/from the kernel language. The proposed kernel language is defined within the MOF (Meta-Object Facility) framework, to allow the exploitation of existing model transformation facilities. In this chapter, we present the key concepts of our methodology and we show its application to the CoCoME case study.

Vincenzo Grassi, Raffaela Mirandola, Enrico Randazzo, Antonino Sabetta

CoCoME in Fractal

Abstract

This chapter presents our solution to the CoCoME assignment that is based on the Fractal component model. The solution involves (i) modeling architecture in Fractal ADL, (ii) specification of component behavior via behavior protocols, (iii) checking compatibility of components, (iv) verification of correspondence between component code and behavior specification, and (v) run-time monitoring of non-functional properties. Among the issues we have faced was the need to modify the architecture - the component hierarchy was reorganized in order to improve clarity of the design and the hierarchical bus was split into two independent buses. These were modeled by primitive components, since Fractal does not support message bus as a first-class entity. Since the CoCoME assignment does not include a complete UML behavior specification (e.g. via activity diagrams and state charts), behavior protocols for all the components are based on the provided plain-English use cases, the UML sequence diagrams, and the reference Java implementation.

Lubomír Bulej, Tomáš Bureš, Thierry Coupaye, Martin Děcký, Pavel Ježek, Pavel Parízek, František Plášil, Tomáš Poch, Nicolas Rivierre, Ondřej Šerý, Petr Tůma

CoCoME in SOFA

Abstract

This chapter presents our solution to the CoCoME assignment that is based on the SOFA 2.0 (SOFtware Appliances) hierarchical component model. The solution involves (i) modeling architecture in SOFA meta-model, (ii) speci fication of component behavior via extended behavior protocols, (iii) checking behavior compliance of components, (iv) verification of correspondence be tween selected component Java code and behavior specification, (v) deploy ment to SOFA run-time envi ronment (using connectors that support RMI and JMS), and (vi) modeling of performance and resource usage via layered queue ing networks. We faced sev eral issues during implementation of the CoCoME assignment in SOFA 2.0. Most notably, the architecture was modified in order to improve clarity of the design – in particular, the hierarchical bus was re placed by two separate buses and the Inventory component was restructured. Extended behavior protocols for all the components are based on the provided plain-English use cases, the UML sequence diagrams, and the reference Java implementation (the assignment does not include a complete UML behavior specification e.g. via activity dia grams and state charts).

Tomáš Bureš, Martin Děcký, Petr Hnětynka, Jan Kofroň, Pavel Parízek, František Plášil, Tomáš Poch, Ondřej Šerý, Petr Tůma

A Specification Language for Distributed Components Implemented in GCM/ProActive

Abstract

This chapter is based on a component model for distributed components called GCM for Grid Component Model. We present here this component model, its reference implementation based on the Java middleware ProActive, our specification language, JDC, adapted to distributed software components, and the associated specification platform: Vercors. From the specification of components and their behaviour, our aim is to both verify properties of this behaviour and generate code for real GCM components.

Antonio Cansado, Denis Caromel, Ludovic Henrio, Eric Madelaine, Marcela Rivera, Emil Salageanu

CoCoME Jury Evaluation and Conclusion

Abstract

The CoCoME Jury attended the two-day seminar with presentations from all participating teams. The jury provided individual feedback to each of the teams. This chapter is an attempt at both organizing the contributions into groups of related themes and summarizing some of the more salient feedback. The jury concludes with a few observations about the CoCoME contest as such and its overall outcome.

Manfred Broy, Johannes Siedersleben, Clemens Szyperski

Backmatter

Titel: The Common Component Modeling Example
herausgegeben von: Andreas Rausch
Ralf Reussner
Raffaela Mirandola
František Plášil
Verlag: Springer Berlin Heidelberg
Electronic ISBN: 978-3-540-85289-6
Print ISBN: 978-3-540-85288-9
DOI: https://doi.org/10.1007/978-3-540-85289-6