Werner Fey

Algebraic Theory of Module Specification with Constraints

The concept for modules in software engineering based on equational algebraic specifications is extended by a suitable notion of constraints. This allows to have loose specifications with constraints for parameter, export and import interfaces of module specifications without loosing executability of the body specification. Correctness of such module specifications ensures that data types satisfying the import constraints are transformed into ones satisfying the export constraints. Operations on module specifications like composition, actualization and union are extended to the case with constraints. They are shown to preserve correctness and to be compositional w.r.t. the semantics. Moreover these operations on module specifications satisfy algebraic laws comparable to those of R-modules in algebra.

Methodology for the Specification of Software Systems: From Formal Requirements to Algebraic Design Specifications

Algebraic specifications of abstract data types and software systems have been studied mainly with respect to the design phase and stepwise refinement towards implementation up to now. This paper shows how to extend the algebraic specification techniques to obtain also a methodology for systematic software development from the requirements to the design Phase. This methodology is based on parameter passing techniques for parameterized specifications with requirements where the notion of requirements is general enough to cover general predicate formulas and different kinds of integrity and consistency constraints.

On the relationship between algebraic module specifications and programs modules

This paper studies the relationship between our long-standing algebraic concept of module specifications and modules as they appear in conventional programming languages. The approach we take is to introduce an intermediate algebraic concept of abstract program modules, which structurally model concrete program modules. We show how a system of abstract program modules is formally related to a system of module specifications. This work is intended to aid the design of modularization mechanisms and to facilitate the transformational development of a system of module specifications into a system of program modules.

Algebraic concepts for software development in ACT ONE, ACT TWO, and LOTOS

Starting from general concepts for software development the role of formal methods in the software development process is discussed and basic algebraic specification concepts are introduced. Moreover some main ideas of the algebraic specification languages ACT ONE and ACT TWO and the specification language LOTOS for concurrent and distributed systems are presented and an overview of the tools in the ACT-System is given.

Categories for the development of algebraic module specifications

The theory of algebraic module specifications with horizontal structuring operations, like composition, actualization and union, is extended by vertical development steps, like refinement, simulation and transformation, and a realization concept of interface by module specifications. Various compatibility results between horizontal operations, vertical steps and realization are explicitly presented and summarized as one compatibility result in a basic development category. Five independent modifications, which are important for practical specification development, are sketched in the paper leading to several other development categories where corresponding compatibility results are true under some additional side conditions.

Towards Abstract User Interfaces for Formal System Specifications

In this paper we propose the concept of an abstract user interface which is an abstract version of some important parts of a user interface as known in software engineering. The main advantage of an abstract user interface formulated in BNF-terms compared with an ordinary user interface written in natural language is the possibility to translate the abstract user interface into a formal specification of the corresponding system. This is achieved by translating the formal parts of an abstract user interface into separate texts of the same formal specification language which is also used for the executable system specification. We link these parts by a third specification text in the same language, which gives an interpretation of the user command language in terms of the system specification. So the resulting executable specification is a prototype of the software system, eguipped with an abstract user interface. We exhibit this method by an example, a simple screen-oriented editor.

Towards a formally based component description language

The importance of a precise definition of what constitutes a software component and how to describe it have become critical issues in the considerations about enhancements of the software development process in general and reuse of software pieces in particular (see e.g. [Boo 87]). We consider these issues by first determining some requirements for component description languages. Based on that we discuss the Π-language as a candidate for a component description language. The Π-language was developed primarily for the specification of distributed modular systems, where the notions of data abstraction and concurrency play an equally important role. After describing the underlying concepts and the syntax of the Π-language we outline an attempt to define its formal semantics by means of algebraic module specifications.

Algebraic Software Development Concepts for Module and Configuration Families

Configuration families are the means of keeping track of structural and historical relationships between the components of a system as they evolve over time. Thus they form a kernel of a configuration management system. In this paper, we study configuration families within a formal semantic framework for modules and their interconnection operations. Our goal is to formulate and prove formally fundamental ideas in this area to serve as a guide to the design of methodologies and tools for software engineering.

Compatibility problems in the development of algebraic module specifications

Abstract Algebraic theory provides a framework for the specification and design of modules and modular software systems. Research in this area has focused on the development of “horizontal” operations for building up module and interface specifications. Our previous work also introduced the notion of vertical development steps, where abstract specifications are converted into a more concrete form. In this paper, we study a variety of compatibility problems between structuring operations and development steps and introduce notions of the realization of an interface specification by a module specification. These compatibility problems are studied in a categorical framework where specifications and developments steps are viewed as objects and morphisms in a “development category”. We show that compatibility can be expressed as the fact that the structuring operations can be extended to partial functors and give sufficient conditions for this property.