Academia.eduAcademia.edu

Outline

Title
Abstract
Figures
Introduction
Background and Motivation
Discussion and Related Work
Conclusions
References
All Topics
Computer Science
Software Engineering

CCDL: the composable components description language

Profile image of Y. BerbersY. BerbersProfile image of Ioana SoraIoana Sora

2007, International Journal on Software Tools for …

https://doi.org/10.1007/S10009-006-0017-7
visibility

…

description

14 pages

link

1 file

Abstract

Tools that automate component composition decisions need as inputs formal descriptions of following categories: the functional and nonfunctional requirements desired for the target, the structural constraints for the target, and the contractual specifications of available individual components. In this article we present CCDL, a description language able to cover these three aforementioned categories.We define a composable component as an architectural entity described by an external contractual specification and a set of structural constraints for its variable internal configuration. The internal configuration of a composable component is not fixed, but is a target that must be composed from available components. This composition is driven by external requirements while complying with the fixed structural constraints. Such hierarchically composable components permit finetuned customization of component-based systems with a high degree of unanticipated variability. Our composition approach is architectural style specific and addresses multiflow architectures.The most important strength of CCDL is its ability to describe structural constraints of composable components (that represent composition targets), as flexible guidelines for their composition. The CCDL descriptions can be used by automatic composition tools that implement requirements driven compositions strategies.

Figures (5)
Fig. 1. Integrated approach for self-customizable systems based on automatic component composition Ioana Sora et al.: CCDL: The Composable Components Description Language
Fig. 1. Integrated approach for self-customizable systems based on automatic component composition Ioana Sora et al.: CCDL: The Composable Components Description Language
Fig. 2. Multi-flow architecture example. System S is defined by four flows and can be realized as different component compositions on these. Ioana Sora et al.: CCDL: The Composable Components Description Language
Fig. 2. Multi-flow architecture example. System S is defined by four flows and can be realized as different component compositions on these. Ioana Sora et al.: CCDL: The Composable Components Description Language
Fig. 4. Example: Contracts expressed through required-provided properties Ioana Sora et al.: CCDL: The Composable Components Description Language
Fig. 4. Example: Contracts expressed through required-provided properties Ioana Sora et al.: CCDL: The Composable Components Description Language
Fig. 8. Exampke: Basic structural constraints example for composable component Sender Fig. 7. Example: External view of component Sender
Fig. 8. Exampke: Basic structural constraints example for composable component Sender Fig. 7. Example: External view of component Sender
Fig. 11. Deployment of repository tools. Example of introducing a new component C'X to the system Ioana Sora et al.: CCDL: The Composable Components Description Language
Fig. 11. Deployment of repository tools. Example of introducing a new component C'X to the system Ioana Sora et al.: CCDL: The Composable Components Description Language

Related papers

Towards an architectural approach for the dynamic and automatic composition of software components
Massimo Tivoli

2006

Abstract In a component-based software system the components are specified, designed and implemented with the intention to be reused, and are assembled in various contexts in order to produce a multitude of software systems. However, this ideal scenario is not always the case, eg, the integration with legacy components. In this context, one main problem in component assembly arises.

View PDFchevron_right
An Approach for Component-Based Software Composition
Ioan Toma

2008 Electronics, Robotics and Automotive Mechanics Conference, 2008

Presently, not only a large amount of information resources are available on the Web, but also a complete lattice of dynamic applications, namely, software components and Web Services. Hence, an increasing demand of a proper model and architecture for composition of software components has triggered a huge amount of integration efforts. However, most of them are partially ignoring operational and knowledge-oriented aspects which can hinge on semantics. In this paper, we present a semantically enhanced framework for software composition focusing on component-based systems.

View PDFchevron_right
Component-based specification of software architecture constraints
luc fabresse

Proceedings of the 14th international ACM Sigsoft symposium on Component based software engineering - CBSE '11, 2011

Component-based software engineering provides for developers the ability to easily reuse and assemble software entities to build complex software. Component-based specification of software functionality has been and is largely addressed, however this is not yet the case for what concerns software non-functionality. In this paper, we propose a new way to express component-based software non-functional documentation, and we will focus more specifically on architecture constraints which formalize parts of architecture decisions, as executable, customizable, reusable and composable building blocks represented by components. Checking of architecture constraints is provided via service invocation through ports of a special kind of components, called constraint-components. The signatures of these checking services can be defined in required interfaces of business components, to document decisions taken while designing their architecture. They can also be part of other required interfaces of constraint components, making it possible to build higher-level or more complex constraints while reusing existing ones. We present an example of implementation of constraint components using, an ADL which is introduced in this paper. Architecture constraints can then be checked on the architecture of business components at design-time using the CLACS tool support, which has been implemented as an Eclipse plugin.

