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.

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.

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 to another.

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 rendezvous point.

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.