Resources for Ada

Online Papers

The online Ada papers contained here are either included thanks to contributing authors or are external references. The goal is to ensure timely dissemination --without commercial design-- of scholarly and technical work. Copyright and all rights therein are maintained by the authors or by other copyright holders, notwithstanding that their works are offered here electronically. It is understood that all persons copying this information will adhere to the terms and constraints invoked by each author's copyright. These works may not be redistributed without the explicit permission of the copyright holder.

Highly recommended reading: The ACM has published a document called the ACM Interim Copyright Policies. It addresses the copyright policies that seem to best apply to electronic publications. Read also the Author's Guide to these copyright policies. (These issues were discussed in CACM 38(4), April 1995.)

It is very easy to submit to HBAP a paper you have written or to communicate an external reference for something that is online somewhere else; please read the instructions on How to submit a paper.

You can read the following online Ada-related papers (listed in reverse chronological order of insertion in this list):

Quantifying the Debate: Ada vs. C++
by Donal J. Reifer

This paper appeared in Crosstalk 9(7), July 1996.
(HTML) [@Crosstalk]

Abstract: Software developers continue to debate the virtues of C++ vs. Ada. In an attempt to provide a fair assessment, this is one consultant's analysis of cost, reliability, and maintainability metrics for similar commercial and military systems. Although this assessment favors C and C++ in some areas, Ada holds up well as a choice for weapon systems and airborne and spaceborne avionics. After he left government service, many people called D.J. Reifer for an update to the hard data he used to periodically publish the cost, reliability, and maintainability of systems developed with Ada, C, C++, and other software engineering technologies. Because these requests have value, he has taken the time to analyze the data he continues to get from the many organizations he helped during the past decade to institute a metrics data collection program.

Foggy Bottom Transit Authority: a Model Rapid Transportation System with Ada 95 Software Control
by Michael B. Feldman, Alden A. Dima, and Yair Rajwan

This paper appeared in Proceedings of the Tenth Annual Ada Software Engineering and Training Symposium (ASEET), Prescott, AZ, June 1996.

Abstract: Foggy Bottom Transit Authority (FoBTA) is a computer-controlled HO-scale model of an urban rapid transportation system based loosely on Metrorail, the rapid rail network of Washington, D.C. and its suburbs in Maryland and Virginia. The name Foggy Bottom refers to the neighborhood in which The George Washington University is located, near the Potomac River and midway between the White House and Watergate. The area is low-lying and was originally swampy, hence the name Foggy Bottom.

FoBTA models a part of the Metrorail system using off-the-shelf HO model railroad equipment and some additional electronic parts, along with a computer running the GNU Ada 95 compiler (GNAT) under the Linux operating system. This project was inspired by the successful work of John McCormick and his students. Our work differs mainly in that we are modeling a rapid transit system instead of a conventional freight railroad.

The Portable Dining Philosophers: a Movable Feast of Concurrency and Software Engineering
by Michael B. Feldman

This paper appeared originally in Proc. 23rd ACM-SIGCSE Technical Symposium on Computer Science Education, Kansas City, MO, March 1992. This online version adds some hyperlinks, a brief update at the end, and several new references.

Abstract: This paper describes a course-related project in concurrent programming using the Ada language. Dijkstra's famous "dining philosophers" problem is used as a vehicle for developing a program rich enough in system construction problems to be realistic yet small enough to be manageable in a classroom situation. The program--Portable Diners--is also nicely animated and fun to observe in execution.

One of the most important advantages of Ada is its strong standard, which governs the entire language including modularization (package) and concurrency (task) constructs. This project demonstrates that sophisticated Ada programs, using a number of packages and tasks, can be written, without much difficulty, to be entirely portable.

Introduction to Concurrent Programming
by Michael B. Feldman

This is chapter 15 from Software Construction and Data Structures with Ada 95, M.B. Feldman. Copyright 1997 , Addison-Wesley Publishing Company. (published June 1996; ISBN 0-201-88795-9).