View PDFchevron_right
Component-Based Design: Towards Guided Composition
Sotiris Moschoyiannis

2003

In this paper, we present a mathematical model for the composition of software components, at a semantic modelling level. We describe a mathematical concept of a single software component and identify properties that ensure its potential behaviour can be captured. Based on that, we give a formal definition of composition and examine its effect on the individual components. We argue that properties of the individual components can, under certain conditions, be preserved in the composite. The proposed model can be used for guiding the composition of components as it advocates formal reasoning about the composite before the actual composition takes place.

View PDFchevron_right
Constructing Component-Based Systems Directly from Requirements Using Incremental Composition
Azlin Nordin

2010 36th EUROMICRO …, 2010

In software engineering, system construction normally starts from a requirements specification that has been engineered from raw requirements in a natural language. Such a specification is derived from intermediate requirements models such as use case models. These models at best only approximate the raw requirements. In this paper we propose a componentbased approach that maps raw requirements directly into architectures, with a view to maximising the match between the final system and the raw requirements. Our approach is based on a component model that supports incremental composition.

View PDFchevron_right
Primitive component architecture description language
Basel Magableh

… and Systems (INFOS), 2010 The 7th …, 2010

This document gives formatting instructions for authors preparing papers for publication in the Proceedings of an IEEE conference. The authors must follow the instructions given in the document for the papers to be published. You can use this document as both an instruction set and as a template into which you can type your own text.

View PDFchevron_right
Towards Composing Software Components in Both Design and Deployment Phases
ling ling

Lecture Notes in Computer Science

In component-based software development, the design of components should be carried out separately from the deployment of components, in order to enable composition by independent third-parties. However, current component models are biased towards either the design phase or the deployment phase. In this paper, we argue that ideally component models should include both design and deployment phases, and it should be possible to compose components in both phases. We also demonstrate a preliminary implementation of composition in both phases in a component model we have defined.

View PDFchevron_right
Comdevalco | a Framework for Software Component Definition Validation and Composition
Istvan Czibula

This paper introduces ComDeValCo - a framework for Soft- ware Component Denition, Validation, and Composition. This is the rst,paper in a series describing current and further developments of this framework, which includes a modeling language, a component repository and a set of tools. The object-oriented modeling language contains,ne- grained constructions, aimed to give a precise description of software com- ponents. Component repository is storing valid components, ready to be composed,in order to build more complex components,or systems. The toolset contains tools dedicated to component denition, validation, and composition, as well as the management of component repository.

View PDFchevron_right
Automatic Translation of Architecture Constraint Specifications into Components
Christophe Dony

Lecture Notes in Computer Science, 2015

Architecture constraints are specifications defined by developers at design-time and checked on design artifacts (architecture descriptions, like UML models). They enable to check, after an evolution, whether an architecture description still conforms to the conditions imposed by an architecture pattern, style or any design principle. One possible language for specifying such constraints is the OMG's OCL. Most of these architecture constraints are formalized as "gross" specifications, without any structure or parameterization possibilities. This causes difficulties in their reuse. We propose in this work a process for translating architecture constraints into a special kind of components called constraint-components. This makes these specifications reusable (easily put and checked out in/from repositories), parametrizable (generic and applicable in different contexts) and composable with others. We implemented this process by considering the translation of OCL constraints into constraint-components described with an ADL called CLACS.

View PDFchevron_right

