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.
- 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.
(HTML) [@GWU]
-
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.
(HTML) [@GWU]
-
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).
(HTML) [@GWU]
-
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
(demer@dev.hcsd.hac.ca) and
Jas Madhur, MacDonald Dettwiler Associates
(jwm@mda.ca)
[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:
- why these schools are using their choice of language in CS 1;
- how the instructors at these schools feel about their current
language as it compares to Pascal in the way it aids in the
teaching of introductory programming skills; and
- which language these instructors feel is the best one to use
in a CS 1 course.
The result of this survey, conducted in February 1995, are summarized.
- Testing Ada 95 Object-Oriented Programs Classes
by Stéphane Barbey
-- stephane.barbey@di.epfl.ch
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
-- stephane.barbey@di.epfl.ch
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.)
-- stephane.barbey@di.epfl.ch
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
-- stephane.barbey@di.epfl.ch
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
-- srs@vuse.vanderbilt.edu
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
-- Robb.Nebbe@di.epfl.ch
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
-- cthom@iossvr.gm.hac.com
and vceli@iossvr.gm.hac.com
First published in Charles B. Engle Jr. (Ed.), TRI-Ada '95 Conference Proceedings, Anaheim, California, USA, 5-10 November 1995, pp. 179191.
(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
-- kempe@ksce.com
First published in Charles B. Engle Jr. (Ed.), TRI-Ada '95 Conference Proceedings, Anaheim, California, USA, 5-10 November 1995, pp. 394405.
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
-- kempe@ksce.com
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
-- tokar@tartan.com
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
-- pukite@daina.com
(HTML)
-
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
-- beckwb@ois.com
(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
-- wheeler@ida.org
(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
-- pledru@cs.uah.edu
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
-- bal@cs.vu.nl
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
-- kempe@ksce.com
First published in Charles B. Engle Jr. (Ed.), TRI-Ada '94 Conference Proceedings, Baltimore, Maryland, USA, 6-11 November 1994, pp. 141152.
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
-- stephane.barbey@di.epfl.ch
First published in Charles B. Engle Jr. (Ed.), TRI-Ada '94 Conference Proceedings, Baltimore, Maryland, USA, 6-11 November 1994, pp. 129140.
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} @ di.epfl.ch, kempe@ksce.com
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
-- bbalfour@std.caci.com
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
-- bbalfour@std.caci.com
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
-- bbalfour@std.caci.com
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} @ di.epfl.ch
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
-- {catherine.jean@cast.adm.epfl.ch, stephane.barbey@di.epfl.ch}
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
-- Mats.Weber@elca-matrix.ch
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
-- hirasuna@acm.org
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,
199x
([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.
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).