About the system

P. Borras, D. Clément, Th. Despeyroux, J. Incerpi, G. Kahn, B. Lang, and V. Pascual,
Centaur: the system
Proceedings of SIGSOFT'88, Third Annual Symposium on Software Development Environments (SDE3), Boston, USA, 1988.
abstract: This paper describes the organization of the Centaur system and its main components. The system is a generic interactive environment. When given a formal specification of a particular programming language -including syntax and semantics- it produces a language specific environment. This resulting environment includes a structure editor, an interpreter/debugger and other tools, all of which have graphic interfaces. Centaur is made of three parts: a database components, that provides standardized representation and access to formal objects and their persistent storage; a logical engine that is used to execute formal specification; an object-oriented man-manchine interface that gives easy access to the system's function. Centaur is essentially written in Lisp (LeLisp). The logical engine is Prolog(Mu-prolog). The man-machine interface is built on top of the virtual graphics facility of LeLisp, itself primarily implemented on top of X-Windows.

D. Clément
A Distributed Architecture for Programming Environments
The Fourth Symposium on Software Development Environments (SDE4), ACM SIGSOFT'90, Irvine, December 1990.
abstract: Programming environments are typically based on concepts, such as syntax and semantics, and they provide functionalities, such as parsing, editing, type-checking, and compiling. Most existing programming environments are designed in a fully integrated manner, where parsers, editors, and semantic tools are tightly coupled. This leads to systems that are the sum of all their components, with obvious implications in terms of size, reusability, and maintainability. In this paper, we present a proposal for a distributed architecture for programming environments.

D. Clément, V. Prunet, and F. Montagnac,
Integrated Software Components: A Paradigm for Control Integration
European Symposium on Software Development Environments and Case Technology, E. Albert et W. Herbert, editors, LNCS, Konigswinter, June 1991.
abstract: This report describes how control integration between software components may be organised using an encapsulation technique combined with broadcast message passing: each software component, which is encapsulated within an "integrated software component" (IC), communicates by sending and receiving events. The proposed mechanism can be used for intertool communication as well as for communication within a single tool. This programming architecture frees the code from dependencies upon the effective software component environments and simplifies its extension.

A.-M. Déry and L. Rideau
Distributed programming environments: an example of a message protocol
Inria Technical Report no. 165, August 1994.
abstract: In this paper we present a message protocol used for message passing between external components and a distributed programming environment. This message protocol allows structured data transfer and remote operations as function calls or signal emissions. In the distributed programming environment, a new component called a Message Manager handles the incoming messages and management. This message protocol has been implemented and validated in the Centaur system.

Ian Jacobs and Janet Bertot
SOPHTALK Tutorials
Technical Report no.149, INRIA Sophia-Antipolis, February 1993.
abstract: This paper presents the Sophtlak system through two tutorials that describe salient features of the system and explore appropriate design methods. Sophtalk implements an event model of communication. System objects, called stnodes, emit messages when significant events occur, such as the termination of a computation, a request for a service from another object, errors conditions, etc. Messages circulate asynchronously in a network of stnodes. An stnode's type determines which messages it will receive; upon reception, an action corresponding to the message and stnode instance is triggered.

In the first tutorial, a small network in which a calculator -possibly in a separate process- serves several clients, we introduce the essentiel of Sophtalk funcitonalities. In the second tutorial, a news network, we concentrate on design aspects and illustrate traps to be avoided.

Ian Jacobs and Laurence Rideau-Gallot,
A Centaur Tutorial
Technical Report no.140, INRIA Sophia-Antipolis, July 1992.
(an uptodate version of the tutorial is available here)
abstract: This paper presents the Centaur system through a tutorial describing the creation of an environment for a small language of mathematical expressions called Exp. With Centaur, the user may interactively generate programming language environments, included structured editors, debuggers, interpreters, and other tools. In this tutorial, all phases of language specification are covered: the design of the abstract and concrete syntax of Exp in Metal and Sdf, the pretty printing rules in Ppml, and the semantics of an Exp interpreter in Typol. The tools generated by Centaur based on these specifications are enhanced by a user interface built with Centaur graphic primitives.

Language Environments

