Wolfgang Grieskamp

OPAL: Design and Implementation of an Algebraic Programming Language

The algebraic programming language OPAL has been designed as a testbed for experiments with the specification and development of functional programs. The language shall in particular foster the (formal) development, of productionquality software that is written in a purely flmctional style. As a consequence, OPAL molds concepts from Algebraic Specification and Functional Programming into a unified framework. The amalgamation of these two concepts which are both based on a sound theoretical foundation constitutes an ideal setting for the construction of formally verified safe software. Moreover, the high level of abstraction and the conceptual clarity of the functional style can increase the productivity of software development significantly. Unfortunately, the acceptance of the functional style suffers from the widespread prejudice that its advantages are paid for by a high penalty in runtime and storage consumption. Yet, this is not, true. Due to their semantic elegance and clarity, functional programs are amenable to a wide variety of powerful optimizations, such that the programmer need not be concerned with low-level considerations about machine pecularities. This way, she can concentrate on finding good algorithmic solutions instead. The potential for automatic optimizations is highly increased, when functional programs are combined with algebraic specifications. Then, algebraic properties of the flmctional programs can be used to guide optimizations which go far beyond traditional optimization techniques. In this paper we illustrate some principles of algebraic programming. Moreover, we introduce the language OPAL, sketch its compilation strategies, and point out some challenges for further research in the area of algebraic programming languages.

Specifying embedded systems with statecharts and Z: an agenda for cyclic software components

The application of formal techniques can contribute much to the quality of software, which is of utmost importance for safety-critical embedded systems. These techniques, however, are not easy to apply. In particular, methodological guidance is often unsatisfactory. We address this problem by the concept of an agenda. An agenda is a list of activities to be performed for solving a task in software engineering. Agendas used to support the application of formal specification techniques provide detailed guidance for specifiers, templates of the used specification language that only need to be instantiated, and application independent validation criteria. We apply the agenda approach to a particular class of embedded safety-critical systems, the formal specification of which has been investigated in the case-studies of the German Espress project during the last two years.

A Computation Model for Z Based on Concurrent Constraint Resolution

We present a computation model for Z, which is based on a reduction to a small calculus, called µZ, and on concurrent constraint resolution techniques applied for computing in this calculus. The power of the model is comparable to that of functional logic languages, and combines the strength of higher-order functional computation with logic computation. The model is implemented as part of the ZETA system, where it is used for executing Z specifications for the purpose of testdata evaluation and prototyping.

A Modular Framework for the Integration of Heterogeneous Notations and Tools

We report on the notation and tool integration framework developed in the application-oriented research project Espress. The framework is based on a Z core and provides means of integrating formalisms on a syntactical, semantical as well as tool technical level. Currently, the framework integrates Z with the languages of Statemate [15], i.e. Statecharts to describe reactive behavior and activity charts to describe structural aspects. Our means of integration are, however, general enough to integrate other, esp. synchronous languages, as well, and reuse much of the existing tools in the process.

From program languages to software languages

In modern Software Engineering it is no longer sufficient to consider programming as the task of writing implementations in more or less suited programming languages and adding a more or less accurate documentation. Rather, the amalgamation of various aspects and views into a heterogeneous assembly of coordinated products is required. In this paper we present a vision of such a scenario. This vision is based on experiences with both academic style foundational research and industry-oriented applied research projects.

Combining Z and Temporal Interval Logics for the Formalization of Properties and Behaviors of Embedded Systems

We describe a variant of discrete temporal interval logics which is embedded, and extends the Z notation. The resulting formalism, called DZ, includes the usual set of operators known from interval logics together with a set of operators tailored for the operational description of deterministic process behavior. We apply our approach to the foundation of a combination of Statecharts and Z by giving a translation from a significant subset of Statecharts into DZ.

Generating Efficient Portable Code for a Strict Applicative Language

We discuss the overall style of code generation for the strict applicative language OPAL. It differs in two respects from the usual declarative language implementations. Firstly, instead of compiling to an abstract machine, we use C as the target language, inheriting many of the machine-dependent low-level optimizations nowadays performed by C compilers. Secondly, instead of using a copying or scanning garbage collector, we use an optimized variant of the classical reference counting scheme, resulting in a residual garbage collector and the capability to perform run-time-detected selective update on recursive data structures.

An Open Environment for the Integration of Hetereogenous Modelling Techniques and Tools

Even though the development of formal methods makes steady progress with respect to techniques and tool support, their acceptance in industry is still relatively low. One reason for this probably stems from the fact that most formal approaches require users to forget about their conventional techniques and tools, and to relearn in a new environment. What makes this switch even harder to accept: due to their research character, tools for formal methods can usually not compete w.r.t. convenience, stability, and degree of integration to conventional, state-of-the-art commercial tools.

Communicating Functional Agents and Their Application to Graphical User Interfaces

We demonstrate how concepts of communicating agents can be integrated into purely functional languages by an orthogonal extension of I/O monads. These agents communicate via so-called service access points and foster concurrent programming in the style of client-server architectures. By applying our approach to the realization of graphical user interfaces it turns out that the combination of functional expressiveness and concurrency monads yields a powerful framework for such systems.

Programming in the Large: The Algebraic-Functional Language Opal 2alpha

We present design aspects of the algebraic-functional language Opal 2α, which features flexible modularization to support programming in the large. Opal 2α provides parameterized structures and theories as part of packages. Parameterized theories serve to specify properties of functions and are shown — along with partial instantiations — to play a similar role to type classes in Haskell. Structures can be viewed as (mere) interfaces or as concrete implementations. A realization relation between structures tells us which implementation realizes which interface. A package is a kind of folder for structures and theories. Packages establish flexible name spaces via an import relation. Name spaces, overloading and instance derivation are based on a well-established annotation concept.