Last update: 1995-11-30

Magnus Writes (and Speaks)

For further details, email requests to kempe@ksce.com
Have passport, will travel. Will speak (and even write) for chocolate (the food of the gods). Really.

A Study of Abstraction and Genericity in Pure Functional Programming Languages
Etude de l'abstraction et de la généricité dans les langages fonctionnels purs
Not yet submitted. (November 1995)

Abstract: The purpose of this project was to study abstraction and genericity in pure functional languages, and to compare them with those provided by a high-level imperative programming language, i.e. Ada 95, since Ada is known for the quality of its design and the power of its basic mechanisms. One important criterion of analysis was the approach to and ease of composition of abstractions.

This analysis is carried in the context of a proposed model of abstraction. This model distinguishes the properties condensed by an abstraction and the particular, omitted measurements of these properties-to account for the relationship between concretes and the abstraction subsuming them. Generalization and specialization, two kinds of relationships between abstractions, are described in the same context.

Successful libraries of reusable components depend on the development of powerful abstractions and their ease of composition. This requires careful analysis and fruitful design choices. A far-sighted choice of abstractions is possible only if one is not blinded by the programming language or paradigm used.

To simplify the discussions, we focus our presentation on the mechanisms provided by Haskell, because this language is "standardized" and because it can be taken as an archetype of what pure functional languages are (most differences in nature are syntactic, not semantic). A side-effect of this study is to describe in what ways Ada's support for abstraction-oriented programming may be too narrow or limited.

Abstraction in Software Engineering
Not yet submitted. (August 1995)

Abstract: It is widely recognized that software systems are, for various reasons, extremely complex human products, and that their level of complexity has kept increasing over time. Dealing with this very complexity is a chief purpose of software engineering. Abstraction is the tool for dealing with complexity, and thus it plays a crucial role in the development of software engineering. A proper understanding of abstraction--both the process and its products--is a necessary foundation of software engineering.

As human beings, we deal with complexity by four major means: abstraction, decomposition, tool building, and composition. Abstraction is a cognitive operation that reduces the number of units to be handled at one time. As a process, it is a selective focus; by extension, as an entity, an abstraction is the result of such a process.

We will examine the role of abstraction in software engineering and how to model it. Why is abstraction important? What is the nature of abstraction? Is there a method of abstraction?

The Composition of Abstractions: Evolution of Software Component Design with Ada 95
Magnus Kempe,
in the Proceedings of TRI-Ada '95, November 6-11, 1995, Anaheim, California, USA.

Abstract: Ada 95 has added many new, powerful constructs to the ones that Ada 83 already offered. From the perspective of a designer and implementor of software components with Ada, this will lead to an evolution of the architecture of component families. This paper describes evolutionary issues in design for reuse, indicates potential directions to update the matrix of component properties, and examines some general design options and problems. Finally, a sample family of components is presented as a case study. Ada 95 supports the resolution of many advanced and complex issues in the design and the implementation of adaptable software components.

Keywords: Software Components, Reuse, Abstraction, Adaptability, Abstract data types, Genericity, Ada 95, Type composition.

Heterogeneous Data Structures and Cross-Classification of Objects with Ada 95
Magnus Kempe,
in the Proceedings of Ada-Europe '95, October 2-6, 1995, Frankfurt, Germany.

Abstract: Homogeneous data structures have been classical ADTs to implement in Ada 83. It was also possible to implement a restricted form of heterogeneous data structures, based on variant records. Ada 95 brings new mechanisms supporting powerful abstract data types. These mechanisms lead to several possible approaches in implementing flexible heterogeneous data structures. One of these approaches can even be generalized to create heterogeneous cross-catalogues of objects, thus implementing one kind of multiple classification.

Keywords: Abstract data types, Ada 95, Heterogeneous collections, Classification, Catalogues.

Notes historiques sur le génie logiciel
Magnus Kempe,
Not yet submitted. (February 1994)

Résumé: Une vision classique mais schématisée soutient que le génie logiciel est simplement né en réponse à la "crise du logiciel", avec un point de départ situé en 1968/69.

Toutefois, le développement de logiciel a été considéré comme problématique en soi à partir des années 50 déjà, et des préoccupations variées ont occupé le devant de la scène au cours des années qui ont suivi. Nous verrons quelles ont été les grandes questions soulevées au cours de ces dernières décennies, dans quel ordre chronologique elles ont été traitées, et avec quelles conséquences sur les solutions proposées.

