There is a real need for clear and sound design specifications of distributed systems at the architectural level. This is the level of the design which deals with the high-level organisation of computational elements and the interactions between those elements. The paper presents the Darwin notation for specifying this high-level organisation. Darwin is in essence a declarative binding language which can be used to define hierarchic compositions of interconnected components. Distribution is dealt with orthogonally to system structuring. The language supports the specification of both static structures and dynamic structures which may evolve during execution. The central abstractions managed by Darwin are components and services. Services are the means by which components interact. In addition to its use in specifying the architecture of a distributed system, Darwin has an operational semantics for the elaboration of specifications such that they may be used at runtime to di...

a "one-of-a-kind" process, where most software is developed from scratch, even though much of the code is similar to code written for other applications. The cost of these systems can be drastically reduced and the capability of these systems improved by providing a suitable software framework for all R&A sys~ terns, We describe a novel software framework, based on the notion of dynamically reconfigurable software for sensor-based control systems. Tools to support the implementation of this framework have been built into the Chimera 3.0 Real-Time Operating System. The framework provides for the systematic development and predictable execution of flexible R&A applications while maintaining the ability to reuse code f)om previous applications. It combines object-oriented design of software with port-automaton design of digital control systems. A control module is an instance of a class of port-based objects. A task set is formed by integrating objects from a module library to form a specific configuration. An implementation using global state variables for the automatic integration of port-based objects is presented. A control subsystem is a collection of jobs which are executed one at a time, and can be programmed by a user. Multiple control subsystems can execute in parallel, and operate either independently or cooperatively. One of the fundamental concepts of reconfigurable software design is that modules are developed independent of the target hard- ware. Our framework defines classes of reconfigurable device driver objects for proving hardware independence to IJO devices, sensors, actuators, and special purpose processors. Hardware independent real-time communication mechanisms for inter-subsystem eommurtication are also described. A/ong with providing a foundatio...

The Chimera Methodology is a new software engineering paradigm which addresses the problem of developing dynamically reconfigurable and reusable real-time software. The foundation of the Chimera methodology is the port-based object model of a reusable software component. The model is obtained by applying the port-automaton formal computational model to object-based design. Global state variable table real-time communication is used to integrate port-based objects, which eliminates the need for writing and debugging glue code. The Chimera real-time operating system provides tools to support the software models defined by the Chimera methodology, so that real-time software can be executed predictably using common real-time scheduling algorithms. A hypermedia user interface has been designed to allow users to easily assemble the real-time software components that are designed based on the Chimera methodology. Use of the methodology can result in a significant decrease the development time and cost of real-time applications.

Abstract. Modern systems must be adaptable | to changing requirements, bug- xes, new technologies and recon guration. For critical applications this must be possible at run-time; for complex applications it should be limitable to major sub-divisions of the system. The DRASTIC architecture addresses these goals by exploiting object persistence and distributed systems implementation techniques. It enables run-time changes of types, implementations, and the system con guration. This is based on a novel architectural abstraction of locality for evolution, called the `zone'. Contracts between zones automatically limit the visibility of such changes between zones. We present work in progress on DRASTIC's computational model and run-time system, illustrating support for software evolution and highlighting key features of our current implementation. A slightly shorter version of this paper appears in the ECOOP'97 conference proceedings. This document contains more information on the DRASTIC implementation details and related work.

The paper describes the SysMan approach to interactive configuration management of distributed software components (objects). Domains are used to group objects to apply policy and for convenient naming of objects. Configuration Management involves using a domain browser to locate relevant objects within the domain service; creating new objects which form a distributed service; allocating these objects to physical nodes in the system and binding the interfaces of the objects to each other and to existing services. Dynamic reconfiguration of the objects forming a service can be accomplished using this tool. Authorisation policies specify which domains are accessible by which managers and which interfaces can be bound together. Keywords Domains, object creation, object binding, object allocation, graphical management interface. 1 INTRODUCTION The object-oriented approach brings considerable benefits to the design and implementation of software for distributed systems (Kramer 1992). Con...

. A distributed program can be viewed as a composition of three parts. Firstly, there is a coordination part which provides a hierarchical structure of components with dynamic binding. Secondly, there is the actual communication part which provides the interaction and synchronisation required by the system. Finally, there is the computation part providing the component programs. Darwin is a language for describing distributed configurations in terms of component types, their instantiation to components with interfaces and the binding of those interfaces. A Darwin program thus defines a class of configurations. Although the language is very small it contains second-order constructs: component types can appear as parameters in the instantiation of other component types. Furthermore Darwin provides support for dynamic run-time instantiation of components. Component types therefore must have a run-time representation. The coordination part of a distributed program has to be closely associa...

The computing community needs distributed systems to satisfy its need for harnessing more computers solving more problems more quickly. Yet is still hard for programmers to write programs for such systems. Recently, configuration languages have emerged which have the aim of making distributed programming easier, more robust and more flexible. So far, each of these is confined to a small user community, and there is a wide range of features and facilities offered. In this paper, we consider the basic responsibilities of configuration languages and then look at four sample languages in detail. These are Darwin, Durra, PCL and Polylith. The study starts with simple static configuration programming and proceeds to dynamic programming and change management. The producer consumer example is used throughout, and the comparative code fragments shown are a novel feature of the paper. From the results of the comparison we deduce a ten-point scheme of criteria for evaluating a language in terms o...

Darwin is a language designed for configuring distributed systems. A system is modelled as a decompositional hierarchy of components with interfaces. Connections are represented as bindings between interfaces. Darwin programs define component types. Configurations of a system are obtained by instantiating these types. Configurations have to comply with a number of constraints on the system structure. It is therefore intuitive to express these constraints in the domain of configurations rather than on the language level. To succeed in this endeavour we need to precisely express the relation between Darwin programs and configurations. We do this in terms of a firstorder logic theory of Darwin programs and configurations. Models of the theory provide a straightforward mapping from Darwin programs to configurations and vice versa. Most of the constraints on configurations as well as structural transformations can be specified by adding just a few axioms to the theory. Also the theory enab...

Two advances in system design over the past decade are brought together in this paper to enhance the process of building distributed systems. Component based programming separates the construction of computational units from their configuration into complex systems. An accepted technique for configuring components is to use an architectural description languages such as Darwin. The resulting system then runs on an environment such as Regis. Arriving later, Java emphasises the presence of the network, and thereby facilitates large scale distributed programming. This paper presents the design, implementation and assessment of Jaden, a runtime environment written in and based on Java, which will support component based programming. Though most of the functions of Darwin’s Regis environment are present in Jaden, its internal structure is very different. Our results show that using Java’s built-in networking makes for a simpler system with controllable system overhead and good scalability properties.

CO-OPN (Concurrent Object Oriented Petri Net) is a formal specification language for modelling distributed systems; it is based on coordinated algebraic Petri nets. In this paper we describe a method for generating an executable prototype from a CO-OPN specification. We focus our discussion on the generation of executable code for COOPN classes. CO-OPN classes are defined using Petri Nets. The main problems arise when implementing synchronization and non-determinism of CO-OPN classes in procedural languages. Our method proposes a solution to these problems. Another interesting aspect of our method is the easy integration of a generated prototype into any existing system. This paper focuses on the generation of Java code that fulfils the Java Beans component architecture, however our approach is also applicable to other object-oriented implementation languages with a component architecture. 1.