V.: A Component Calculus for Modeling the Olan Configuration Language. COORDINATION (original) (raw)

A component calculus for modeling the Olan configuration language

Lecture Notes in Computer Science, 1997

Components will certainly become a key concept for the next generation of software architectures because of their impact on effective software reuse, real interoperability and integration. Within the Olan project [18], we face the difficulty of defining an operational semantics able to reflect the diversity of execution models involved in real applications. Existing process calculi offer the required abstractions such as encapsulation and process equivalences, but they rely on the fundamental assumption that agents are active, i.e autonomously able to initiate communication. However, components, viewed as software pieces with explicit interfaces, require a notion of passive composition that allows, for instance, several components to be traversed by a same process. In this paper, we introduce a calculus, named ICCS, which extends the Milner's CCS calculus with (1) an operator for passive composition, and (2) selective interactions. While preserving the powerful theory of process equivalences established for CCS, this calculus provides an operational definition of passive components and allows thus to establish the basis of an operational semantics for the Olan Configuration Language.

A Calculus for Reconfigurable Component-Based Systems

Clei Electronic Journal, 2004

The concept of reconfigurable systems is almost always restricted to the abstract design level, in which configuration languages are used to manipulate software connections. In this paper, we propose to deal with reconfiguration abstraction also in the formal specification level. We show that the process algebra π-calculus, widely applied to specify composable systems, is not suitable to capture all the properties required by these kinds of systems. To deal with these restrictions of π, we propose the Rπ-calculus. Rπ is a π-calculus extension that uses the concept of components as unit of specification. Its semantics allows for the reconfiguration of formal specifications in the same way configuration languages do.

An Open System Operational Semantics for an Object-Oriented and Component-Based Language

Electronic Notes in Theoretical Computer Science, 2008

Object orientation and component-based development have both proven useful for the elaboration of open distributed systems. These paradigms are offered by the Creol language. Creol objects are concurrent, each with its own virtual processor and internal process control, and communicate using asynchronous (non-blocking) method calls. This provides the efficiency of message passing systems, while keeping the structuring benefits of methods and object-oriented programming. Conditional processor release points provide a high-level synchronization mechanism based on passive waiting that allows us to combine active and reactive behavior. A Creol component can be a single (concurrent) object or a collection of objects, together with a number of interfaces, and cointerfaces, defining the provided and required interaction and semantic behavior. Creol's semantics is defined formally using operational semantics and Hoare logic. An operational semantics lets us simulate an entire system, where all components are known in advance; in contrast, Hoare logic, together with class invariants and communication histories, lets us reason locally about a method body, without needing access to the implementations of the other classes. To bridge the gap between these two semantics, we introduce a history-based operational semantics for open systems. This new semantics can be used as an intermediate step for proving that Creol's Hoare logic is sound and complete with respect to the language's operational semantics. The approach can easily be adapted to other component-based languages where communication is done by message passing or by method interaction.

Flexible Component Composition through Communication Abstraction

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.

Reo: a channel-based coordination model for component composition

Mathematical Structures in Computer Science, 2004

In this paper, we present Reo, a paradigm for composition of software components based on the notion of mobile channels. Reo is a channel-based exogenous coordination model wherein complex coordinators, called connectors are compositionally built out of simpler ones. The simplest connectors in Reo are a set of channels with well-defined behavior supplied by users. Reo can be used as a language for coordination of concurrent processes, or as a "glue language" for compositional construction of connectors that orchestrate component instances in a component-based system. The emphasis in Reo is on connectors and their composition only, not on the entities that connect to, communicate, and cooperate through these connectors. Each connector in Reo imposes a specific coordination pattern on the entities (e.g., components) that perform I/O operations through that connector, without the knowledge of those entities. Channel composition in Reo is a very powerful mechanism for construction of connectors. We demonstrate the expressive power of connector composition in Reo through a number of examples. We show that exogenous coordination patterns that can be expressed as (meta-level) regular expressions over I/O operations can be composed in Reo out of a small set of only five primitive channel types.

pi -calculus semantics for the concurrent configuration language Darwin

2002

the modelling of mobile processes is not straightfor-DARWIN is a configuration language f o r distributed and parallel programs, providing a hierarchical structure of components with dynamic binding. In order t o specify precisely the behaviour of DARWIN programs, we sketch a translation of the features of the language into the a-calculus, a formalism for modelling concurrent processes. The match between underlying models f o r DARWIN and ?r-calculus is good. Examples done in the calculus are clean abstractions of the same solutions in other concurrent languages.

A Notion of Glue Expressiveness for Component-Based Systems

Lecture Notes in Computer Science, 2008

Comparison between different formalisms and models is often by flattening structure and reducing them to behaviorally equivalent models e.g., automaton and Turing machine. This leads to a notion of expressiveness which is not adequate for component-based systems where separation between behavior and coordination mechanisms is essential. The paper proposes a notion of glue expressiveness for component-based frameworks characterizing their ability to coordinate components. Glue is a closed under composition set of operators mapping tuples of behavior into behavior. Glue operators preserve behavioral equivalence. They only restrict the behavior of their arguments by performing memoryless coordination. Behavioral equivalence induces an equivalence on glue operators. We compare expressiveness of two glues G 1 and G 2 by considering whether glue operators of G 1 have equivalent ones in G 2 (strong expressiveness). Weak expressiveness is defined by allowing a finite number of additional behaviors in the arguments of operators of G 2 . We propose an SOS-style definition of glues, where operators are characterized as sets of SOS-rules specifying the transition relation of composite components from the transition relations of their constituents. We provide expressiveness results for the glues of BIP and of process algebras such as CCS, CSP and SCCS. We show that for the considered expressiveness criteria, glues of the considered process calculi are less expressive than general SOS glue. Furthermore, glue of BIP has exactly the same strong expressiveness as glue definable by the SOS characterization.

Composing Specifications for Coordination

1999

We introduce Oikos adtl, a speci cation language for distributed systems based on asynchronous communication via remote writings. The language is designed to support the composition of speci cations. It allows expressing the global properties of a system in terms of the local properties of the components and of coordination patterns. Oikos adtl is based on an asynchronous, distributed, temporal logic, which extends Unity to deal with components and events. We present the speci cation language and its semantics, introduce a number of compositionality theorems, and discuss some coordination patterns. A fragment of a standard case study is used to validate pragmatically the approach, with respect to expressiveness and work-ability.

Component-Oriented Programming with Sharing: Containment is Not Ownership

Lecture Notes in Computer Science, 2005

Component-oriented programming yields a tension between higherorder features (deployment, reconfiguration, passivation), encapsulation, and component sharing. We propose a discipline for component-oriented programming to address this issue, and we define a process calculus whose operational semantics embodies this programming discipline. We present several examples that illustrate how the calculus supports component sharing, while allowing strong encapsulation and higher-order primitives.