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.
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?
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.
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.
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.
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].
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: 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.
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.
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
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