Section 1.1 - What is Ada?

Ada is a computer programming language originally designed to support the
construction of long-lived, highly reliable software systems.
Its design emphasizes readability, avoids error-prone notation,
encourages reuse and team coordination, and it is designed to be
efficiently implementable.

A significant advantage of Ada is its reduction of debugging time.
Ada tries to catch as many errors as reasonably possible, as early as possible.
Many errors are caught at compile-time by Ada that aren't caught or
are caught much later by other computer languages.
Ada programs also catch many errors at run-time if they can't be caught
at compile-time (this checking can be turned off to improve performance
if desired).
In addition, Ada includes a problem (exception) handling mechanism so that
these problems can be dealt with at run-time.

However, Ada's user base has expanded far beyond the U.S. DoD
to many other areas such as
large-scale information systems, distributed systems,
and scientific computation.
Major Ada niches include aerospace and safety-critical systems.
An informal
1994 survey
concluded that Ada was the most popular language for safety-critical systems.

People use Ada for small projects as well as large ones, since Ada's
error-catching capabilities (both compile-time and run-time)
significantly reduce debugging time.
Also, Ada's parallel constructs can take advantage of today's more advanced
operating systems (such as Microsoft's Windows NT and Linux).

Many people use Ada when the application must run quickly.
The Ada programming language was designed to be efficiently
implementable, since one of its key application domains is in real-time
embedded systems (where efficiency is critical).
The actual efficiency of an Ada program, of course,
depends on the the algorithms selected and the actual Ada compiler used.
The first Ada compilers, like many other first compilers of a given language,
generated inefficient code; modern Ada compilers
generally generate relatively good code.
Sadly, the performance of the initial Ada compilers created a myth of
slow execution that is only beginning to disappear.
The best test of efficiency, of course,
is to benchmark a specific compiler with the
type of problem you wish to solve.

Where and how is Ada standardized?

Ada was originally standardized by ANSI in 1983
(ISO released an equivalent standard in 1987).
Ada was recently revised to add some new capabilities;
this revision is called `Ada 9X' or `Ada 95'.
Ada compiler vendors have generally updated their compilers to
add the new Ada 95 features.
This tutorial covers the capabilities of Ada 95, but will note which
features are new to Ada 95.

Ada is officially defined in its reference manual (RM).
The
complete Ada 95 RM is available on-line as a hypertext document.
However, the RM is not intended to be a tutorial and can be
hard to understand if you're not already somewhat familiar with Ada.
We will often refer to the RM, and feel free to look at it if you're
interested in more detail about a particular subject.

Ada was not designed by a committee.
The original Ada design was the winner of a language design competition;
the winning team was headed by Jean Ichbiah
(Ichbiah's language was called "Green").
The 1995 revision of Ada (Ada 95)
was developed by a small team led by Tucker Taft.
In both cases, the design underwent a public comment period where the
designers responded to public comments.

What exactly are Ada's capabilities?

Packages (modules) of related types, objects,
and operations can be defined.

Packages and types can be made generic (parameterized through a template)
to help create reusable components.

Errors can be signalled as exceptions and handled explicitly.
Many serious errors (such as computational overflow and invalid
array indexes) are automatically caught and handled
through this exception mechanism, improving program reliability.

Tasks (multiple parallel threads of control) can be created and communicate.
This is a major capability not supported in a standard way by many
other languages.

Data representation can be precisely controlled to support
systems programming.

A predefined library is included; it provides input/output (I/O),
string manipulation, numeric functions,
a command line interface, and a random number generator
(the last two were available in Ada 83, but are standardized in Ada 95).

Object-oriented
programming is supported (this is a new feature of Ada 95).
In fact, Ada 95 is the first internationally
standardized object-oriented programming language.

Interfaces to other languages (such as C, Fortran, and COBOL)
are included in the language (these have been significantly
enhanced in Ada 95).
At least one Ada compiler (from Intermetrics)
can generate Java Virtual Machine (J-code)
from Ada, so people can
use Ada
to develop Java applets and applications.