(Note: Some of the terms included here are technical terms
which Ive defined loosely and informally. Such definitions are for
your guidance only, and are not necessarily complete or entirely accurate.)
- Abstract operation:
- An operation for which no implementation
can be provided. Only abstract types can have abstract operations. Derived
concrete types must override any inherited abstract operations.
- Abstract data type:
- A type whose implementation details
are hidden and can only be handled using the publicly accessible operations
provided for it. Not to be confused with abstract type.
- Abstract type:
- A type declared using the reserved word abstract.
Only abstract types can have abstract operations. You cannot declare
objects belonging to an abstract type; the purpose of an abstract type
is to act as the parent for a class of derived types.
- Access discriminant:
- A discriminant whose type is an anonymous
general access type. Access discriminants can only be given for limited
types; the values supplied for them cannot be null and they cannot be copied
- Access parameter:
- A form of input parameter which
is an anonymous general access type. Access parameters cannot be
null and they cannot be copied or altered.
- Access type:
- A type whose values are access values.
Pool-specific access types can only refer to objects created using
new, while general access types can also refer to aliased
- Access value:
- A value which refers to (points to)
other objects defined elsewhere, commonly referred to as a pointer.
- A function which accesses an internal component
of a private type.
- Actual parameter:
- The parameter value supplied in
a subprogram call (often referred to as an argument) or a
- An acronym for abstract data type.
- A method for solving a particular problem which
is guaranteed to terminate in a finite time.
- Aliased object:
- An object declared using the reserved word
aliased which can be accessed by a general access value, so that
the same object might be referred to by more than one alias.
- Anonymous type:
- A type whose name is not known so that objects
of that type cannot be declared explicitly.
- Often used as a synonym for parameter. Technically
speaking, arguments are the actual parameters supplied when
calling a subprogram (or instantiating a generic unit) to match the formal
parameters given in its specification.
- A collection of objects of the same type which can
be selected by an index belonging to the index subtype of the array.
- A characteristic of a type which can be used to
access various details of the type and its implementation.
- A section of a program incorporating an optional set
of declarations valid within the block, a set of statements
defining the processing to be carried out, and an optional set of exception
- The portion of a package, subprogram, task or protected
record which contains the statements which define its implementation.
- Bottom Up:
- The opposite of top down; an approach which
builds simple low-level objects into more complex higher-level objects.
- An error in a program.
- The invocation of a subprogram which causes in
parameters to be transferred into the subprogram, followed by execution
of the subprogram body and the transfer of out parameters back to
the surrounding environment.
- A package or subprogram which acts as
an extension of a parent package, thus allowing packages to be extended
without modifying the original specifications.
- A family of derived types with a common parent
- Class-wide type:
- A type which can refer to an object of any
type within a class. Class-wide types are created by applying the
'Class attribute to a tagged type.
- A program unit which makes use of the services provided
by a particular package.
- Compilation unit:
- A portion of a program which can be submitted
to the compiler independently; a package specification or body,
a subprogram body or a generic instantiation.
- A program which translates the source code
for a library unit into an object module in a program
- An element of a composite type.
- Composite type:
- An array or record type which
represents a collection of smaller components.
- Concrete type:
- A non-abstract type (see abstract type).
- An object whose value cannot be changed.
- Constrained type:
- A type whose constraints have all
been specified so that the compiler knows exactly how it should be represented
- A discriminant for a record or a range
for a subtype or array index subtype which usually determines the amount
of memory the compiler must allocate for objects of the type.
- A subprogram which constructs a value of a private
type from its component parts.
- A type which contains a number of simpler elements.
Array types are provided as a built-in container type in Ada.
- Context clause:
- A with or use clause at the
start of a compilation unit which specifies the context within which
a program unit should be compiled (i.e. which names should be recognised
as being valid).
- Controlled type:
- A type which provides for user-defined initialisation
and finalisation procedures.
- Controlling operand:
- A parameter of a primitive operation
of a tagged type (or a result in the case of a function) which belongs
to that tagged type.
- A linkage between two parts of a program such that
if one part of the program is modified, the behaviour of the other part
may also be affected. This can lead to maintenance problems.
- What happens when something goes wrong and your program
(or worse, its operating environment) ceases to function.
- Dangling pointer:
- A pointer (access value)
which points to an object that no longer exists.
- A tool for tracing program execution to help track
- The process of discovering and correcting bugs
in a program.
- The definition of a name and its meaning.
- For a particular unit of a program, all those
parts of the program which depend on it (e.g. via a with clause)
and which will need recompiling as a result of any changes.
- The definition of a new type in terms of an existing
- Derived type:
- A type created from an existing parent
type which inherits the primitive operations of its parent. Objects
of a derived type can always be converted to a parent type and vice versa.
- Discrete type:
- An integer or enumeration type.
- A parameter to a record type
whose value may be used in array index constraints for record components,
as an initial value for components, or to select between record variants.
- The selection of the correct primitive operation
to be executed based on the actual tag of a class-wide value.
- The means by which one task can request a service
from another task or from a protected record.
- Enumeration type:
- A type whose possible values are enumerated
(i.e. listed) as part of its declaration.
- An error indication which can be raised
when an error is detected and which can be handled by an exception
handler elsewhere in the program.
- Exception handler:
- A section of code at the end of a block
which defines the recovery actions to be performed in response to exceptions
raised within that block.
- Executable program:
- A subprogram which has been compiled
into the program library and then linked with any other library
units it depends on.
- Something which can be evaluated to produce a
value which can be stored or otherwise processed.
- The ability to add new features to an existing
program without disturbing any existing code.
- A synonym for component.
- The actions which take place immediately before
an object is destroyed.
- Fixed point:
- A variety of real number whose value
is accurate to within a given magnitude.
- A Boolean value which can be set to True
or reset to False.
- Floating point:
- A variety of real number which is
represented to a specified number of significant figures regardless of
how big or small it is.
- Formal parameter:
- The definition of a parameter in
- Full view:
- The unrestricted view of a private type
available from the package body where the type is declared, or from the
body of a child package or from the private parts of any of the associated
- A subprogram which returns a value of a
specified type which is invoked as part of an expression.
- Garbage collection:
- The automatic reclamation of dynamically
allocated objects that are no longer accessible. Garbage collection is
not usually provided in Ada.
- General access type:
- A type which can refer to aliased
objects as well as objects created using new.
- Generic unit:
- A unit defined in terms of generalised types
or subprograms and which can be instantiated to use any compatible
types or subprograms in their place.
- Global object:
- An object declared outside the current
block (especially one declared at library level) so that
the current block is not the only place where it can be referenced.
- The GNU Ada Translator, a free Ada 95 compiler available for a range of platforms.
See Chapter 20 for more details.
- A condition used with an accept statement or
a protected entry that specifies when it can be invoked.
- A synonym for what Ada refers to as a storage pool.
- A name given to a program entity that can be
used to refer to it. Identifiers must begin with a letter and must consist
entirely of letters, digits and underline characters. The last character
must not be an underline character.
- Indefinite type:
- A type with unknown discriminants; a class-wide
type or a type whose discriminants are specified as (<>).
- Index subtype:
- A subtype specifying the range of possible
subscripts for an array.
- The automatic definition of the characteristics
of a type based on the characteristics of its parent type.
- The actions which are performed immediately
after an object is created to prepare it for use.
- The act of creating an instance
of a generic unit by replacing its formal parameters by a set of
matching actual parameters.
- Integer type:
- A type capable of holding any whole number
from a specified range of values. In Ada these can be signed integer types
or modular types.
- A synonym for repetition, as in a
- A data type used to mark a position in a collection
of data (e.g. a linked list) and to move from item to item within
- A repository managed by the compiler which
is used to hold information about units which have been compiled.
- Library level:
- The outermost level of scope in a program.
Only the names of library units and names declared in a library-level
package are at library level.
- Library unit:
- A subprogram or package compiled
as a stand-alone unit (i.e. not embedded within any other unit) and added
to the program library.
- Limited type:
- A type which cannot be copied by assignment
and for which the standard equality tests are not provided (although you
can overload "=" and "/=" to provide these yourself).
- Linked list:
- A data collection where each item in the collection
points to its neighbours using access values.
- A program which binds a library subprogram together
with any other library units it refers to into an executable
- A representation of a value of a particular type,
as with integer literals (e.g. 123) or string literals (e.g. "xyzzy").
- A section of code which is repeated (iterated).
- Magic number:
- A number appearing in a program whose appearance
tells you nothing about its intended purpose or meaning.
- The process of fixing bugs in, and adding
new features to, existing software.
- A representation of some aspect of external reality
in a program.
- The ability to execute several parts of a program
in parallel (or apparently in parallel).
- The set of names accessible at a given point in
- Null pointer:
- An access value which does not refer
to any object.
- A constant or variable of a specified
- Opaque type:
- A private type whose implementation details
are made completely invisible by moving them into the package body and
using an access value for an incompletely declared type in the package
- Giving multiple meanings to the same name, but
making them distinguishable by context. For example, two procedures with
the same name are overloading that name as long as the compiler can determine
which one you mean from contextual information such as the type and number
of parameters that you supply when you call it.
- Providing a declaration which matches
another declaration of the same name, thereby hiding the existing declaration.
- A collection of logically related declarations
(both public and private); typically, the declaration of a type
together with the operations of that type. Implementation details are concealed
within the corresponding package body.
- A value or object which is used to transfer information
to or from subprograms. Input parameters can be thought of as being
copied into the subprogram when it is called, and output parameters can
be thought of as having their values copied back to the caller when the
- Parent type:
- The type from which a derived type was
- Partial view:
- The view of a private type to a client
where not all characteristics of the type are visible.
- A common synonym for what Ada calls an access
- Pool-specific access type:
- An access type which can
only refer to objects allocated by new from a storage pool
specific to the objects type.
- A measure of system independence; portable programs
can be moved to a new system by recompiling without having to make any
- The order in which arithmetic operations are
- A tool for automatically formatting Ada source
- Primitive operation:
- An operation of a type which is inherited
by all types derived from it. The primitive operations of a type are those
operations with a controlling operand or result of that type declared in
the same package specification as the type itself.
- Private type:
- A type whose internal implementation is inaccessible
outside the package where it is declared.
- A subprogram which is invoked by a procedure
- A subprogram (usually a parameterless procedure)
which has been linked to produce an executable file.
- Protected record:
- A data structure which provides synchronised
access to the data it contains for use in multitasking situations.
- Real type:
- A type representing numeric values which include
a fractional part. In Ada these can be floating point or fixed
- A composite type consisting of a collection of named
components, not necessarily all of the same type.
- The definition of an operation in terms of itself.
- A form of intertask communication and synchronisation,
where one task calls an entry of another task and the called task
executes an accept statement for the entry being called.
- The ability of a package or subprogram to be
used again without modification as a building block in a different program
from the one it was originally written for.
- Scalar type:
- A type representing single values which cannot
be broken down into smaller components, namely a discrete type or
a real type.
- The region of a program where a name is visible, extending
from its declaration to the end of the block which contains the declaration.
- A section of an array selected by specifying
its lower and upper limits.
- Source code:
- The original textual form of a program.
- A description of the interface provided by
a subprogram, package, task or protected record. The implementation details
are hidden in the corresponding body.
- An instruction to carry out some action; a single
step within a program.
- Stepwise refinement:
- The development of a program by breaking
the original problem into smaller subproblems and then applying the same
process to each subproblem.
- Storage pool:
- A block of unused memory, often referred to
as a heap, which can be used to allocate objects dynamically using
new for use with access types.
- A sequence of characters.
- A temporary implementaion of part of a program for
- A set of statements which can be executed by
calling the subprogram by name.
- An index into an array which is used to
specify an individual array component.
- A type together with a constraint
which possibly restricts the allowed range of values. Strictly speaking,
all types in Ada are actually subtypes of anonymous unconstrained types.
- The rules of a language which determine what is and
is not acceptable to the compiler.
- Syntax analysis:
- The process of checking that something conforms
to the rules of a given syntax and analysing its structure according
to those rules.
- Tagged type:
- A type which can be extended by derivation
to add new components or operations.
- A construct consisting of a specification and
a body whose body is executed in parallel with other tasks in the
- Anything treated as a single symbol during syntax
analysis such as a name, a literal or an operator.
- An approach which starts from a high (generalised)
level and works towards lower (more specific) levels.
- Top-down design:
- A synonym for stepwise refinement.
- Every object has a type which specifies the
set of values allowed and the primitive operations which it provides.
Types are grouped into classes which share the same primitive operations.
- Unconstrained type:
- A type which is not fully specified,
e.g. an array whose index subtype is incompletely specified or a
type with discriminants whose values are not known. You cannot declare
objects of an unconstrained type without supplying the missing constraints
(although you can supply them by providing an initial value as part of
- Having an unpredicatable (and not necessarily
- An object of a specified type whose value
can be changed.
- Variant record:
- A record which can take different forms depending
on the value of a discriminant.
- An external representation of an internal processing
model which is used to interact with the internal model.
- A package which changes the interface to
an existing package without substantially increasing its functionality.
This file is part of Ada 95: The Craft
of Object-Oriented Programming by John English.
Copyright © John
English 2000. All rights reserved.
Permission is given to redistribute this work for non-profit educational
use only, provided that all the constituent files are distributed without
$Revision: 1.2 $
$Date: 2001/11/17 12:00:00 $