Journal of Integrated Design and Process Science

Constructing complex software systems by integrating different software components is a promising and challenging approach. With the functionality of software components given by models it is possible to ensure consistency of such models before implementation in order to successfully build the system. Models consisting of different submodels, the absence of an overall formal semantics and the numerous possibilities of employing models requires the development of techniques ensuring the consistency. In this paper, we discuss the issue of consistency of models made up of different submodels proposing a concept for the management of consistency. Consistency management relies on a consistency concept and a process for ensuring consistency of models. We introduce a consistency concept for software components modeled in the Unified Modeling Language (UML) and devise suitable consistency checks. On this basis, we propose a process how to locate and resolve inconsistencies, thus ensuring the consistency of models and by that the consistency of component-based systems derived from those models.

In the last years, generative component based techniques have already successfully been used within a large number of software development projects. They have shown to be especially useful in applications where certain patterns of system architecture and/or implementation structures can be identified and used as possible starting points for automatically generating system parts from more abstract descriptions. Standard component "developing" techniques being used were CORBA (including real-time CORBA), DCOM or JavaBeans. But there is huge amount of platforms, not necessarily exotic ones, where neither the traditional middleware techniques (e.g CORBA) nor component techniques can be applied. A particular example for those kind of systems, are given by network embedded, real-time, wireless systems. The size of NEST configurations, their tight integration with dynamic, non-stationary physical processes and limitations in component reliability make the use of self-assembly, self-configuration, self-repair and other forms of adaptation mandatory. These requirements push the demand for new tools and methodologies for designing communication protocols and services for distributed systems supporting a third generation of ultra-high performance middleware and light-weighted components. We're presenting our framework for developing light-weighted, formally correct software which is well suiting for the needs of NEST demands.

Software components are a useful abstraction to manage software systems during their whole lifecycle from early analysis to maintenance. Components can be combined in order to build more complex components or "composed software systems". However, components do not exist independently of component platforms which provide them with a runtime environment. Therefore, developing components means developing components in the context of a dedicated component platform and in many cases in the context of a supporting component framework too. However, there is a rapidly growing number of modern technology platforms which have to coexist with mature but legacy technology. To cope with that challenge the Model-Driven Architecture (MDA™) paradigm was created. The idea is to use a hierarchy of platform-independent models of applications and application domains. Transformation rules allow the generation of platform-dependent code from models. That might work well for newly built systems, but how to include legacy systems or off-the-shelf components in this paradigm? We will discuss a much simpler approach - a platform-independent markup-language for components and a set of tools to support classical round-trip engineering.

Open nets are place-transition Petri nets with interfaces, which support a notion of composition and a corresponding compositional interpretation of the concurrent behaviour of nets. The control synthesis problem of generating a controller for a given plant from an abstract specification of the controller's behaviour can be formulated in terms of open nets by modelling the plant as an open net whose interfaces correspond to the sensors and actuators of the controller and specifying the desired behaviour as a set of processes for this net. Then, the problem consists in synthesising a controller net which, when composed with the net modelling the plant, leads to the specified restriction of the plant's processes.

Based on this observation, which provides an abstraction of the actual synthesis algorithm, we study the problem of generating controllers consisting of several components. In particular, we analyse requirements for the logic used for specifying the controller in order to allow for a compositional, component-wise synthesis.

This paper is based on two general ideas. The first one is the integration paradigm for data type and process modeling techniques developed by the first two authors within the last five years. The second one is a transformation-based component framework for system modeling presented at ETAPS 2002 in Grenoble. The aim of this paper is to join both ideas leading to a component framework for a generic integrated modeling technique. This component framework is based on transformations and is especially useful to be instantiated by graph- and net-based techniques. The main concepts are a self-contained semantics and internal correctness of components, based on a new idea of high-level constraints. Two main results concerning compositionality show that semantics and correctness for a system can be inferred from that of its components. The concepts are illustrated by a running example on modeling Java threads by high-level nets.

Here we present a new module concept for Petri nets that is based on the component concepts of Continuous Software Engineering (CSE). According to that concept two distinguished interfaces are required. These are import and export interfaces. The import describes the assumptions on the environment, e.g. in terms of used components. The export gives an abstraction of the functionality and presents e.g. the offered services.

The modules for Petri we introduce here consist of three nets for the import, the body of the module and the export. The import net IMP states the prerequisites the modules assumes. The body net BOD represents the internal functionality. The export net EXP gives an abstraction of the body that can be used by the environment. We provide module operations to compose larger modules from basic ones. Operations to compose Petri net modules are crucial as the main purpose is composition. In most approaches module concepts come along with just one operation. A great advantage is achieved having different possibilities to compose modules, as it increases the convenience of modeling large systems. We propose three different operations, composition, disjoint union, and union. Our main result in this contribution is that these module operations are compatible with each other.

Since Software Engineering emerged as one of the computer science disciplines at the end of the sixties, one common goal of many different approaches was to provide methods and mechanisms for component-based software construction. Simple reusable, reliable components and simple construction mechanisms - for building big systems out of many simple components - were thought to be the key to managing the increasing complexity in software production. More than 30 years have passed since then. And still we do not find component architectures being applied in most commercial information systems. In this paper, we discuss the objective handicaps and drawbacks of component-based software engineering in a commercial setting and what could be done to change this situation. The presentation is based on the experiences we have gained, when we have been developing new object-oriented information systems for one of the top five German insurance companies.