A component calculus for modeling the Olan configuration language (original) (raw)

V.: A Component Calculus for Modeling the Olan Configuration Language. COORDINATION

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.

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.

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.

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.

A Logical Interface Description Language for Components

Lecture Notes in Computer Science, 2000

Motivated by our earlier work on the IWIM model and the Manifold language, in this paper, we attend to some of the basic issues in component-based software. We present a formal model for such systems, a formal-logic-based component interface description language that conveys the observable semantics of components, a formal system for deriving the semantics of a composite system out of the semantics of its constituent components, and the conditions under which this derivation system is sound and complete. Our main results in this paper are the theorems that formulate the notion of compositionality and the completeness of the derivation system that supports this property in a componentbased system. 1 Introduction Building applications out of software components is currently a major challenge for Software Engineering. The urgency and importance of this challenge are intensi ed by the continuous rapid growth of the supply and demand for software (components) on the internet, and the prospect of mobile computing. There are close ties between many of the issues investigated in the coordination research community in the past decade or so, on the one hand, and some of the basic problems in Component Based Software Engineering, on the other. Motivated by our earlier work on the IWIM model and the Manifold language, in this paper we introduce a formal logic-based interface description language for components in component-based systems. We consider components as black box computational entities that communicate asynchronously via unbounded FIFO bu ers. Each such FIFO bu er is called a channel and has a system-wide unique identity. The identity of a channel can also be communicated as a value through channels. This allows dynamic recon guration of channel connections among the components of a system. The interface of a component describes its observable behavior abstracting away its implementation in a particular programming language. The interface of a component contains ve elements: a name, a channel signature, and three predicates, namely a blocking invariant, a precondition, and a postcondition.

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.

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.