Abstract: This chapter introduces you to the fascinating field of concurrent programming, which is the writing of concurrent programs. Ada provides an especially rich and interesting set of structures for concurrent programming; this chapter presents some of these structures. In particular, we introduce Ada task types and protected types. A task object is an active program, carrying on its activities independently of other tasks and interacting with others only when necessary. A protected object is passive; its purpose is to encapsulate a data structure and provide services to tasks on request, allowing many tasks to view the structure simultaneously but authorizing only one task at a time to modify the structure.

Programming the Internet in Ada 95
by S. Tucker Taft

(HTML) [@Intermetrics]

Abstract: A new paradigm for computing is emerging based on the Internet and the World Wide Web, accompanied by a new standard programming platform based on the Java(tm) technology recently announced by Sun Microsystems. The Java technology includes the definition for a platform-independent byte code representation for small applications called applets, which allows Java-enabled Web browsers to download and execute these Java applets using a byte code interpreter.

Although the Java byte-code representation was designed specifically for the new Java language, it turns out that the underlying semantic models of Ada 95 and Java are sufficiently similar that a very direct mapping from Ada 95 to Java byte codes is possible. We at Intermetrics are in the process of adapting our Ada 95 compiler front end to generate Java byte codes directly, thereby allowing the development of Java-compatible applets in Ada 95. This paper explains our approach, and provides details on the mapping from Ada 95 features to Java byte codes, as well as the mapping from certain Java features to Ada 95. We have found the combination of the Ada 95 and Java technologies to be very natural and powerful, providing the best characteristics of both technologies, with essentially no loss in functionality.

Implementing the C++ Standard Template Library in Ada 95
by Ulfar Erlingsson and Alexander V. Konstantinou

TR96-3, CS Dept., Rensselaer Polytechnic Institute, Troy, NY, January 1996
(Postscript, 27 pages, 84KB) [original@RPI]

Abstract: The Standard Template Library (STL), a recent addition to the ANSI C++ standard, "provides a set of well structured generic C++ components that work together in a seamless way." The popularity of STL stems from its combination of an orthogonal design, solid theoretical foundation, and strong emphasis on efficiency. This paper presents a design scheme for implementing the C++ STL library components in Ada, using features introduced in the 1995 Ada standard. Discussion is based on a prototype Ada 95 implementation, segments of which illustrate the paper. This work was prepared under the supervision of Dr. David Musser at Rensselaer Polytechnic Institute.

This paper won the "Best Paper Award" at Ada-Europe'96.
Experiences Applying a Practical Architectural Method
by David E. Emery, Richard F. Hilliard II, and Timothy B. Rice

published in Alfred Strohmeier (Ed.), "Reliable Software Technologies - Ada-Europe '96", proceedings, Lecture Notes in Computer Science, Vol 1088, Springer, Ada-Europe International Conference on Reliable Software Technologies, Notreux, Switzerland, June 10-14, 1996, ISBN 3-540-61317-X
(HTML, 42KB)

Abstract: Software architecture has come to be recognized as a discipline distinct from software design. Over the past five years, we have been developing and testing a practical software architecture method at the MITRE Software Center. The method begins with an initial statement of system goals, the purchaser's vision for the system, and needs, an abstraction of the system's requirements. Multiple views of the system are then developed, to address specific architectural concerns. Each view is defined in terms of components, connections and constraints and validated against the needs. This paper briefly introduces the method and describes our experiences with its "alpha" and "beta" applications to two U.S. Army management information systems.

Keywords: software architecture, information systems, methods

