Architecture description languages (ADLs) are means to specify software architectures. During the last few years, a number of ADLs addressed structural aspects of software systems. However, constructing architecture descriptions (ADs) requires specific types of domain knowledge and introduces specific restrictions on the problems to be solved. Such requirements and restrictions play a key role in specifying, reusing and evolving ADs, in acquiring domain knowledge, and in defining the problems to be tackled by the software systems. We discuss the different roles that assumptions play in architecture-centered software development and we derive the requirements for capturing them as part of an ADL. We show how such requirements introduce bias for ADL formalisms.

Recent work in the area of software architectures is exploring the use of formal methods for specification and analysis of software architecture designs. The work is particularly aimed at achieving better possibilities for evolution, sharing and reuse among software entities. However, it is believed that specifying architecture components and connections without revealing their underlying design assumptions increases the problems with evolution, their reuse and even interoperability among independently operating components. The paper reveals some of the issues underlying architectural difficulties and concludes that implicit design assumptions pose obstacles. We ascertain that separation of architecture ontology from its design modeling is necessary and provides enough context to examine the assumptions behind the central design decisions in architecture abstractions. We propose a basic architecture ontology that is aimed at providing a formal reconciliation of architecture design assumptions and discuss its usefulness to software engineering.

The rise of the ‘cheaper, faster, better’ mission paradigm increasingly challenges the industrial development of satellite systems. The novel paradigm will have a profound impact on the production of the real-time software embedded on board new-generation systems. This paper contends that a large proportion of the ensuing demands can be satisfied by an iterative and incremental development model revolving around two evolutionary enhancements to the present engineering approach, namely (1) static real-time analysis as a key ingredient of the software verification process, and (2) an architectural paradigm centred on fixed priority preemptive scheduling. Copyright © 1999 John Wiley & Sons, Ltd.

Our interest in the field of software architecture is focused on the application in technical systems, such as control systems. Our current research in this field is centered around a real-life case study, a control system for unmanned vehicles transporting containers on the "Maasvlakte" , an area in the ports of Rotterdam.Important issues in this control system are scalability, evolvability, and on-line change capacities.In this paper, we discuss two mechanisms for on-line change in the distributed control system for the Maasvlakte system, which we have implemented in Java. The software architecture we use is a configuration of distributed processes, communicating according to the subscription model. We will focus on the software architectural aspects of the mechanisms for on-line change. One of these mechanisms is associated with the decoupling of processes as a result of the subscription-based communication model. The other mechanism is based on the late-binding properties of Java.

VDM/sup ++/ is a formal object oriented specification language, which extends VDM by providing object-orientation as well as real-time and parallel features. The use of the language is supported by an extensive toolset and design guidelines. The former offers graphical representations, syntactic and semantic checking, pretty printing and code generation. The latter aim at presenting guidelines for modelling and subsequent development. We argue that, despite its formal character, VDM/sup ++/ is a practically applicable vehicle for software development for real-time control systems. An outline specification case study is included.

The paper presents results from work in progress on finding a method for formal specification and verification of real time concurrent systems that incorporate a non trivial data component. We have extended Timed CCS, a timed CCS variant with a model oriented data language based on VDM. The semantics of the extension, called MTCCS is expressed in a combination of denotational and operational style. We show how verification of temporal logic properties based on symbolic model checking can be made possible for such a combination notation.

An alternative approach to the development of control systems is presented. It differs from current ones in two aspects, because it is based on a formal software specification language, which allows formal verification and because it enables multidisciplinary development of a control system as existing control models can be easily incorporated in the discussed approach. Simulation of ASTRAL specifications is discussed. Simulation, as opposed to verification which is laborious, is useful to provide a quick impression of possible system behaviors. It is shown how existing (continuous) control models, like those constructed using software packages like MatLab, can be incorporated in an ASTRAL specification thus leading to a hybrid specification containing both continuous and discrete subsystems. This hybrid style of specification is illustrated by the example of a robot control system. The specification language and some aspects of control theory are discussed in the introduction. In the second section the example specification concerning robot control and incorporation of continuous system models is discussed. Simulation of the specification is addressed in the third section. The final section presents conclusions and suggestions for future work.

In this paper, a method is presented for the reuse of software designs and software architectures. A software design refers to the abstractions and mechanisms that provide the behavior a system or a component requires. A software architecture refers to the organizational structure of a software system or a component. According to this method, a software design can be represented in terms of extended data-flow graphs (EDFGs) and formal specifications. The graphs and the specifications can be organized into a hierarchical structure, representing different levels of abstraction. Such a structure can be easily understood, modified, reconstructed, aiming at varieties of design targets.>

Abstract In this paper a new model is presented for the run‐time description of arrays, records, and other data types in Ada*‐like programming languanges. The model has several advantages over the classical implementation model using dope vectors. It has been used for the run‐time description of data strutures in an implementation of almost the whole Ada programming languange. First an outline of our data description model is presented, then issues in addressing components of composite objects are discussed. A practical approach to implement the model is discussed next and finally an example is given and some conclusions are drawn.