Ada is a modern general-purpose language aimed at the broad area of
systems programming, embedded and real-time systems, and general
applications--with a number of features to support concurrent and
distributed programming. It is named in honor of Augusta Ada Byron,
Countess of Lovelace, who by virtue of her early 19th century work with
Charles Babbage is considered to be the first computer programmer. With
its revision, Ada 95 is the first internationally standardized fully
object-oriented programming (OOP) language.
Abstract data type
A data type is completely characterized by the set of operations that
can be applied to its values; thus the internal structure of these
values can be hidden and even inaccessible to users of the type. Any
imaginable data type can be defined by choosing a representation for its
values and writing a subprogram for each operation. This collection of
subprograms is an abstract data type. A language that is designed to
support user-defined abstract data types has a mechanism for bundling
all the subprograms that implement the operations into a single unit; in
Ada, this is a package.
An attribute referring to the potential unpredictability of the order in
which events occur. Two tasks executing in parallel are asynchronous
with respect to each other if their execution speeds are mutually
independent and thus it is not possible to predict which will be the
first to arrive at a given place in the program.
A sequence of statements within a program that externally is treated as
a single statement. Within a bloc new objects (variables, procedure,
types) may be defined. The names of these objects are unknown outside
the block. Blocks may be nested; that is, one block may be completely
contained in another block. In this case, an inner block may redefine a
name that was defined in an outer block, thus preventing access to the
outer object throughout the inner block.
An attribute of a collection of activities that are in progress
simultaneously; that is, more than one task may be observed between its
initiation and termination.
Choosing which operation to perform at run-time, based on some
characteristics of the operands. In Ada, dispatching occurs when a
primitive operation of a tagged type has passed an operand that is of a
class-wide type; the “type-tag” identifies at run-time the specific type
whose primitive subprogram will be called.
The coordinated and collective action of multiple programs, perhaps
running on multiple computers, to solve a single problem. In Ada,
pragmas may be used to identify where a single conceptual program may be
divided into separate executable “partitions.” The actual partitioning,
if any, is performed at link-time. The Ada implementation, rather than
the user, takes responsibility for consistency and strong type checking
between communicating partitions.
The run-time actions (such as initialization) associated with a type or
object declaration. In Ada, certain declarations require actions at
run-time, such as initializing a pointer to null, or allocating space
for an array whose size is not known until run-time.
Embedded computer system
A system in which the computer is an integral part of a larger system
whose purpose is not primarily computation.
Building a secure wall around a set of entities so that access from
outside is limited to only those entities that have been explicitly
designated as accessible. In Ada, a package is used for encapsulation.
An unlikely, but not completely unanticipated, failure in some part of a
program. The immediate reaction to this is called raising an exception.
Taking action appropriate to a raised exception is called handling the
exception. The code that is executed to handle the exception is called
an exception handler.
A generic entity is a parameterized template from which the compiler may
create similar entities. A generic entity itself is not part of any
program; only instantiations of it can be included in an executing
program. Instantiation is done by the compiler. Each instantiation is
explicitly invoked in the program; values for the generic parameters are
supplied as part of the invocation.
Programming so that certain information and the subprograms necessary for accessing it are not directly accessible from outside the encapsulating package used to hide it. All access
is indirect through the subprograms in the package.
Allowing of one type to be defined in terms of another, with the new
type “inheriting” various characteristics and operations of the original
type, and then overriding or extending the inherited characteristics and
operations necessary to tailor the new type to some new purpose. In
Ada, inheritance occurs when a “derived” type is defined.
A collection of modules that can be combined to build one or more
programs. In Ada, library units are the modules that make up the
library, and “with” clause is used to create references from one library
Allowing concurrent execution of more
than one task or thread of control.
One unit is nested in another unit if it is completely contained within
that unit, which itself may be nested in a third unit, and so on.
Applied to subprogram names and operator symbols, which are
treated as names of functions; a name is overloaded when it has more
than one meaning, the correct meaning being determined by context.
When a single algorithm is applicable to multiple types.
Compile time polymorphism is provided in Ada via generic units.
Instantiation as compile-time is used to specialize a generic unit to a
particular type. Ada 95 also supports run-time polymorphism -- where a
run-time type tag can be used to control which subprogram body is
executed when a polymorphic algorithm calls a primitive operation with
an operand of class-wide type.
A combination of private components plus “protected operations,” which
have exclusive access to the components. A protected type is specified
by a program unit that defines the components and the protected
operations -- read-only functions, read/write procedures or potentially
suspending entries (similar to task entries).
Where the correctness of a system's behavior depends
not only on what happens in what order, but also on exactly when it
happens. Ada has features that provide real-time support by allowing
the programmer to control when an action will occur, to connect an
action to a time-based trigger, and to schedule multiple tasks using
strict priority-based FIFO scheduling to ensure that critical real-time
deadlines are met.
A mechanism used to synchronize two tasks. It is more elaborate
than the traditional semaphore mechanism. Each rendezvous is associated
with a particular task entry, whose name must be visible to both tasks.
Two tasks achieve a rendezvous when one task executes a call to entry in
the other task, and the called task executes and accept statement that
names the same entry. Each distinct call-accept pair defines a
A special type of variable used to synchronize tasks, all of which share
the semaphore. In the simplest case, when a task reaches its
synchronization point, it checks the semaphore. If the semaphore is on,
the task must wait until it is off. When the semaphore is off, the task
turns it on and continues to execute.
An attribute of a language in which objects of a given type may take on
only those values that are appropriate to the type, and the only
operations that may be applied to an object are those that are defined
for its type. In some languages, like Ada, the type of every object can
be determined at compile time, and many type mismatches will be detected
by the compiler. However, Ada allows a subtype whose values are a
limited subset of the set of values for the parent type. In this case,
some type mismatches cannot be detected until the program executes.
A program unit that is capable of executing concurrently with
other tasks. In some systems this type of units is called a process
instead of a task.
For the definitions of additional Ada terms, see
the glossary in
the Ada 95 Language Reference Manual.