References (30)

  1. Sascha Alda. Component-based self-adaptability in peer- to-peer architectures. In Proceedings of the 26th Interna- tional Conference on Software Engineering ICSE 2004, 2004.
  2. Robert Allen and David Garlan. A formal basis for ar- chitectural connection. ACM Transactions on Software Engineering and Methodology, 6(3):213-249, 1997.
  3. Felix Bachman, Len Bass, Charles Buhman, Santi- ago Comella-Dorda, Fred Long, John Robert, Robert Seacord, and Kurt Wallnau. Technical concepts of component-based software engineering, CMU/SEI-2000- TR-008. Technical report, Carnegie Mellon Software En- gineering Institute, May 2000.
  4. Don Batory and Bart Geraci. Composition validation and subjectivity in GenVoca generators. IEEE Transac- tions on Software Engineering, 23(2), February 1997.
  5. Humberto Cervantes and Richard Hall. Autonomous adaptation to dynamic availability using a service- oriented component model. In Proceedings of the 26th International Conference on Software Engineering ICSE 2004, pages 614-623, 2004.
  6. Ivica Crnkovic, Heinz Schmidt, Judith Stafford, and Kurt Wallnau, editors. Proceedings of the 4th ICSE Workshop on Component-Based Software Engineering dedicated to Component Certification and System Pre- diction, Toronto, Canada, 14-15 May 2001.
  7. Ioana S ¸ora. Model compozitional bazat pe compo- nente compozabile in arhitecturi multi-flux (Composi- tional model based on composable components in multi- flow architectures, in Romanian). PhD thesis, Po- litehnica University Timisoara, Romania, 2004.
  8. Ioana S ¸ora, Vladimir Cret ¸u, Pierre Verbaeten, and Yolande Berbers. Automating decisions in component composition based on propagation of requirements. In Michel Wermelinger and Tiziana Margaria, editors, Fun- damental Approaches to Software Engineering, 7th Inter- national Conference, Proceedings, number 2984 in Lec- ture Notes in Computer Science, pages 374-388. Springer Verlag, 2004.
  9. Ioana S ¸ora, Frank Matthijs, Yolande Berbers, and Pierre Verbaeten. Automatic composition of systems from components with anonymous dependencies. In Theo D'Hondt, editor, Technology of Object-Oriented Languages, Systems and Architectures, pages 154-169. Kluwer Academic Publishers, 2003.
  10. Ioana S ¸ora, Pierre Verbaeten, and Yolande Berbers. Us- ing component composition for self-customizable sys- tems.
  11. In I. Crnkovic, J. Stafford, and S. Larsson, editors, Proceedings -Workshop On Component-Based Software Engineering at IEEE-ECBS 2002, pages 23-26, Lund, Sweden, 2002.
  12. Eric M. Dashofy, Andre van der Hoek, and Richard N. Taylor. A highly-extensible, XML-based architecture description language. In Proceedings of the Work- ing IEEE/IFIP Conference on Software Architectures (WICSA 2001), Amsterdam, Netherlands, 2001.
  13. David Garlan. Software architecture. In J. Marciniak, ed- itor, Wiley Encyclopedia of Software Engineering. John Wiley & Sons, 2001.
  14. David Garlan, Robert Allen, and John Ockerbloom. Ar- chitectural mismatch, or, why it's hard to build systems out of existing parts. In Proceedings of the 17th Interna- tional Conference on Software Engineering, pages 179- 185, Seattle, Washington, April 1995.
  15. Ioannis Georgiadis, Jeff Magee, and Jeff Kramer. Self- organising software architectures for distributed systems. In Proceedings of the ACM SIGSOFT Workshop on Self- healing Systems WOSS'02, 2002.
  16. Apache Group. Xerces Java Parser. http://www.apache.org, 2001.
  17. Dieter K. Hammer. Component-based architecting for component-based systems. In Mehmet Askit, edi- tor, Software Architectures and Component Technology. Kluwer, 2002.
  18. Scott A. Hissam, Gabriel A. Moreno, Judith A. Stafford, and Kurt C. Wallnau. Packaging predictable assembly. In IFIP/ACM Working Conference on Component De- ployment (CD2002), Berlin, Germany, June 20-21 2002.
  19. Paola Inverardi and S Scriboni. Connectors synthesis for deadlock-free component based architectures. In Pro- ceedings of the 16th ASE, Coronado Island, California, USA, November 2001.
  20. Paola Inverardi and Massimo Tivoli. Correct and au- tomatic assembly of COTS components: an architec- tural approach. In Proceedings of the 5th ICSE Work- shop on Component-Based Software Engineering, Or- lando, Florida, USA, May 19-20 2002.
  21. Valrie Issarny and Christophe Bidan. Aster: A frame- work for sound customization of distributed runtime sys- tems. In Proceedings of the 16th International Confer- ence on Distributed Computing Systems, pages 586-593, Hong-Kong, May 1996.
  22. Christos Kloukinas and Valerie Issarny. Automating the composition of middleware configurations. In Automated Software Engineering, pages 241-244, 2000.
  23. Frank Matthijs. Component Framework Technology for Protocol Stacks. PhD thesis, Katholieke Universiteit Leu- ven, Belgium, December 1999.
  24. N. Medvidovic and R. Taylor. A classification and com- position framework for software architecture description languages. IEEE Transactions on Software Engineering, Vol.26(No.1):70-93, January 2000.
  25. Peyman Oreizy, Michael M. Gorlick, Richard N. Tay- lor, Dennis Heimbigner, Gregory Johnson, Nenad Med- vidovic, Alex Quilici, David S. Rosenblum, and Alexan- der L. Wolf. An architecture-based approach to self- adaptive software. IEEE Intelligent Systems, 14(3):54- 62, May/June 1999. 25. The Object Management Group (OMG). Catalog of Domain Specifications. http://www.omg.org/technology/documents/domain spec catalog.htm
  26. Clemens Szypersky. Component Software: Beyond Object Oriented Programming. Addison-Wesley, 1997.
  27. World Wide Web Consortium W3C. eX- tensible Markup Language (XML) 1.0. http://ww.w3.org/TR/1998/REC-xml-19980210, 1998.
  28. World Wide Web Consortium W3C. Xml schema. http://ww.w3.org/XML/Schema, 2001.
  29. Michel Wermelinger. Towards a chemical model for soft- ware architecture reconfiguration. In Proc. of the 4th Intl. Conf. on Configurable Distributed Systems. IEEE Computer Society Press, 1998.
  30. David Wile. Revealing component properties through architectural styles. Journal of Systems and Software, Special Issue on Component-Based Software Engineer- ing, 65(3):209-214, March 2003.

