nach oben

2007 | Buch

Kapitel lesen Erstes Kapitel lesen

Software Composition

6th International Symposium, SC 2007, Braga, Portugal, March 24-25, 2007, Revised Selected Papers

herausgegeben von: Markus Lumpe, Wim Vanderperren

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

Über dieses Buch

OnbehalfoftheOrganizingCommitteewearepleasedtopresenttheproceedings ofthe2007SymposiumonSoftwareComposition(SC2007).ThegoalofSC2007 wastobringtogethertheresearchandindustrialcommunitiesinordertoaddress the challenges of the component-based softwaredevelopment approach. SC 2007 was the sixth symposium on software composition in the SC series that seeks to develop a better understanding of how software components may be used to build and maintain large software systems. This LNCS volume contains the revised versions of the papers presented at SC 2007, which was held as a satellite event of the European Joint Conferences on Theory and Practice of Software (ETAPS) in Braga, Portugal, March 24–25, 2007. The symposium began with a keynote on “Composition by Anonymous Parties” by Farhad Arbab (CWI and Leiden University). The main program consisted of six technical sessions related to speci?c aspects of component-based software development. In response to the call for papers, we received 59 submissions from over 20 countries and 6 continents. Each paper was reviewed by at least three Program Committeemembers.TheentirereviewingprocesswassupportedbyMicrosoft’s Conference Management Toolkit. In total, 15 submissions were accepted as full papers and 5 submissions were accepted as short papers.

Inhaltsverzeichnis

Frontmatter

Invited Talk

Composition by Anonymous Third Parties

Abstract

Composition of algorithms has dominated software composition since the inception of programming. The ubiquitous subroutine call acts as the primary composition operator in virtually all programming models and paradigms, appearing in various guises such as function call, method invocation, remote procedure call, etc. The inadequacies of the tight coupling imposed by such composition mechanisms and the need for more flexible alternatives have become clearer along the evolution through object-oriented to component-based, and now, service oriented computing.

Farhad Arbab

Session: Composition Contracts

Defining Component Protocols with Service Composition: Illustration with the Kmelia Model

Abstract

We address in this article the description and usage of component protocols viewed as specific services. In addition to inter-component service composition, our Kmelia component model supports vertical structuring mechanisms that allow service composition inside a component. The structuring mechanisms (namely state annotation and transition annotation) are then used to describe protocols which are considered here as component usage guides. These structuring mechanisms are integrated in the support language of our component model and are implemented in our COSTO toolbox. We show how protocol analysis is performed in order to detect some inconsistencies that may be introduced by the component designers.

Pascal André, Gilles Ardourel, Christian Attiogbé

Composite Contract Enforcement in Hierarchical Component Systems

Abstract

Abadi and Lamport established a general theorem for composing specifications [1] . Based on an assume-guarantee principle, it enables one to prove the specification of a composite system from the ones of its components. But the general application of this theorem to software composition is not that straightforward because the resulting abstract specification of the composite depends upon the hidden guarantees of its subcomponents. In this paper, we investigate how this result can be exploited without blurring responsibilities between the different participants. Our contributions leverage an existing contracting framework for hierarchical software components [7] , in which contracts are first-class objects during configuration and run times. This framework already associates specifications and responsibilities to software components, within the traditional horizontal form of composition. We show here how the vertical one can be made operational using the theorem as a sound formal basis. The resulting composite contracts make possible not only to detect violations, but also to determine and exploit precisely responsibilities upon them, related to both forms of composition.

Philippe Collet, Jacques Malenfant, Alain Ozanne, Nicolas Rivierre

Towards a Unifying Theory for Choreography Conformance and Contract Compliance

Abstract

In the context of Service Oriented Computing, contracts are descriptions of the externally observable behaviour of services. Given a group of collaborating services, their contracts can be used to verify whether their composition is sound, i.e., the services are compliant. In this paper, we relate the theory of contracts with the notion of choreography conformance, used to check whether an aggregation of services correctly behaves according to a high level specification of their possible conversations. The main result of this paper is the definition of an effective procedure that can be used to verify whether a service with a given contract can correctly play a specific role within a choreography. This procedure is achieved via composition of choreography projection and contract refinement.

Mario Bravetti, Gianluigi Zavattaro

Session: Composition Design and Analysis

A Process-Algebraic Approach to Workflow Specification and Refinement

Abstract

