Publications

 Component-based programming is about how to create application programs by prefabricated components with new software that provides both glue between the components, and new functionality. Models of components are required to support black-box compositionality and substitutability by a third party as well as interoperability. However, the glue codes and programs designed by users of the components for new applications in general do not require these features, and they can be even designed in programming paradigms different from those of the components. In this paper, we extend the rCOS calculus of components with a model for glue programs and application programs that is different from that of components. We study the composition of a glue program with components and prove that components glued by a glue program yield a new component.

 Modern software development has to deal with many different aspects and different views of applications. Thus it needs different modelling notations and tools to support more and more phases of the entire development process. To ensure the correctness of the models produced, the tools need to integrate sophisticated checkers, generators and transformations. A feasible approach to ensuring high quality of such add-ins is to base them on sound formal foundations. This paper summarizes our research on the Refinement of Component and Object Systems (rCOS) and illustrates it with experiences from the work on the Common Component Modelling Example (CoCoME). This gives evidence that the formal techniques developed in rCOS can be integrated into a model-driven development process and shows where it may be integrated in computer-aided software engineering (CASE) tools for adding formally supported checking, transformation and generation facilities. Keywords: Formal methods, multi-view modelling, rCOS, software design process, tool design, UML

 The method of refinement of component and object systems, known as rCOS, provides a notation with a formally defined relational semantics. In rCOS, the notions of interfaces, contracts, components, and component publications are formally defined. With the definitions of various compositions and refinement relations between contracts and components, the key software artifacts in all phases of a component-based model driven design process can be formally specified, analyzed and refined. This paper presents our further investigation on problems of component publications and composition of components. We will define the notion of publications of components that describes how a component can be used by a third party in building their own components or in writing their applications without the access to the design or the code of the component. It is desirable that different users of the components can be given different publications according to their need. The first contribution of this paper is to provide a procedure, which calculates a weakest contract of the required interface of a component from the contract of its provided interface and its code. The other contribution, that is more significant from a component-based designer's point of view, is to define composition on publications so that the publication of a composite component can be calculated from those of its subcomponents. For this we define a set of primitive composition operators over components, including renaming, hiding, internalizing and plugging.

Modern software development is complex as it has to deal with many different and yet related aspects of applications. In practical software engineering this is now handled by a UML-like modelling approach in which different aspects are modelled by different notations. Component-based and object-oriented design techniques are found effective in the support of separation of correctness concerns of different aspects. These techniques are practised in a model-driven development process in which models are constructed in each phase of the development. To ensure the correctness of the software system developed, all models constructed in each phase are verifiable. This requires that the modelling notations are formally defined and related in order to have tool support developed for the integration of sophisticated checkers, generators and transformations. This paper summarises our research on the method of Refinement of Component and Object Systems (rCOS) and illustrates it with experiences from the work on the Common Component Modelling Example (CoCoME). This gives evidence that the formal techniques developed in rCOS can be integrated into a model-driven development process and shows where it may be integrated in computer-aided software engineering (CASE) tools for adding formally supported checking, transformation and generation facilities.

Models of software components at different levels of abstraction, component interfaces, contracts, implementations and publications are important for component-based design. Refinement relations among models at the same level and between different levels are essential for model-driven development of components. Classical refinement theories mainly focus on verification and put little attention on design. Therefore, most of them are not suitable for component-based model-driven development (CB-MDD). To address this issue, in this paper, we propose two refinement relations for CB-MDD, that is a trace-based refinement and a state-based refinement. The former comprises a trace refinement between contracts and components and an alternating trace refinement between publications; while the latter comprises a data refinement between contracts and components, and an alternating data refinement between publications. Both of the two refinement relations are discussed in the framework of rCOS, which is a formal model of component and object systems. These refinement relations provide different granularity of abstraction and can capture the intuition that a refined component provides "more" and "better" services to the environment. We also show how to extend these refinement relations to allow us to compare contracts, components and publications with different interfaces by exploiting the primitive operator internalizing over contracts, components and publications.

In a component-based design, a component interface specification describes the guaranteed ordering in which the component accepts calls to its provided methods and the assumption about the order in which the component calls methods it requires. Automata-based formalism is widely used for interface specification and compatibility checking of components. We extend this idea by introducing the concepts of reactive interface automata (RIA) for reactive components and active interface automata (AIA) for active components. We present a component-based architecture description language for object-oriented and service-based design in which a composite reactive component is built from a number of reactive components and active components through different operators. For the architectural operators, we provide the algorithms for constructing RIA of composite components.

In component-based design, a component interface specification describes the guaranteed order in which the provided methods of the component are called and the assumption about the order in which the component calls methods it requires. Automata-based formalism is widely used for interface specification and compatibility checking of components. We extend this idea by introducing reactive interface automata for modeling the interface behavior of reactive components, and active interface automata for active components. The contribution is a composable model of component interfaces that allows static compatibility checking for different kinds of composition of components through their interface models. Algorithms are given for compatibility checking and generating the interface model of a composite component from its execution model.

In component-based design, a component interface specification describes the guaranteed order in which the provided methods of the component are called and the assumption about the order in which the component calls methods it requires. Automata-based formalism is widely used for interface specification and compatibility checking of components. We extend this idea by introducing reactive interface automata for modeling the interface behavior of reactive components, and active interface automata for active components. The contribution is a composable model of component interfaces that allows static compatibility checking for different kinds of composition of components through their interface models. Algorithms are given for compatibility checking and generating the interface model of a composite component from its execution model.

 We present a new automata-based interface model describing the
  interaction behavior of software components. Contrary to earlier
  component- or in\-terface-based approaches, the interface model we
  propose specifies all the non-blockable interaction  behaviors of a
  component with any environment. To this end, we develop an algorithm
  to compute the unblockable interaction behavior, called the
  \emph{interface model of a component}, from its execution
  model. Based on this model, we introduce composition
  operators for the components and prove important
  compositionality results, showing the conditions under which
  composition of interface models preserves unblockable sequences of
  provided services.