Related papers

A description language for composable components
Y. Berbers, Ioana Sora

Fundamental Approaches to Software …, 2003

In this paper we present CCDL, our description language for composable components. We have introduced hierarchically composable components as means to achieve finetuned customization of component based systems. A composable component is defined by a fixed contractual specification of its external view and a set of structural constraints for its internal configuration. The internal configuration of a composable component is not fixed, but will be composed according to different requirements and has to comply with the structural constraints. This permits a high degree of unanticipated variability. Our approach is architectural style specific and addresses multiflow architectures. The goal of CCDL is to describe contractual specifications and structural constraints of composable components, as guidelines for their composition. CCDL descriptions can be used by automatic composition tools that implement requirements driven composition strategies.

View PDFchevron_right
Automating Decisions in Component Composition Based on Propagation of Requirements
Ioana Sora

Lecture Notes in Computer Science, 2004

Automatic component composition is a way to achieve selfcustomizable systems that are able to adapt themselves through structural configuration to changing conditions in their environment. In this paper, we propose an automatic composition strategy for multi-flow architectures with hierarchically composable components. Our composition strategy takes automatic decisions for the composition of a target that is specified through a set of required properties imposed over its given structural constraints. The composition decisions are taken knowing the properties provided by individual available components. Properties characterize functional or non-functional aspects of a component. The composition strategy is driven by a mechanism of propagation of required properties, detailed in this paper.

View PDFchevron_right
A component composition model to support unanticipated customization of systems
Y. Berbers, Ioana Sora

Proceedings of the first …, 2002

Systems must adapt themselves to (evolving) user requirements or to their (changing) environment. One way to address this problem is through component composition, systematically (re-)building systems from their requirements by composing reusable components.

View PDFchevron_right
Serious Specification for Composing Components
Clemens Szyperski

Component-Based Software Engineering, 2003

We discuss the use of an industrial-strength specification language to specify component-level contracts for a product group within Microsoft. We outline how the specification language evolved to meet the needs of the component-based ap- proach followed by that group. The specification language, AsmL, is executable which allows for testing to be done using runtime verification. Runtime verification dynamically monitors the

View PDFchevron_right
Flexible Component Composition through Communication Abstraction
Fabian Gilson

Proceedings of the 4th International Conference on Model-Driven Engineering and Software Development, 2016

Software architectures are often abstracted as a combination of reusable components connected to each other by various means. Specifications of components' semantics have been widely studied and many modeling languages have been proposed from coarse-grained loosely-defined elements to operational objects with behavioral semantics that may be generated and executed in a dedicated framework. All these modeling facilities have proven their advantages in many domains through either case studies or real-world applications. However, most of those approaches either consider a subset of composition facilities, i.e. the available types of bindings between components, or do not even consider communication properties at all, staying at behavioral-related compatibility between components. Verifications of communication-related properties are then postponed to the hand of software developers and finally considered at deployment-time only. Part of a general architecture framework, we propose an abstraction formalism to specify communication paths between components. This modeling facility relies on a taxonomy of types of links and the specifications of communication protocols. This protocol serves as a reification element between abstract component compositions, architecture instances and deployment infrastructure, making explicit communication-related constraints and properties.

View PDFchevron_right

Related topics

  • Functional Analysis
  • Formal Specification
  • Non Functional Requirement
    • 580 California St., Suite 400
    San Francisco, CA, 94104
    © 2025 Academia. All rights reserved