This paper describes a process-algebraic approach to specification and refinement of workflow processes. In particular, we model both specification and implementation of workflows as CSP processes. CSP’s behavioural models and their respective refinement relations not only enable us to prove correctness properties of an individual workflow process against its behavioural specification but also allows us to design and develop workflow processes compositionally. Moreover, coupled with CSP is an industrial strength automated model checker FDR, which allows behavioural properties of workflow models to be proved automatically. This paper details some CSP models of van der Aalst et al.’s control flow workflow patterns, and illustrates behavioural specification and refinement of workflow systems with a business process scenario.

Peter Y. H. Wong, Jeremy Gibbons

Generic Feature-Based Software Composition

Abstract

Bridging problem domain and solution in product line engineering is a time-consuming and error-prone process. Since both domains are structured differently (features vs. artifacts), there is no natural way to map one to the other. Using an explicit and formal mapping creates opportunities for consistency checking and automation. This way both the configuration and the composition of product instances can be more robust, support more product variants and be performed more often.

Tijs van der Storm

Composition Management Interfaces for a Predictable Assembly

Abstract

Software system construction based on the reuse of software components has to be done with flexibility enough to control the desired behavior of the resulting assemblies. Applications created by component composition usually depend on a strict method of construction in which COTS or in-house components are only integrated with great difficulty. Actually, reliable assemblies result from being able to observe the inner workings of components and from getting an in-depth understanding of them. The need for fine-grained tailoring and adequate setups is also therefore essential. To enhance the usability, the interoperability and the runtime adaptability of components, composition management interfaces are proposed. They aim at preparing and guiding composition by exposing information about components’ inners (states and transitions), which in turn allow for the making of rules that formalize appropriate composition conditions. Finally, state-based expressions for composition are built on a set of primitives discussed in the paper.

Xabier Aretxandieta, Goiuria Sagardui, Franck Barbier

Path-Based Error Propagation Analysis in Composition of Software Services

Abstract

In Service-Oriented Architectures (SOA) composed services provide functionalities with certain non-functional properties that depend on the properties of the basic services. Models that represent dependencies among these properties are necessary to analyze non-functional properties of composed services. In this paper we focus on the reliability of a SOA. Most reliability models for software that is assembled from basic elements (e.g. objects, components or services) assume that the elements are independent, namely they do not take into account the dependencies that may exist between basic elements. We relax this assumption here and propose a reliability model for a SOA that embeds the “error propagation” property. We present a path-based model that generates the possible execution paths within a SOA from a set of scenarios. The reliability of the whole system is then obtained as a combination of the reliability of all generated paths. On the basis of our model, we show on an example that the error propagation analysis may be a key factor for a trustworthy prediction of the reliability of a SOA. Such a reliability model for a SOA may support, during the system development, the allocation of testing effort among services and, at run time, the selection of functionally equivalent services offered by different providers.

Vittorio Cortellessa, Pasqualina Potena

Session: Dynamic Composition

Dynamically Adaptable Applications with iPOJO Service Components

Abstract

Traditional component models and frameworks simplified software system development by enabling developers to break software systems into independent pieces with well-defined interfaces. This approach led to looser coupling among the system pieces and enhanced possibilities for reuse. While the component-based approach led to advancements in the software development process, it still has its limitations. In particular, after a component-based application is developed and deployed it typically is a monolithic and static configuration of components. The advent of service-oriented component (SOC), the rise in popularity of consumer devices, and the ubiquity of connectivity have fostered a growing interest in applications that react dynamically to changes in the availability of various services. To simplify the creation of such dynamic software systems, it is possible to borrow concepts from SOC and include them into a component model, resulting in a service-oriented component model that specifically supports dynamically adaptable applications. This paper presents iPOJO, a service-oriented component framework to help developers implement dynamically adaptable software systems.

Clement Escoffier, Richard S. Hall

Dynamic Contextual Service Ranking

Abstract

This paper explores service composition in pervasive environments with a focus on dynamic service selection. Service orientation offers the dynamism and loose coupling needed in pervasive applications. However, context-aware service composition is still a great challenge in pervasive computing. Service selection has to deal with dynamic contextual information to enable context-aware behaviors to emerge from the environment. This paper describes how to add dynamic contextual service ranking mechanisms to the service-oriented OSGi framework and further discusses service re-composition decisions.

André Bottaro, Richard S. Hall

Session: Short Papers

Measuring Reactability of Persistent Computing Systems

Abstract