Quality as Successful Design:
The Study of Failure Modes as a Necessary Precondition of Quality
Magnus Kempe,
Not yet submitted. (February 1994)

Abstract: Software, like all other engineering products, is the result of design processes. [Petroski 94] argues that engineers have historically learned more about design from failure than success, and that "the concept of failure is central to the design process."

It is natural to ask whether--and in what fashion--this observation is relevant to the field of software engineering, and more specifically to software quality. In this context, quality is taken to be the absence of failure in a specific set of quality factors (as listed in e.g. [ISO 9126]).

This paper argues for the necessity of analysing and understanding failure modes, in order to complement the analytical and procedural methods associated with software quality endeavours. Some failure modes are universal to the engineering field, others are specific to software engineering [Brooks 87].

Modeling with Objects and Values:
Issues and Perspectives
Gabriel Eckert and Magnus Kempe,
Report on Object Analysis and Design (ROAD),
vol. 1, no. 5, Jan-Feb 1995, pp. 20-27.
Also published in:
Technical Report No 93/29, Département d'Informatique,
Ecole Polytechnique Fédérale de Lausanne, Suisse, November 1993.

Abstract: The nature, purpose and assumptions of modeling are discussed. The concepts of "value" and "object" are assessed in this context. Their fundamental nature is compared and different uses are investigated. Various approaches are illustrated with comparative examples, and we indicate in what respect they may be reconciled beyond their (perceived) oppositions. The paper has the form of a Socratic dialogue.

Abstract Data Types Are Under Full Control with Ada 9X
Magnus Kempe,
TRI-Ada '94 Conference Proceedings ,
Charles B. Engle Jr. (Ed), November 6-11, 1994, Baltimore, Maryland, USA, pp. 141-152.
Also published in:
Technical Report No 94/66, Département d'Informatique,
Ecole Polytechnique Fédérale de Lausanne, Suisse, November 1994.
and in:
Boletin informativo de Ada-Spain, Febrero 1995, Num. 27, pp. 6-17.

Abstract: Ada 83 did not provide enough control on the creation, assignment, and destruction of objects of user-defined types. This lack of control restricted type composition and prevented the full exercise of information hiding on Abstract Data Types. Ada 9X brings new mechanisms supporting the full control of Abstract Data Types, powerful type composition, and more extensive information hiding. With better control of Abstract Data Types, Ada code will be easier to write, understand, and reuse. Thus, applications written in Ada 9X will be safer.

Keywords: Abstract data types, Information hiding, Ada 9X, Object initialization, User-defined Assignment, Object finalization, Memory Reclamation, Reference counting, Type composition.

Advanced Object-Oriented Programming with Ada 9X
Magnus Kempe, Stéphane Barbey, and Alfred Strohmeier,
TRI-Ada 1994 Sunday Tutorial Proceedings,
Baltimore, Maryland, USA, November 6, 1994, pp. 373-467. Abstract

A Framework for The Blackboard Model
Magnus Kempe,
short paper written to demonstrate frameworks in Ada, for the TRI-Ada 1994 Tutorial, "Advanced Object-Oriented Programming with Ada 9X",
Baltimore, Maryland, USA, November 6, 1994.

Abstract: The blackboard model is a flexible problem-solving approach where the data and knowledge rules are strictly separated. The data generated during a problem resolution, from a problem statement to a solution through various stages of inferences, is centrally stored in many forms of objects. The knowledge rules are divided into independent experts; each expert contributes to the resolution with its knowledge of how to search for a (partial) solution of (parts of) the problem.

A blackboard system is composed of three main components: the blackboard, which is a database containing data and hypotheses; knowledge sources, which examine the state of the blackboard and create new data or hypotheses; and a control mechanism, which regulates the incremental hypothesizing and testing.

A blackboard application is a particular problem-solving system developed on top of a blackboard framework. A blackboard framework is an architecture, or skeleton, embodying a blackboard model. This paper describes the architecture of a blackboard framework (or "pattern"), in order to illustrate advanced object-oriented concepts in Ada 95.