HCSD Unit Development Process: Step-Wise Process Improvement
by David Emery, Hughes Aircraft of Canada, Systems Division ( and Jas Madhur, MacDonald Dettwiler Associates (
[a revision of this paper is planned, showing initial process metrics results]
published in Alfred Strohmeier (Ed.), "Reliable Software Technologies - Ada-Europe '96", proceedings, Lecture Notes in Computer Science, Vol 1088, Springer, Ada-Europe International Conference on Reliable Software Technologies, Notreux, Switzerland, June 10-14, 1996, ISBN 3-540-61317-X
(HTML, 36KB)

Abstract: Hughes Canada has been involved with the development of the Canadian Automated Air Traffic Control System (CAATS) software since 1993. The program, originally estimated to be over a million lines of Ada code, has evolved from prototyping concepts and requirements to producing operational software. This paper describes the evolution of the procedures for software development. We explain the reasons behind the changes made to the unit development process, and show our movement from ad-hoc through qualitative to quantitative process enhancement, consistent with our transition from prototyping to production.

Ada Outperforms Assembly: A Case Study
by Patricia K. Lawlis and Terence W. Elam

published in Proceedings of TRI-Ada '92, Orlando, FL, November 16-20, Association for Computing Machinery (ACM), New York, 1992
(HTML, 18KB) [@GWU]

Abstract: With the intent of getting an Ada waiver, a defense contractor wrote a portion of its software in Ada to prove that Ada could not produce real-time code. The expectation was that the resultant machine code would be too large and too slow to be effective for a communications application. However, the opposite was verified. With only minor source code variations, one version of the compiled Ada code was much smaller while executing at approximately the same speed, and a second version was approximately the same size but much faster than the corresponding assembly code.

Comparing Development Costs of C and Ada
by Stephen F. Zeigler, Ph.D., Rational Software Corporation

March 1995, not yet published
(HTML, about 100KB including graphics) [@Rational]

Abstract: Programming Languages often incite zealotry because of theoretic advantages, whether from market acceptance or from intrinsic features. Practical comparisons of languages are more difficult. Some projects, notably prominently failing ones, cite choice of language and tools as a reason for their failure. Analysis is complex however: big projects aren't done twice in parallel just to see which language/tool choice is better, and even then there would be questions about the relative talent, teamwork, and fortunes of the efforts. This article discusses one case where most variables were controlled enough to make a comparison between development costs of C versus development costs of Ada.

Two companies, Verdix and Rational, merged in 1994 to form Rational Software Corporation. In the process of Due Diligence, records were examined to determine the value of the two companies but also to judge the best technologies and methodologies to continue into the future of the merged company. During that process, the extensive and complete update records of the Verdix Aloha development showed that there might be quantitative basis for comparing the success of two languages, C and Ada, under the fairest known conditions. A cursory pre-merger evaluation resulted in the following assertion:

"We have records of all changes ever made in the development of Verdix products; those records show us that for the lifecycle Ada seems to be about 2x or better for cost effectiveness than C..."
We have now completed a much more extensive evaluation. Our data applies more to development costs than to whole lifecycle costs. Even so, the above cost estimates are substantiated in comparing C and Ada development.

Computer Language Usage In CS 1: Survey Results
by Suzanne Pawlan Levy

reproduced from SIGCSE Bulletin, 27(3):21-26, Sept. 1995
(HTML, total size 100KB?) [@UOFS]

Abstract: The Reid Report [Reid 94] is a list of more than 400 schools throughout the world and the language they are using in their first computing science course (commonly referred to as ACM's CS 1). It is a voluntary report updated regularly. Its list of schools is not exhaustive or complete. Based on this report, 139 colleges and universities within the United States who are not using Pascal were surveyed. The intent of the survey was threefold: The result of this survey, conducted in February 1995, are summarized.

Testing Ada 95 Object-Oriented Programs Classes
by Stéphane Barbey
in M. Toussaint (Ed.), Ada-Europe '95 Conference Proceedings, Frankfurt, Germany, 2-6 October 1995 (LNCS: Lecture Notes in Computer Sciences, Springer-Verlag).
(Postscript, 14 pages, 58KB)
Also available: Ada-Europe Slides (Postscript, 20 slides, 216KB)

Abstract: We show some of the specific problems for testing software introduced by the object-oriented features of Ada 95, and focus on specification-based testing, since this strategy is the key strategy for testing object-oriented software. We present a theory for testing software by refinement of an exhaustive test set into a finite test set using three reduction hypothesis. We also show how the Oracle problem can be partially solved using some particular features of Ada 95.

Ada 95 as Implementation Language for Object-Oriented Designs
by Stéphane Barbey
First published in Charles B. Engle Jr. (Ed.), TRI-Ada '95 Conference Proceedings, Anaheim, California, USA, 5-10 November 1995, pp. 212-225.
(Postscript, 14 pages, 82KB)
Also available: TRI-Ada Slides (Postscript, 20 slides, 848KB)

Abstract: In this paper, we show how Ada 95 can be used as an implementation language for object-oriented designs. We present a strategy to map Fusion class descriptions into Ada specifications, considering the various kinds of qualifiers that can be applied to attributes, and the various ways methods can be mapped. We also discuss issues such as naming conventions, mapping of operations, use of mixins and of generics. Finally, we show how bidirectional associations, that usually end up in a mutual dependency, can be implemented in Ada 95.

Experiences in Object-Oriented Programming (Panel)
Stéphane Barbey (Ed.)
First published in Charles B. Engle Jr. (Ed.), TRI-Ada '95 Conference Proceedings, Anaheim, California, USA, 5-10 November 1995, pp. 194-199.
(Postscript, 6 pages, 39KB)

Abstract: The goal of this panel is to renew this discussion, now that the language definition is complete, that more complete development environments have found their way to the programmer, and especially that we have more experience with its features. The panel will focus on all aspects of object-oriented programming with Ada 95. The discussion will cover expressivity, programming practices, the match with design methods, integration, and any issue related to Ada in object-oriented software development.

Annotating Dispatching
by Stéphane Barbey
Proceedings of the TRI-Ada '95 Workshop on Design Guidelines for Ada 95, Anaheim, California, USA, 5-10 November 1995.
(Postscript, 5 pages, 32KB)

Abstract: Dispatching calls decrease the understandability of programs, and thus some extra annotations must be given some extra highlight by special annotation. We present and criticize several possibilities to annotate dispatching and re-dispatching calls.

Translating C++ Software into Ada 95
by Kimberly K. Uhde and Stephen R. Schach
First published in "CrossTalk", October 1995.
(HTML) [@Crosstalk]

Abstract: Before 1995, a software developer had to choose between building software that was object oriented and software that had the reliability of Ada 83. By translating C++ into Ada 95, we can now achieve more reliable object-oriented software. This article describes a case study in which such a translation was performed manually. The various difficulties that were encountered are described, together with the solutions that were adopted. This article concludes with a justification for an automatic translator from C++ to Ada 95.

Using Inheritance in Ada
by Robb Nebbe
First published in Ada in Switzerland Conference Proceedings, Bern, Switzerland, 23 November 1995.
(Postscript, 5 pages, 39KB)

Abstract: The purpose of this paper is not so much to introduce Ada language features but to examine the concepts underlying some of these features, soecifically class-wide and specific types. It is hoped that this will provide a foundation facilitating decisions about how to use these two features when programming.

This paper won the "Best Paper Award" at TRI-Ada'95.
DVM: An Object-Oriented Framework for Building Large Distributed Ada Systems
by Christopher J. Thomson and Vincent Celier
-- and
First published in Charles B. Engle Jr. (Ed.), TRI-Ada '95 Conference Proceedings, Anaheim, California, USA, 5-10 November 1995, pp. 179­191.
(HTML, 63KB)

Abstract: This paper presents a description of a reusable framework for building large, distributed Ada applications. The framework, known as the Distributed Virtual Machine (DVM), provides a portable suite of integrated services for building a wide variety of distributed, fault tolerant applications. It serves as the foundation for a family of automated air traffic control systems currently under development by Hughes Aircraft Company. The DVM provides an "abstract instruction set" for developing distributed systems, allowing applications to be developed without concern for the actual physical distribution. This level of abstraction is essential for managing the complexity of the air traffic control systems, which are estimated to require the development of up to one million lines of Ada source code.

The paper first describes the architectural philosophy and objectives of the DVM. Then the most important services providedare described, showing how they support the overall architectural objectives. The paper also describes how the DVM supports the development of reliable, fault tolerant systems with near real-time performance requirements. Finally, the paper concludes with a description of how the DVM already uses many of the new concepts offered by Ada 95 and how it will be modified to take advantage of Ada 95 language capabilities.

The Composition of Abstractions: Evolution of Software Component Design with Ada 95
by Magnus Kempe
First published in Charles B. Engle Jr. (Ed.), TRI-Ada '95 Conference Proceedings, Anaheim, California, USA, 5-10 November 1995, pp. 394­405.
This is a (cosmetically) revised version, dated November 21, 1995.
(Postscript, 12 pages, 63KB)

Abstract: Ada 95 adds many new, powerful constructs to the ones Ada 83 already offered. From the perspective of a designer and implementor of Ada software components, this should encourage an evolution in the architecture of component families, and from the perspective of the user the improvements must be understood. This paper describes evolutionary issues in designing reusable components, 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. The conclusion is that Ada 95 helps solve many advanced and complex issues in the design and implementation of adaptable software components, benefitting both designers and users of reusable component libraries.

Keywords: Software Component, Reuse, Abstraction, Evolution, Adaptability, Composition, Signature, Mixin, Abstract Data Type, Genericity, Ada 95.

Heterogeneous Data Structures and Cross-Classification of Objects with Ada 95
by Magnus Kempe
First published in the Ada-Europe '95 Conference Proceedings, Frankfurt, Germany, 2-6 October 1995 (Springer-Verlag).
This is a (cosmetically) revised version, dated November 21, 1995.
(Postscript, 6 pages, 40KB)

Abstract: The implementation of ADTs for homogeneous data structures has become a classic example of ADT in Ada 83. With some effort, it was also possible to implement a restricted form of heterogeneous data structures, based on variant records. We show that various approaches in implementing flexible heterogeneous data structures with Ada 95 are now possible. One of these approaches is generalized to create heterogeneous catalogues of cross-referenced objects, thus implementing one kind of multiple classification.

Keywords: Abstract Data Types, Ada 95, Heterogeneous Collections, Classification, Catalogues.

Ada 95: The Language for the 90's and Beyond
by Joyce Tokar
Copyright 1995 Ada Language UK. First published in the Ada User Journal 16(3).
(postscript, 8 pages, 15KB)

Abstract: New and existing software systems are being designed to satisfy the demands of increasingly complex requirements. A variety of tools and methodologies are being developed to address these elaborate conditions. The selection of a programming language may have a significant impact on the development of such systems. To be most effective in the successful implementation of complex software systems, the programming language should support the system requirements. This paper presents a common set of complex requirements and demonstrates how Ada 95 satisfies them.

Global Positioning of Ada
by Paul Pukite

Abstract: Given the fascination the media has had with the Internet (aka the Information Superhighway), one could easily overlook the success of yet another government technology transfer project. The Global Positioning System (GPS) has clearly made the leap from serving primarily as a military defense tool to a product with a vast amount of commercial potential. From uses in aviation to outdoor recreational activities, we have already seen surprising new markets opening up.

If we look at the core of GPS technology, we find that Ada has played a significant role in its success. Although the DoD will not make available all of the details of the GPS architecture for security reasons, the commercial end-user applications have had a definite Ada flavor.

Building Better Bindings in Ada 95
by Bill Beckwith
(postscript, 6 pages, 59KB) [@OIS]

Abstract: Unlike Ada, most popular programming languages do not provide a robust mechanism specifically designed for interface definition. The lack of a clear interface definition makes writing applications in language X that use a body of non-X code especially challenging. In addition, languages and their compilers format data structures and use calling conventions in many different ways. Ada 95 offers new features for developing bindings. This paper presents these features and develops strategies for building bindings in Ada 95.

Lovelace: An Ada 95 Tutorial
by David A. Wheeler
(postscript, 10 pages, 81KB)

Abstract: Lovelace is a free interactive tutorial for Ada 95 [RM 95] and is available through the World Wide Web (WWW). This paper describes Lovelace, including basic facts about it, its organization, implementation, user comments, and lessons learned. This paper should be of use to educators considering the use of Lovelace in courses using Ada, users of Lovelace, and educators considering the development of computer-aided instruction programs for the World Wide Web (WWW).

A Review of Non-Ada to Ada Conversion
Prepared for USAF Rome Laboratory, by Kaman Sciences Corporation

(hypertext, 63 page report) [@Kaman]

Abstract: This report provides a discussion of the processes and problems involved with the conversion of software from early High Order Languages (HOLs) to Ada. Specific compatibility and format difficulties are discussed for each HOL examined, including C, Cobol, Fortran, Jovial, Modula-2, and Pascal. Several conversion approaches are presented, along with the advantages and disadvantages of each. Three specific conversion projects are overviewed. Points of contact for several currently available Off the Shelf (OTS) tools to help the conversion process are included for reference, with a short discussion of each.

Translation of the Protected Type mechanism in Ada 83
by Pascal Ledru
Copyright Pascal Ledru. First published in AdaLetters XV(1):64-69.
(Postscript, 6 pages, 76KB)

Abstract: Several features of the Ada 95 language are useful to improve the efficiency of Ada programs. Especially the protected type mechanism is useful to improve the efficiency of concurrent Ada programs sharing common data structures. In order to facilitate the transition to Ada 95 before Ada 95 compilers are widely available, this paper proposes the use of an adapter which can be either a methodology, or an automatic translator. The adapter accepts source including protected objects and produces Ada 83 source. The results of several tests show that the performances of concurrent programs can be dramatically improved by using protected objects.

Comparing Data Synchronization in Ada 9X and Orca
by Henri E. Bal
First published in AdaLetters XV(1):50-63.
(Postscript, 14 pages, 46KB)

Abstract: Protected object types are one of three major extensions to Ada 83 proposed by Ada 9X. This language feature is intended for light-weight data synchronization between tasks. The Orca parallel programming language has a very similar construct, the shared data-object, with which we have over five years of experience, both in usage and implementation. This paper compares protected objects and shared data-objects, with regard to design, usage, and implementation.

Keywords: synchronization, parallel languages, distributed systems, language design.

Abstract Data Types Are Under Full Control with Ada 9X
by Magnus Kempe
First published in Charles B. Engle Jr. (Ed.), TRI-Ada '94 Conference Proceedings, Baltimore, Maryland, USA, 6-11 November 1994, pp. 141­152.
This is a revised version, dated March 23, 1995.
Also appeared in Boletin informativo de Ada-Spain, Febrero 1995, Num. 27, pp. 6-17.
(Postscript, 13 pages, 72KB)

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.

Working with Ada 9X Classes
by Stéphane Barbey
First published in Charles B. Engle Jr. (Ed.), TRI-Ada '94 Conference Proceedings, Baltimore, Maryland, USA, 6-11 November 1994, pp. 129­140. This revised version appeared in SpAda, No 26, Octobre 94, pp. 15-26.
(Postscript, 12 pages, 72KB)
Also available: TRI-Ada Slides (Postscript, 23 slides, 232KB)

Abstract: Ada 9X refines the Ada 83 concept of class and introduces class-wide types to support run-time polymorphism. We study how the Ada definition of class compares to other definitions of this term. We examine how run-time polymorphism is introduced in Ada 9X, how it relates to the different concepts of subtype, and how it compares with other forms of polymorphism. We also discuss the different uses of class-wide types, mainly as a means for dynamic binding (dispatching). However, since Ada 9X has adhered to the philosophy of building blocks, class-wide entities can be used for other purposes than dispatching. These uses are idioms that every programmer should be aware of. Some of these idioms are presented here. We also examine how classes are integrated with generics.

Keywords: Ada 9X, Object-Oriented Programming, Class, Polymorphic types, Run-time polymorphism, Dispatching, Genericity, Class-wide programming, Subtype, Anchor, Mixin.

Object-Oriented Programming with Ada 9X
by Stéphane Barbey, Magnus Kempe, and Alfred Strohmeier
-- {Stephane.Barbey, Alfred.Strohmeier} @,
This is a draft version of a technical report. It was the basis for an article published in French.

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 and genericity mechanisms. 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, Mixins.

Ada 95 Tips and Tidbits Number 1:
User Defined Assignment

by Brad Balfour
First published in Ada Letters XIV(5), September/October 1994 [@SIGAda]

Abstract: User Defined Assignment (UDA) is needed whenever the default semantics of a private type (which are derived from the semantics of the underlying implementation) don't match the semantics that the designer desires for the abstraction. Typically, this occurs when the underlying implementation uses access types. In this case, ":=" no longer gives copy semantics, it gives share semantics. Most of the time, the designer wants the abstraction to have copy semantics (i.e., after a:=b; then b:=x doesn't change a). Unwanted share semantics can be eliminated by redefining ":=" so that it copies the object that the underlying access type points to rather than just copying the access type.

Ada 95 Tips and Tidbits Number 2:
Expressing Design Inheritance Relationships in Ada 95

by Brad Balfour
First published in Ada Letters XV(3), May/June 1995 [@SIGAda]

Abstract: Because Ada 95 separates the concepts of modularity (expressed in the language through the Ada program units such as packages) from the concept of inheritance (expressed through the used of derived tagged types), it is possible to model several different design uses of inheritance directly in the Ada programming language. As a specific example, we will consider the two typical uses for inheritance: the "is-a" relationship and the "is-implemented-using" relationship. Ada 95 allows these two uses of inheritance to be expressed differently, and therefore to be clearly understood.

Ada 95 Tips and Tidbits Number 3:
Inheritance and Child Library Units

by Brad Balfour
First published in Ada Letters XV(4), July/August 1995 [@SIGAda]

Abstract: This column expands on the themes introduced in Tips and Tidbits #2 [Ada Letters XV(3), May/June 1995], by continuing to discuss variations on inheritance that are possible in Ada 95. In this column we'll look at the combination of derived types, packages, and hierarchies of both types and packages. Since Ada 95 clearly, and in my opinion correctly, separates the concepts of module and type, there are many issues to explore. And I'll attempt to demonstrate that rarest of occurrences -- where the combination of two features leads to simpler software.

Testing Ada Abstract Data Types using Formal Specifications
by Stéphane Barbey and Didier Buchs
-- {Stephane.Barbey, Didier.Buchs}  @
First published in the proceedings of the 1st International Eurospace-Ada-Europe Symposium, Copenhagen, September 1994, LNCS no 887, Springer Verlag, 1994, pp. 76--89.
(Postscript, 14 pages, 48KB)
Also available: Ada-Europe Slides (Postscript, 23 slides, 200KB)

Abstract: The purpose of this paper is to present an experiment with formal methods for the black-box testing of reusable abstract data types (ADTs). We propose to test a family of software components by re-engineering a formal specification from an existing Ada implementation, using algebraic specifications. From this well-defined basis, we generate test sets automatically, by constructing an exhaustive set of formulae that prove the property preservations of a program with respect to its specifications, and by reducing this set to a finite size by applying reduction hypotheses. Once the selection of a finite test set has been performed, we show how to build the oracle, the decision procedure for the success or the failure of a test set. Finally, we discuss the advantages of test sets generated from the formal specification over those defined by a programmer, based on his intuitive understanding of the behavior of the ADT.

Keywords: Ada, ADT, formal specifications, reengineering, testing, automatic test sets generation.

Implementing Associations with Ada
by Catherine Jean-Pousin and Stéphane Barbey
-- {,}
First published in the proceedings of Software Engineering and its Applications 1993, Paris, 15-19 novembre 1993, pp. 149-158.
(Postscript, 10 pages, 41KB)
Also available: Conference Slides (Postscript, 56 slides, 464KB)

Abstract: Object-oriented programming is a mechanism used to construct modular systems made of reusable components. Objects that compose a system are necessarily related. This is the reason why the relationships between the objects are one of the major factors in the development of software. Unfortunately, of all the relationships between the objects, the associations are often left aside. Therefore, we investigated a way to implement associations, using a language that does not provide a built-in construct for that purpose.

We start by giving a definition of associations and then an implementation-oriented taxonomy of the different kinds of associations. Then, according to this taxonomy, we propose a way to implement the associations using Ada 83. We also show, for a particular case, how Ada 9X can be used. The solutions proposed allow to translate all the semantics attached to associations while preserving the integrity of the system to develop.

Proposals for Enhancement of the Ada Programming Language:
A Software Engineering Perspective

by Mats Weber
thesis, 1994
(Level 2 Postscript, 130 pages --or 70 pages reduced-- compressed to ~ 1 MB)

Abstract: This thesis is a critique of the Ada 83 programming language with emphasis on the construction of reusable components and their composition, and more generally on programming "in the large".

Ada 83's deficiencies in that area are first described, and then solutions are proposed to most of the problems.

The main part of the thesis is a proposal for object-oriented extensions, making classes and objects with inheritance available through package and task types, as a very natural extension of Ada 83's task types.

These proposals can be viewed as an alternative to Ada 9X's tagged types, with which a comparison is made.

BATCES Solution #2: A Simplified SA/OOD Approach
by Michael Hirasuna
received in January 1995
(Postscript, 22 pages, 79KB)

Abstract: In large embedded systems, where Ada is often mandatory, it is not clear if Structured (i.e. function-oriented) or Object-Oriented methodologies should be used. Even though Object-Oriented methods are favored in software-only development, Structured Analysis provides better communication of requirements when software is part of a larger system. This paper proposes a "best of both worlds solution," Structured Analysis for requirements, Object-Oriented Design for coding. Unlike other SA/OOD approaches, Simplified SA/OOD takes advantage of Ada's self-documenting features to minimize the required design products. All design products, i.e. diagrams and tables, were created on a personal computer using only low-cost software tools. The BATCES problem statement, created by the SigAda OOWG, is used to illustrate the method.

Orthogonal Persistence and Ada
by Stephen C. Crawley and Michael J. Oudshoorn,

First published in Proceedings TRI-Ada '94, Nov 6-11 1994, pp. 298-308, ACM. Will also be published by DSTO as an ESRL Research Report.
Also available as: (Postscript, 11 pages, 242 KB)

Abstract: Research into persistent programming languages and systems in recent years has shown that the technology is useful for developing complex software in many problem domains. This paper explores the issues of adding persistence support to Ada, either as extensions to Ada 9X, or as an integral part of the next version of the language.

Ada Tasking for Sensor and Control Applications
by P.R. Pukite,

([strange, Windows-generated] Postscript, 4 pages, 58KB)

Abstract: The Ada language allows for the development of sophisticated applications. For example, Ada's concurrency features relieves the developer of acquiring a multi-tasking operating system, multi-tasking language libraries, or additional code for task scheduling. In fact, the built-in tasking feature of Ada remains a consistently overlooked tool for a developer who wishes to design or prototype a multiple process system. Given the wide availability of Ada compilers for various platforms, the embedded system developer should strongly consider Ada for various industrial sensor and control applications. This paper provides an example of the use of Ada tasking for a personal computer application.

Ada for MS-Windows
by P.R. Pukite,

July 1994
([strange, Windows-generated] Postscript, 6 pages, 112KB)

Abstract: With the power inherent in many of the current computing environments, including Microsoft (MS) Windows, developers will demand alternative languages specifically designed to handle large and complex projects. Clearly, Ada manages large projects well, but its utility for Windows applications is little known. This paper describes techniques used in developing Ada Windows programs and component libraries (as well as interfacing to external libraries). The key result is that large, well-integrated, reliable, maintainable, and reusable Ada applications can be developed for the Windows environment. The development process becomes more manageable and less obscure by using standard Ada constructs such as package specifications, generics, tasking, and exceptions.

Ada 9X for Embedded Systems Development
by S.T. Taft,

draft of article published in EE Times, 6 June 1994, p. 112
(hypertext, 20 KB)

Abstract: Anyone involved with the development of embedded systems should take a serious look at Ada 95, as it retains the excellent readability and safety of the original version (Ada83), while providing the flexibility and control of lower-level languages, and full support for object-oriented programming and multitasking.

How to Submit Your Paper

If you'd like to submit some of your papers, great! All you need to do is e-mail your paper to the editor or if it is large (more than 100KB) upload it to the incoming directory of (be sure to send a message to the address above to inform us that you've uploaded a file and to give a description for the listing here). There are no particular restrictions on the subject of a paper (as long as it is related to Ada and/or software engineering).

Please check the Copyright if you've already published it elsewhere. Since this is not a commercial publication, copyright transfers should normally allow storage here provided that the paper includes: appropriate acknowledgment, title and date of publication, and notice that copying is by permission (check the copyright transfer form you signed).

Please read also the information on submitting material for inclusion in the Ada Home.

Page last modified: 1998-12-25