A persistent computing system is a reactive system that functions continuously anytime without stopping its reactions even when it needs to be maintained, upgraded, or reconfigured, it has some trouble, or it is attacked. However, the requirement that a computing system should run continuously and persistently is never taken into account as an essential and/or general requirement by traditional system design and development methodologies. As a result, there is no clearly defined standard to be used for measuring the reactability of a computing system. This paper proposes the first method to measure the reactability of a persistent computing system in a unified way. The paper introduces the notion of reactive processing path among components and shows that the reactive processing paths can be used to measure the reactability of a persistent computing system.

Takumi Endo, Yuichi Goto, Jingde Cheng

Requirements for Applying Aspect-Oriented Techniques in Web Service Composition Languages

Abstract

In current composition languages for web services, there is insufficient support to explicitly separate crosscutting concerns, which leads to compositions that are hard to maintain or evolve. A similar problem in object-oriented languages is being tackled by aspect-oriented programming, and some work has been started to apply these techniques to web service composition languages as well. We identified some problems with these approaches. This short paper lists these limitations and offers a number of requirements to apply aspect-oriented techniques to workflow languages.

Mathieu Braem, Niels Joncheere

Synthesizing Communication Middleware from Explicit Connectors in Component Based Distributed Architectures

Abstract

In component based software engineering, an application is build by composing trusted and reusable units of execution, the components. A composition is formed by connecting the components’ related interfaces. The point of connection, namely the connector, is an abstract representation of their interaction. Most component models’ implementations rely on extensive middleware, which handles component interaction and hides matters of heterogeneity and distribution from the application components. In resource constrained embedded systems this middleware and its resource demands are a key factor for the acceptance and usability of component based software. By addressing connectors as first class architectural entities at model level, all application logic related to interaction can be located within them. Therefore, the set of all explicit connectors of a component architecture denotes the exact requirements of that application’s communication and interaction needs. We contribute by demonstrating how to use explicit connectors in model driven development to synthesize a custom tailored, component based communication middleware. This synthesis is achieved by model transformations and optimizations using prefabricated basic building blocks for communication primitives.

Dietmar Schreiner, Karl M. Göschka

Streamlining Feature-Oriented Designs

Abstract

Software development for embedded systems gains momentum but faces many challenges. Especially the constraints of deeply embedded systems, i.e., extreme resource and performance constraints, seem to prohibit the successful application of modern and approved programming and modularization techniques. In this paper we indicate that this objection is not necessarily justified. We propose to use refinement chain optimization to tailor and streamline feature-oriented designs to satisfy the resource constraints of (deeply) embedded systems. By means of a quantitative analysis of a case study we show that our proposal leads to a performance and footprint improvement significant for (deeply) embedded systems.

Martin Kuhlemann, Sven Apel, Thomas Leich

Requirements for Reusable Aspect Deployment

Abstract

The aspect-oriented paradigm aims to modularize concerns that crosscut traditional abstraction boundaries. In the AOSD community, there is an increasing interest in the development of reusable implementations of typical crosscutting concerns, such as security, synchronization, profiling, etc. To employ a reusable aspect in a concrete application, deployment logic has to be written that specifies where and how to apply the new behavior, and how the interaction with the base application and the other aspects in the system is organized. We have analyzed the means for the specification of such deployment logic in current aspect-oriented technologies and have identified a number of issues regarding its reuse, its dynamic invocation and its integration with the rest of the system. With the knowledge gained, we propose important first steps towards better support for the specification of deployment logic.

Bruno De Fraine, Mathieu Braem

Session: Aspect-Oriented Programming

Aspect-Oriented Programming: Selecting and Exposing Object Paths

Abstract

Aspects require access to the join point context in order to select and adapt join points. For this purpose, current aspect-oriented systems offer a large number of pointcut constructs that provide access to join point information that is local to the join point context, like parameters in method call join points. However, these systems are quite miserly with non-local information that cannot directly be derived from the local execution context. Recently, there have been some proposals that offer access to some kind of non-local information. One such proposal is the path expression pointcut that permits to abstract over non-local object information. Path pointcuts expose non-local objects that are specified in corresponding path expression patterns. In this paper, we show recurrent situations where developers need to access the whole object paths, and consequently, they add workarounds other than pointcut constructs to get the required accesses. Then, we present and study an extension to the path expression pointcuts to permit exposing the object paths and show how this extension overcomes the problem.

Mohammed Al-Mansari, Stefan Hanenberg, Rainer Unland