Programming with Ada 9X
Stéphane Barbey, Magnus Kempe, and Alfred Strohmeier,
OOPSLA 1994, Conference on Object-Oriented Programming, Systems, Languages and Applications: Outline and Transparencies ,
Portland, Oregon, USA, October 24, 1994. Abstract

La programmation par objets avec Ada 9X
Stéphane Barbey, Magnus Kempe, and Alfred Strohmeier,
TSI (Technique et science informatiques, AFCET) ,
Volume 13 - no 5/1994, pp. 639-669.
Egalement publié dans:
Rapport technique No 94/73, Département d'Informatique,
Ecole Polytechnique Fédérale de Lausanne, Suisse, octobre 1994.

Résumé: Ada 9X, la définition révisée du langage de programmation Ada, intègre la programmation par objets. Cet article examine les nouvelles caractéristiques du langage propres à la programmation par objets, leur utilisation et leur intégration avec le typage fort de Ada. Nous couvrons les mécanismes fondamentaux liés aux objets, tels que l'héritage et le polymorphisme. Nous montrons ensuite comment combiner ces mécanismes en de précieuses pratiques de programmation, comme la programmation par extension, les structures de données hétérogènes, et l'héritage par 'mixin'.

Abstract: Ada 9X, the revised definition of the Ada programming language, supports object-oriented programming. This paper examines the new, object-oriented features of the language, their use, and how they fit into Ada's strong type system. Basic object-oriented mechanisms are covered, such as inheritance and polymorphism. We then show how to combine these mechanisms into valuable programming techniques; topics include programming by extension, heterogeneous data structures, and mixin inheritance.

Mots-clefs: programmation par objets, Ada, langages de programmation, réutilisation, héritage, polymorphisme, types abstraits, contrôle de visibilité, composition d'abstractions, héritage multiple, 'mixins'

Keywords: object-oriented programming, Ada, programming languages, reuse, inheritance, polymorphism, abstract types, control of visibility, composition of abstractions, multiple inheritance, mixins

Ada: Young, Smart and Evolving
Stéphane Barbey, Magnus Kempe, and Alfred Strohmeier,
SI-Information , vol. 40, September 1993, pp. 21-23.

Object-Oriented Programming with Ada 9X
Alfred Strohmeier, Stéphane Barbey, and Magnus Kempe,
OOPSLA 1993, Conference on Object-Oriented Programming, Systems, Languages and Applications: Outline and Transparencies ,
Washington D.C., USA, September 26th-October 1st, 1993. Abstract

Object-Oriented Programming and Reuse in Ada 9X
Alfred Strohmeier, Stéphane Barbey, and Magnus Kempe,
TRI-Ada 1993: Tutorial Proceedings, Volume 2 ,
Seattle, Washington, USA, September 18-23, 1993, pp. 945-984.
Also published in:
Technical Report No 93/30, Département d'Informatique,
Ecole Polytechnique Fédérale de Lausanne, Suisse, August 1993.

Abstract: Ada 9X, the revised definition of the Ada programming language, supports object-oriented programming. This tutorial presents the new, object-oriented features of the language, their use, and how they fit into Ada's strong type system. Basic object-oriented mechanisms are covered, such as inheritance and polymorphism. We then show how to combine these mechanisms into valuable programming techniques; topics include programming by extension, heterogeneous data structures, and mixin inheritance.

Keywords: object-oriented programming, Ada, programming languages, reuse, inheritance, polymorphism, abstract types, control of visibility, composition of abstractions, multiple inheritance, mixins

Ada: Drills (66 pages of exercises for the students)
Ada: Solutions des drills (110 pages of solutions for the teachers)
Magnus Kempe, Prof. A. Strohmeier,
October/November 1992, 2nd ed.

Parallélisation de l'algorithme SSS* avec contrôleurs distribués
Magnus Kempe,
Rapport interne no. 82, Laboratoire d'Informatique Théorique,
Département d'Informatique, Ecole Polytechnique Fédérale de Lausanne, Suisse, December 1991.

Hyperbook: an Experiment with PCTE
Magnus Kempe,
ACM Software Engineering Notes,
Volume 14, no. 5, July 1989.

Simulation distribuée de systèmes à événements discrets
Magnus Kempe,
Rapport interne no. 63, Laboratoire d'Informatique Théorique,
Département d'Informatique, Ecole Polytechnique Fédérale de Lausanne, Suisse, Mars 1988.