Ada is a structured, statically typed, imperative,
wide-spectrum, and object-oriented high-level
computer programming language, extended from
Pascal and other languages. It has built-in
language support for explicit concurrency,
offering tasks, synchronous message passing,
protected objects, and non-determinism. Ada
is an international standard; the current
version is defined by ISO/IEC 8652:2012.
Ada was originally designed by a team led
by Jean Ichbiah of CII Honeywell Bull under
contract to the United States Department of
Defense from 1977 to 1983 to supersede the
hundreds of programming languages then used
by the DoD. Ada was named after Ada Lovelace,
who is credited as being the first computer
programmer.
Features
Ada was originally targeted at embedded and
real-time systems. The Ada 95 revision, designed
by S. Tucker Taft of Intermetrics between
1992 and 1995, improved support for systems,
numerical, financial, and object-oriented
programming.
Notable features of Ada include: strong typing,
modularity mechanisms, run-time checking,
parallel processing, exception handling, and
generics. Ada 95 added support for object-oriented
programming, including dynamic dispatch.
The syntax of Ada minimizes choices of ways
to perform basic operations, and prefers English
keywords to symbols. Ada uses the basic arithmetical
operators "+", "-", "*", and "/", but avoids
using other symbols. Code blocks are delimited
by words such as "declare", "begin", and "end",
whereas the "end" is followed by the identifier
of the block it closes. In the case of conditional
blocks this avoids a dangling else that could
pair with the wrong nested if-expression in
other languages like C or Java.
Ada is designed for development of very large
software systems. Ada packages can be compiled
separately. Ada package specifications can
also be compiled separately without the implementation
to check for consistency. This makes it possible
to detect problems early during the design
phase, before implementation starts.
A large number of compile-time checks are
supported to help avoid bugs that would not
be detectable until run-time in some other
languages or would require explicit checks
to be added to the source code. For example,
the syntax requires explicitly named closing
of blocks to prevent errors due to mismatched
end tokens. The adherence to strong typing
allows detection of many common software errors
either during compile-time, or otherwise during
run-time. As concurrency is part of the language
specification, the compiler can in some cases
detect potential deadlocks. Compilers also
commonly check for misspelled identifiers,
visibility of packages, redundant declarations,
etc. and can provide warnings and useful suggestions
on how to fix the error.
Ada also supports run-time checks to protect
against access to unallocated memory, buffer
overflow errors, range violations, off-by-one
errors, array access errors, and other detectable
bugs. These checks can be disabled in the
interest of runtime efficiency, but can often
be compiled efficiently. It also includes
facilities to help program verification. For
these reasons, Ada is widely used in critical
systems, where any anomaly might lead to very
serious consequences, e.g., accidental death,
injury or severe financial loss. Examples
of systems where Ada is used include avionics,
railways, banking, military and space technology.
Ada's dynamic memory management is high-level
and type-safe. Ada does not have generic or
untyped pointers; nor does it implicitly declare
any pointer type. Instead, all dynamic memory
allocation and deallocation must take place
through explicitly declared access types.
Each access type has an associated storage
pool that handles the low-level details of
memory management; the programmer can either
use the default storage pool or define new
ones. It is even possible to declare several
different access types that all designate
the same type but use different storage pools.
Also, the language provides for accessibility
checks, both at compile time and at run time,
that ensures that an access value cannot outlive
the type of the object it points to.
Though the semantics of the language allow
automatic garbage collection of inaccessible
objects, most implementations do not support
it by default, as it would cause unpredictable
behaviour in real-time systems. Ada does support
a limited form of region-based memory management;
also, creative use of storage pools can provide
for a limited form of automatic garbage collection,
since destroying a storage pool also destroys
all the objects in the pool.
Ada was designed to resemble the English language
in its syntax for comments: a double-dash,
resembling an em dash, denotes comment text.
Comments stop at end of line, so there is
no danger of unclosed comments accidentally
voiding whole sections of source code. Comments
can be nested: prefixing each line with "--" will
skip all that code, while being clearly denoted
as a column of repeated "--" down the page.
There is no limit to the nesting of comments,
thereby allowing prior code, with commented-out
sections, to be commented-out as even larger
sections. All Unicode characters are allowed
in comments, such as for symbolic formulas.
To the compiler, the double-dash is treated
as end-of-line, allowing continued parsing
of the language as a context-free grammar.
The semicolon is a statement terminator, and
the null or no-operation statement is null;.
A single ; without a statement to terminate
is not allowed.
Code for complex systems is typically maintained
for many years, by programmers other than
the original author. These language design
principles apply to most software projects,
and most phases of software development, but
when applied to complex, safety critical projects,
benefits in correctness, reliability, and
maintainability take precedence over costs
in initial development.
Unlike most ISO standards, the Ada language
definition is free content. Thus, it is a
common reference for Ada programmers and not
just programmers implementing Ada compilers.
Apart from the reference manual, there is
also an extensive rationale document which
explains the language design and the use of
various language constructs. This document
is also widely used by programmers. When the
language was revised, a new rationale document
was written.
One notable free software tool that is used
by many Ada programmers to aid them in writing
Ada source code is the GNAT Programming Studio.
History
In the 1970s, the US Department of Defense
was concerned by the number of different programming
languages being used for its embedded computer
system projects, many of which were obsolete
or hardware-dependent, and none of which supported
safe modular programming. In 1975, a working
group, the High Order Language Working Group,
was formed with the intent to reduce this
number by finding or creating a programming
language generally suitable for the department's
requirements. The result was Ada. The total
number of high-level programming languages
in use for such projects fell from over 450
in 1983 to 37 by 1996.
The HOLWG working group crafted the Steelman
language requirements, a series of documents
stating the requirements they felt a programming
language should satisfy. Many existing languages
were formally reviewed, but the team concluded
in 1977 that no existing language met the
specifications.
Requests for proposals for a new programming
language were issued and four contractors
were hired to develop their proposals under
the names of Red, Green, Blue and Yellow.
In April 1978, after public scrutiny, the
Red and Green proposals passed to the next
phase. In May 1979, the Green proposal, designed
by Jean Ichbiah at CII Honeywell Bull, was
chosen and given the name Ada—after Augusta
Ada, Countess of Lovelace. This proposal was
influenced by the programming language LIS
that Ichbiah and his group had developed in
the 1970s. The preliminary Ada reference manual
was published in ACM SIGPLAN Notices in June
1979. The Military Standard reference manual
was approved on December 10, 1980, and given
the number MIL-STD-1815 in honor of Ada Lovelace's
birth year. In 1981, C. A. R. Hoare took advantage
of his Turing Award speech to criticize Ada
for being overly complex and hence unreliable,
but subsequently seemed to recant in the foreword
he wrote for an Ada textbook.
Ada attracted much attention from the programming
community as a whole during its early days.
Its backers and others predicted that it might
become a dominant language for general purpose
programming and not just defense-related work.
Ichbiah publicly stated that within ten years,
only two programming languages would remain,
Ada and Lisp. Early Ada compilers struggled
to implement the large, complex language,
and both compile-time and run-time performance
tended to be slow and tools primitive. Compiler
vendors expended most of their efforts in
passing the massive, language-conformance-testing,
government-required "ACVC" validation suite
that was required in another novel feature
of the Ada language effort.
The first validated Ada implementation was
the NYU Ada/Ed translator, certified on April
11, 1983. NYU Ada/Ed is implemented in the
high-level set language SETL.
In 1987, the US Department of Defense began
to require the use of Ada for every software
project where new code was more than 30% of
result, though exceptions to this rule were
often granted.
By the late 1980s and early 1990s, Ada compilers
had improved in performance, but there were
still barriers to full exploitation of Ada's
abilities, including a tasking model that
was different from what most real-time programmers
were used to.
The Department of Defense Ada mandate was
effectively removed in 1997, as the DoD began
to embrace COTS technology. Similar requirements
existed in other NATO countries.
Because of Ada's safety-critical support features,
it is now used not only for military applications,
but also in commercial projects where a software
bug can have severe consequences, e.g. avionics
and air traffic control, commercial rockets,
satellites and other space systems, railway
transport and banking. For example, the fly-by-wire
system software in the Boeing 777 was written
in Ada. The Canadian Automated Air Traffic
System was written in 1 million lines of Ada.
It featured advanced distributed processing,
a distributed Ada database, and object-oriented
design. Ada is also used in other air traffic
systems, e.g. the UK’s next-generation Interim
Future Area Control Tools Support air traffic
control system is designed and implemented
using SPARK Ada. It is also used in the French
TVM in-cab signalling system on the TGV high-speed
rail system, and the metro suburban trains
in Paris, London, Hong Kong and New York City.
Standardization
The language became an ANSI standard in 1983,
and without any further changes became an
ISO standard in 1987. This version of the
language is commonly known as Ada 83, from
the date of its adoption by ANSI, but is sometimes
referred to also as Ada 87, from the date
of its adoption by ISO.
Ada 95, the joint ISO/ANSI standard was published
in February 1995, making Ada 95 the first
ISO standard object-oriented programming language.
To help with the standard revision and future
acceptance, the US Air Force funded the development
of the GNAT Compiler. Presently, the GNAT
Compiler is part of the GNU Compiler Collection.
Work has continued on improving and updating
the technical content of the Ada programming
language. A Technical Corrigendum to Ada 95
was published in October 2001, and a major
Amendment, ISO/IEC 8652:1995/Amd 1:2007 was
published on March 9, 2007. At the Ada-Europe
2012 conference in Stockholm, the Ada Resource
Association and Ada-Europe announced the completion
of the design of the latest version of the
Ada programming language and the submission
of the reference manual to the International
Organization for Standardization for approval.
ISO/IEC 8652:2012 was published in December
2012.
Other related standards include ISO 8651-3:1988
Information processing systems—Computer
graphics—Graphical Kernel System language
bindings—Part 3: Ada.
Language constructs
Ada is an ALGOL-like programming language
featuring control structures with reserved
words such as if, then, else, while, for,
and so on. However, Ada also has many data
structuring facilities and other abstractions
which were not included in the original ALGOL
60, such as type definitions, records, pointers,
enumerations. Such constructs were in part
inherited or inspired from Pascal.
"Hello, world!" in Ada
A common example of a language's syntax is
the Hello world program:
This program can be compiled by using the
freely available open source compiler GNAT,
by executing
Data types
Ada's type system is not based on a set of
predefined primitive types but allows users
to declare their own types. This declaration
in turn is not based on the internal representation
of the type but on describing the goal which
should be achieved. This allows the compiler
to determine a suitable memory size for the
type, and to check for violations of the type
definition at compile time and run time. Ada
supports numerical types defined by a range,
modulo types, aggregate types, and enumeration
types. Access types define a reference to
an instance of a specified type; untyped pointers
are not permitted. Special types provided
by the language are task types and protected
types.
For example a date might be represented as:
Types can be refined by declaring subtypes:
Types can have modifiers such as limited,
abstract, private etc. Private types can only
be accessed and limited types can only be
modified or copied within the scope of the
package that defines them. Ada 95 adds additional
features for object-oriented extension of
types.
Control structures
Ada is a structured programming language,
meaning that the flow of control is structured
into standard statements. All standard constructs
and deep level early exit are supported so
the use of the also supported 'go to' commands
is seldom needed.
Packages, procedures and functions
Among the parts of an Ada program are packages,
procedures and functions.
Example: Package specification
Package body
This program can be compiled e.g. by using
the freely available open source compiler
GNAT, by executing
Packages, procedures and functions can nest
to any depth and each can also be the logical
outermost block.
Each package, procedure or function can have
its own declarations of constants, types,
variables, and other procedures, functions
and packages, which can be declared in any
order.
Concurrency
Ada has language support for task-based concurrency.
The fundamental concurrent unit in Ada is
a task which is a built-in limited type. Tasks
are specified in two parts - the task declaration
defines the task interface, the task body
specifies the implementation of the task.
Depending on the implementation, Ada tasks
are either mapped to operating system tasks
or processes, or are scheduled internally
by the Ada runtime.
Tasks can have entries for synchronisation.
Task entries are declared in the task specification.
Each task entry can have one or more accept
statements within the task body. If the control
flow of the task reaches an accept statement,
the task is blocked until the corresponding
entry is called by another task. Task entries
can have parameters similar to procedures,
allowing tasks to synchronously exchange data.
In conjunction with select statements it is
possible to define guards on accept statements.
Ada also offers protected objects for mutual
exclusion. Protected objects are a monitor-like
construct, but use guards instead of conditional
variables for signaling. Protected objects
combine the data encapsulation and safe mutual
exclusion from monitors, and entry guards
from conditional critical regions. The main
advantage over classical monitors is that
conditional variables are not required for
signaling, avoiding potential deadlocks due
to incorrect locking semantics. Like tasks,
the protected object is a built-in limited
type, and it also has a declaration part and
a body.
A protected object consists of encapsulated
private data, and procedures, functions and
entries which are guaranteed to be mutually
exclusive. A task calling a protected object
is blocked if another task is currently executing
inside the same protected object, and released
when this other task leaves the protected
object. Blocked tasks are queued on the protected
object ordered by time of arrival.
Protected object entries are similar to procedures,
but additionally have guards. If a guard evaluates
to false, a calling task is blocked and added
to the queue of that entry; now another task
can be admitted to the protected object, as
no task is currently executing inside the
protected object. Guards are re-evaluated
whenever a task leaves the protected object,
as this is the only time when the evaluation
of guards can have changed.
Calls to entries can be requeued to other
entries with the same signature. A task that
is requeued is blocked and added to the queue
of the target entry; this means that the protected
object is released and allows admission of
another task.
The select statement in Ada can be used to
implement non-blocking entry calls and accepts,
non-deterministic selection of entries, time-outs
and aborts.
The following example illustrates some concepts
of concurrent programming in Ada.
Pragmas
A pragma is a compiler directive that conveys
information to the compiler to allow specific
manipulation of compiled output. Certain pragmas
are built into the language while other are
implementation-specific.
Examples of common usage of compiler pragmas
would be to disable certain features, such
as run-time type checking or array subscript
boundary checking, or to instruct the compiler
to insert object code in lieu of a function
call.
See also
APSE – a specification for a programming
environment to support software development
in Ada
JOVIAL – an earlier U.S Military programming
language
PL/SQL and PL/pgSQL
Ravenscar profile
SPARK – a programming language consisting
of a highly restricted subset of the Ada,
annotated with meta information describing
desired component behavior and individual
runtime requirements
Straw man proposal
VHDL – a hardware description language originally
developed at the behest of the U.S Department
of Defense that borrows heavily from Ada in
both concepts and syntax
Comparison of programming languages
List of programming languages
References
International standards
ISO/IEC 8652: Information technology—Programming
languages—Ada
ISO/IEC 15291: Information technology—Programming
languages—Ada Semantic Interface Specification
ISO/IEC 18009: Information technology—Programming
languages—Ada: Conformity assessment of
a language processor
IEEE Standard 1003.5b-1996, the POSIX Ada
binding
Ada Language Mapping Specification, the CORBA
IDL to Ada mapping
Rationale
(These documents have been published in various
forms including print.)
Jean D. Ichbiah, John G. P. Barnes, Robert
J. Firth and Mike Woodger, Rationale for the
Design of the Ada Programming Language, 1986.
John G. P. Barnes, Ada 95 rationale : the
language : the standard libraries, 1995.
John Barnes, Rationale for Ada 2005, 2005,
2006.
Books
Archives
Ada Programming Language Materials, 1981–1990.
Charles Babbage Institute, University of Minnesota,
Minneapolis.
External links
Ada programming language Ada at DMOZ
ACM SIGAda
Ada-Europe Organization
ISO Home of Ada Standards
Interview with S.Tucker Taft, Maintainer of
Ada