Debugging Aspect-Enabled Programs

Abstract

The ability to debug programs composed using aspect-oriented programming (AOP) techniques is critical to the adoption of AOP. Nevertheless, many AOP systems lack adequate support for debugging, making it difficult to diagnose faults and understand the program’s composition and control flow. We present an AOP debug model that characterizes AOP-specific program composition techniques and AOP-specific program behaviors, and relates them to the AOP-specific faults they induce. We specify debugging criteria that we feel all AOP systems should support and compare how several AOP systems measure up to this ideal.

We explain why AOP composition techniques, particularly dynamic and binary weaving, hinder source-level debugging, and how results from related research on debugging optimized code help solve the problem. We also present Wicca, the first dynamic AOP system to support full source-level debugging. We demonstrate how Wicca’s powerful interactive debugging features allow a programmer to quickly diagnose faults in the base program behavior or AOP-specific behavior.

Marc Eaddy, Alfred Aho, Weiping Hu, Paddy McDonald, Julian Burger

Unification of Static and Dynamic AOP for Evolution in Embedded Software Systems

Abstract

This paper discusses how evolution in software systems can be supported by a unified application of both static as well as dynamic aspect-oriented technology. The support for evolution is required statically, where the applications could be taken offline and adapted, and dynamically where going offline is not an available option. While this is straightforward in the static case by taking the system offline and statically weaving the aspects, runtime evolution requires an additional dynamic aspect weaving infrastructure.

Our current implementation of the family-based dynamic aspect weaving infrastructure supports most of the features known from the static aspect weaving domain, offers a tailored dynamic aspect weaving support, and is able to target a wide range of applications including embedded systems with very small memory footprint. The availability of a single language both for static and dynamic aspects means that the decision whether an aspect is static or dynamic is postponed to the later stages of the deployment of aspects into the sytem, and is decided according to the requirements and available resources. As a case study, we will present our experiences with the static and runtime evolution of the embedded operating system eCos.

Wasif Gilani, Fabian Scheler, Daniel Lohman, Olaf Spinczyk, Wolfgang Schröder-Preikschat

Session: Structural Composition

Patterns of Component Evolution

Abstract

Contemporary software systems are composed of many components, which, in general, undergo phased and incremental development. In order to facilitate the corresponding construction process, it is important that the development team in charge has a good understanding of how individual software components typically evolve. Furthermore, software engineers need to be able to recognize abnormal patterns of growth with respect to size, structure, and complexity of the components and the resulting composite. Only if a development team understands the processes that underpin the evolution of software systems, will they be able to make better development choices. In this paper, we analyze recurring structural and evolutionary patterns that we have observed in public-domain software systems built using object-oriented programming languages. Based on our analysis, we discuss common growth patterns found in present-day component-based software systems and illustrate simple means to aid developers in achieving a better understanding of those patterns. As a consequence, we hope to raise the awareness level in the community on how component-based software systems tend to naturally evolve.

Rajesh Vasa, Markus Lumpe, Jean-Guy Schneider

An Approach for Structural Pattern Composition

Abstract

Pattern composition has been recognized as a key element for the adoption of pattern languages and systems. This paper discusses the challenges of structural pattern composition and proposes an approach for role-based pattern composition, with two alternative composition mechanisms. To demonstrate the applicability of the proposed composition model, we have extended an existing pattern-driven architecting environment with an implementation of the approach.

Imed Hammouda, Kai Koskimies

Composite Connectors for Composing Software Components

Abstract

In a component-based system, connectors are used to compose components. Connectors should have a semantics that makes them simple to construct and use. At the same time, their semantics should be rich enough to endow them with desirable properties such as genericity, compositionality and reusability. For connector construction, compositionality would be particularly useful, since it would facilitate systematic construction. In this paper we describe a hierarchical approach to connector definition and construction that allows connectors to be defined and constructed from sub-connectors. These composite connectors are indeed generic, compositional and reusable. They behave like design patterns, and provide powerful composition connectors.

Kung-Kiu Lau, Ling Ling, Vladyslav Ukis, Perla Velasco Elizondo

Backmatter

Titel: Software Composition
herausgegeben von: Markus Lumpe
Wim Vanderperren
Verlag: Springer Berlin Heidelberg
Electronic ISBN: 978-3-540-77351-1
Print ISBN: 978-3-540-77350-4
DOI: https://doi.org/10.1007/978-3-540-77351-1