Previous     Contents     Next

Glossary

(Note: Some of the terms included here are technical terms which I’ve 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 or altered.

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 objects.

Access value:
A value which refers to (‘points to’) other objects defined elsewhere, commonly referred to as a pointer.

Accessor:
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 generic instantiation.

ADT:
An acronym for abstract data type.

Algorithm:
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.

Argument:
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.

Array:
A collection of objects of the same type which can be selected by an index belonging to the index subtype of the array.

Attribute:
A characteristic of a type which can be used to access various details of the type and its implementation.

Block:
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 handlers.

Body:
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.

Bug:
An error in a program.

Call:
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.

Child:
A package or subprogram which acts as an extension of a parent package, thus allowing packages to be extended without modifying the original specifications.

Class:
A family of derived types with a common parent type.

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.

Client:
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.

Compiler:
A program which translates the source code for a library unit into an object module in a program library.

Component:
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).

Constant:
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 in memory.

Constraint:
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.

Constructor:
A subprogram which constructs a value of a private type from its component parts.

Container:
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.

Coupling:
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.

Crash:
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.

Debugger:
A tool for tracing program execution to help track down bugs.

Debugging:
The process of discovering and correcting bugs in a program.

Declaration:
The definition of a name and its meaning.

Dependents:
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.

Derivation:
The definition of a new type in terms of an existing one.

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.

Discriminant:
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.

Dispatching:
The selection of the correct primitive operation to be executed based on the actual tag of a class-wide value.

Entry:
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.

Exception:
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.

Expression:
Something which can be evaluated to produce a value which can be stored or otherwise processed.

Extensibility:
The ability to add new features to an existing program without disturbing any existing code.

Field:
A synonym for ‘component’.

Finalisation:
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.

Flag:
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 a specification.

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 specifications.

Function:
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.

GNAT:
The GNU Ada Translator, a free Ada 95 compiler available for a range of platforms. See Chapter 20 for more details.

Guard:
A condition used with an accept statement or a protected entry that specifies when it can be invoked.

Heap:
A synonym for what Ada refers to as a storage pool.

Identifier:
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.

Inheritance:
The automatic definition of the characteristics of a type based on the characteristics of its parent type.

Initialisation:
The actions which are performed immediately after an object is created to prepare it for use.

Instantiation:
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.

Iteration:
A synonym for ‘repetition’, as in a loop.

Iterator:
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 the collection.

Library:
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.

Linker:
A program which binds a library subprogram together with any other library units it refers to into an executable program.

Literal:
A representation of a value of a particular type, as with integer literals (e.g. 123) or string literals (e.g. "xyzzy").

Loop:
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.

Maintenance:
The process of fixing bugs in, and adding new features to, existing software.

Model:
A representation of some aspect of external reality in a program.

Multitasking:
The ability to execute several parts of a program in parallel (or apparently in parallel).

Namespace:
The set of names accessible at a given point in a program.

Null pointer:
An access value which does not refer to any object.

Object:
A constant or variable of a specified type.

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 specification.

Overloading:
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.

Overriding:
Providing a declaration which matches another declaration of the same name, thereby hiding the existing declaration.

Package:
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.

Parameter:
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 subprogram returns.

Parent type:
The type from which a derived type was created.

Partial view:
The view of a private type to a client where not all characteristics of the type are visible.

Pointer:
A common synonym for what Ada calls an access value.

Pool-specific access type:
An access type which can only refer to objects allocated by new from a storage pool specific to the object’s type.

Portability:
A measure of system independence; portable programs can be moved to a new system by recompiling without having to make any other changes.

Precedence:
The order in which arithmetic operations are performed.

Prettyprinter:
A tool for automatically formatting Ada source code.

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.

Procedure:
A subprogram which is invoked by a procedure call statement.

Program:
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 point types.

Record:
A composite type consisting of a collection of named components, not necessarily all of the same type.

Recursion:
The definition of an operation in terms of itself.

Rendezvous:
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.

Reusability:
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.

Scope:
The region of a program where a name is visible, extending from its declaration to the end of the block which contains the declaration.

Slice:
A section of an array selected by specifying its lower and upper limits.

Source code:
The original textual form of a program.

Specification:
A description of the interface provided by a subprogram, package, task or protected record. The implementation details are hidden in the corresponding body.

Statement:
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.

String:
A sequence of characters.

Stub:
A temporary implementaion of part of a program for debugging purposes.

Subprogram:
A set of statements which can be executed by calling the subprogram by name.

Subscript:
An index into an array which is used to specify an individual array component.

Subtype:
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.

Syntax:
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.

Task:
A construct consisting of a specification and a body whose body is executed in parallel with other tasks in the program.

Token:
Anything treated as a single symbol during syntax analysis such as a name, a literal or an operator.

Top-down:
An approach which starts from a high (generalised) level and works towards lower (more specific) levels.

Top-down design:
A synonym for stepwise refinement.

Type:
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 the declaration).

Undefined:
Having an unpredicatable (and not necessarily valid) value.

Variable:
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.

View:
An external representation of an internal processing model which is used to interact with the internal model.

Wrapper:
A package which changes the interface to an existing package without substantially increasing its functionality.

 Previous     Contents     Next

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 change.