P. Asar,
Towards a Multi-Formalism Framework for Architectural Synthesis: the ASAR Project
Third International Workshop on Hardware/Software Codesign (Codes/CASHE'94) Grenoble, Septembre 1994.
abstract: This paper describes a research project -- named ASAR -- grouping together six French research teams, oriented towards architectural and system synthesis. A main concern of this project is hardware/software codesign and user-interface management.

Isabelle Attali, Denis Caromel, and Andrew L. Wendelborn
A Formal Semantics and an Interactive Environment for Sisal
Submitted to publication to Kluwer Academic Publishers in a special volume on Advances in Program Development Tools and Environment for Parallel and Distributed Systems.
abstract: We present a formal definition of the dynamic semantics of a significant part of the language Sisal 2.0 in the structural operational style of Natural Semantics, using Typol inference rules within the Centaur system, a generic specification environment.

Sisal is a strongly typed, applicative, single assignment language in use on a variety of parallel processors, including conventional multiprocessors, vector machines and data-flow machines.

The motivations of our work are, with a formal semantic description of Sisal, to provide a firm foundation for understanding and evaluating language design issues, aid the elimination of ambiguities in the language, provide a valuable reference for both implementors and programmers, and facilitate comparison of Sisal with other parallel functional languages. At the same time, Centaur specifications automatically yield a structure editor and an interpreter for Sisal, which can be developed into an interactive environment for Sisal programming. Also, Centaur permits us to develop animation tools to show the evaluation process.

Besides classical dynamic semantic aspects of functional programming languages such as the absence of side-effects and aliasing, the notion of referential transparency, and higher-order functions, we have characterized specific semantic aspects of the Sisal language such as arrays, infinite streams, sequential and parallel loops (with reduction and masking operators).

From this semantic definition, we intend to formally define program transformations, particularly parallelizations. We will use the two graph-oriented intermediate formats IF1 and IF2 currently used in Sisal implementations; IF1 expresses data dependencies while IF2 is more memory-oriented. We aim at specifying the semantics of both intermediate forms, and the translation from Sisal into IF1 and IF2. Our ultimate goal is to formally describe (prove and extend) parallelization techniques and algorithms for Sisal compilation, and to incorporate such techniques into a program development and visualization environment for Sisal programming.

Dennis S. Arnon, Isabelle Attali, and Paul Franchi-Zannettacci
A Document Manipulation System based on Natural Semantics
Published in Mathematical and Computer Modelling Journal, 1995.
abstract: This paper reports on an application of programming environments generation to structured document manipulation. We use the Centaur system as a formal tool to model and implement logical and physical document structure, logical structure editing, layout processing, format conversion, and document queries, for a sample class of documents: scientific articles containing figures. We support two particular concrete external syntaxes for logical structure: LaTeX, and Tioga (Tioga is a wysiwyg editor in the Cedar programming environment).

From the formal specifications of the logical and physical structures of the Article document class, and a formal specification of varied tools such as layout processing and document queries, the Centaur system automatically generates a document manipulation system including a structured editor for Articles, a format converter between LaTeX and Tioga, a previewer displaying Articles in their layout form as well as management tools over a set of Articles.

Yves Bertot,
Implementation of an Interpreter for a Parallel Language in Centaur
3rd European Symposium on Programming, Copenhague, Denmark, LNCS 432, May 1990. Also appears as Inria Research Report no. 1076 (August 1989).
abstract: This paper presents the implementation of an interpreter for the parallel language Esterel in the Centaur system. The dynamic semantics of the language is described and completed with two modules providing a graphical visualization of the execution and a graphical execution controller. The problems of implementing a parallel language using natural semantics and of providing a visualization for a parallel language are especially addressed.

B. Dion, L. Angeli, and A. Bravo Lastra,
ParaGraph: An interactive environment for parallelizing FORTRAN programs
Research Report Inria no. 1920, May 1993.
abstract: This report presents the implementation of PARAGRAPH, a parallelizer for F, a subset of the FORTRAN lanauge, in the Centaur system. Using, Typol, the dynamic semantics of the language has been formally defined, dependence graphs have been computed and a standard set of transformations has been specified. An interactive user interface based on the Sophtalk message based system has then been experimented.

Semantic Aspects

Isabelle Attali, Denis Caromel, and Michael Oudshoorn,
A Formal Definition of the Dynamic Semantics of the Eiffel Language
Published in the sixteen Australian Computer Science. Conference ACSC'93, Feb 93, Brisbane, Australia
abstract: This paper formally defines the dynamic semantics of the Eiffel language in an operational style using Natural Semantics. We present a technique to describe object-oriented features such as message passing, multiple inheritance, polymorphism, redefinition and dynamic binding.

Isabelle Attali, Denis Caromel, and Sidi Ould Ehmety
A Natural Semantics for Eiffel Dynamic Binding
Submitted to publication
abstract: This paper formally defines the dynamic semantics of the Eiffel language in an operational style using Natural Semantics, and more specifically message passing, multiple inheritance, dynamic binding, and polymorphism. An interactive environment based on this specification has been generated.

Isabelle Attali and Didier Parigot,
Integrating Natural Semantics and Attribute Grammars: the Minotaur System
Research Report no 2339, INRIA Sophia Antipolis September 1994.
abstract: This paper describes the principles and the functionalities of the Minotaur system. Minotaur is a generic interactive environment based on the integration of the Centaur system and the FNC-2 system, two systems widely used to specify syntax and semantics of programming languages and generate efficient semantic tools from these specifications. We show how Attribute Grammars techniques can be adequate for evaluation of a quite large subclass of Natural Semantics specifications, including specifications of an arithmetic calculator, a tree transformation, a type-checker for an Algol-like language, ...

For this subclass of Natural Semantics specifications, the Minotaur system automatically generates an incremental and efficient (in time and memory) evaluator which gives to Natural Semantics an industrial strength implementation.

Isabelle Attali, Jacques Chazarain, and Serge Gilette,
Incremental Evaluation of Natural Semantics Specifications
Proc. of PLILP'92 (Programming Language Implementation and Logic Programming), Leuven Belgique, August 1992, LNCS 631 pp 87-99.
abstract: Natural Semantics is a logical formalism used to specify semantic aspects of a language by sets of logical rules (called a Typol program) where a query is proved using Prolog. In a previous paper, we have shown how to replace, under certain hypotheses, the Prolog engine by a functional evaluator; this is possible because unification is no longer required and can be replaced by pattern matching. Starting from this previous work, we now add incremental facilities to our evaluator. That is to say, after some modification of a term whose semantic value has already been evaluated, we do not need to re-evaluate everything from scratch as it is the case with a Prolog engine.

Yves Bertot, Ranan Fraer,
Reasoning with Executable Specifications
accepted to TAPSOFT/FASE'95
abstract: Starting from the specification of a small imperative programming language, and the description of two program transformations on this language, we formally prove the correctness of these transformations. The formal specifications are given in a single format, and can be compiled into both executable tools and collections of definitions to reason about into a theorem prover. This work is a case study of an environment integrating executable tool generation and formal reasoning on these tools.

Web page maintained by Janet.Bertot@inria.fr and Laurent.Thery@inria.fr