[[Property:title|Glossary]]
[[Property:link_title|Glossary]]
[[Property:description|Glossary of Object Technology]]
[[Property:weight|4]]
[[Property:uuid|b8c10baa-4f50-adfe-a6f8-9cb56a8f1917]]
This glossary provides brief definitions of the principal terms of object technology, discussed in detail in the book ''[[uuid:496983ef-b86e-772e-16b9-39b37ef80e37|Object-Oriented Software Construction, 2nd Edition]]'' and used in this website. ''Italics font'' in a definition marks a term or phrase, other than the ubiquitous "class", that is itself the subject of another definition.

==Abstract class==
:See ''[[#Deferred class|deferred class]]''.

==Abstract data type (ADT)==
:A set of mathematical elements specified by listing the functions applicable to all these elements and the formal properties of these functions.

==Abstract object==
:An element of an [[#Abstract data type (ADT)|''abstract data type (ADT)'']].

==Ancestor (of a class)==
:The class itself, or one of its direct or indirect ''[[#Parent (of a class)|parents]]''.

==Assertion==
:A formal condition describing the semantic properties of software elements, especially routines and loops. Used in expressing ''[[#Contract|contracts]]''. Assertions include in particular ''[[#Precondition|preconditions]]'', ''[[#Postcondition|postconditions]]'', ''[[#Class invariant|class invariants]]'' and ''[[#Loop invariant|loop invariants]]''.

==Assignment attempt==
:An operation that conditionally attaches an ''[[#Object|object]]'' to a ''[[#Reference|reference]]'', only if the object’s type ''[[#Conformance|conforms]]'' to the type declared for the corresponding ''[[#Entity|entity]]''.

==Asynchronous call==
:A call which lets its caller proceed before it completes. Antonym: ''[[#Synchronous call|synchronous call]]''.

==Attribute==
:The description of a ''[[#Field|field]]'' present in all the ''[[#Instance (of a class)|instances]]'' of a class. Along with the ''[[#Routine|routine]]'', one of the two forms of ''[[#Feature|feature]]''.

==Behavior class==
:A class, usually ''[[#Deferred class|deferred]]'', describing a set of adaptable behaviors through ''[[#Effective feature|effective routines]]'' relying on some components (usually ''[[#Deferred feature|deferred features]]'') that may be ''[[#Redeclaration|redeclared]]'' to capture specific variants of the general behaviors.

==Class==
:A partially or totally implemented ''[[#Abstract data type (ADT)|abstract data type]]''. Serves both as a ''[[#Module|module]]'' and as a ''[[#Type|type]]'' (or type pattern if the class is ''[[#Generic class|generic]]''.)

==Class invariant==
:An ''[[#Assertion|assertion]]'' which must be satisfied on creation of every ''[[#Instance (of a class)|instance]]'' of a class, and preserved by every exported routine of the class, so that it will be satisfied by all instances of the class whenever they are externally observable.

==Client==
:A class that uses the features of another, its ''[[#Supplier|supplier]]'', on the basis of the supplier's interface specification (''[[#Contract|contract]]'').

==Cluster==
:A group of related classes or, recursively, of related clusters.

==Component==
:See ''[[#Reusable software component|reusable software component]]''.

==Concurrent==
:Able to use two or more ''[[#Processor|processors]]''. Antonym: ''[[#Sequential|sequential]]''.

==Conformance==
:A relation between types. A type conforms to another if it is derived from it by ''[[#Inheritance|inheritance]]''.

==Constrained genericity==
:A form of ''[[#Genericity|genericity]]'' where a formal generic parameter represents not an arbitrary type, but one that is required to ''[[#Conformance|conform]]'' to a certain type, known as the constraint. See ''[[#Constrained genericity|constrained genericity]]''.

==Container data structure==
:An ''[[#Object|object]]'' whose primary use is to provide access to a number of other objects. Examples include lists, queues, stacks, arrays.

==Contract==
:The set of precise conditions that govern the relations between a ''[[#Supplier|supplier]]'' class and its ''[[#Client|clients]]''. The contract for a class includes individual contracts for the exported routines of the class, represented by ''[[#Precondition|preconditions]]'' and ''[[#Postcondition|postconditions]]'', and the global class properties, represented by the ''[[#Class invariant|class invariant]]''. See also ''[[#Design by Contract|Design by Contract]]''.

==Contravariance==
:The policy allowing a feature ''[[#Redeclaration|redeclaration]]'' to change the ''[[#Signature (of a feature)|signature]]'' so that a new result type will ''[[#Conformance|conform]]'' to the original but the original argument types conform to the new. See also: ''[[#Covariance|covariance]]'', ''[[#Novariance|novariance]]''.

==Covariance==
:The policy allowing a feature ''[[#Redeclaration|redeclaration]]'' to change the ''[[#Signature (of a feature)|signature]]'' so that the new types of both arguments and result ''[[#Conformance|conform]]'' to the originals. See also: ''[[#Contravariance|contravariance]]'', ''[[#Novariance|novariance]]''.

==Current object (or: current instance)==
:During the execution of an ''[[#Object-oriented|object-oriented]]'' software system, the target of the most recently started routine call.

==Defensive programming==
:A technique of fighting potential errors by making every module check for many possible consistency conditions, even if this causes redundancy of checks performed by ''[[#Client|clients]]'' and ''[[#Supplier|suppliers]]''. Contradicts ''[[#Design by Contract|Design by Contract]]''.

==Deferred class==
:A class which has at least one ''[[#Deferred feature|deferred feature]]''. Antonym: ''[[#Effective class|effective class]]''.

==Deferred feature==
:A feature which, in a certain class, has a specification but no implementation. May be declared as deferred in the class itself, or inherited as deferred and not ''[[#Effect|effected]]'' in the class. Antonym: ''[[#Effective feature|effective feature]]''.

==Descendant (of a class)==
:The class itself, or one of its direct or indirect ''[[#Heir (of a class)|heirs]]''.

==Design by Contract==
:A method of software construction that designs the components of a ''[[#System|system]]'' so that they will cooperate on the basis of precisely defined ''[[#Contract|contracts]]''. See also: ''[[#Defensive programming|defensive programming]]''.

==Direct instance (of a class)==
:An ''[[#Object|object]]'' built according to the mold defined by the class.

==Dynamic==
:Occurring during the execution of a ''[[#System|system]]''. See also ''[[#Run time (noun, two words)|run time]]''. Antonym: ''[[#Static|static]]''.

==Dynamic binding==
:The guarantee that every execution of an operation will select the correct version of the operation, based on the type of the operation's target.

==Dynamic typing==
:The policy whereby applicability of operations to their target ''[[#Object|objects]]'' is only checked at run time, prior to executing each operation.

==Effect==
:A class effects a feature if it inherits it in ''[[#Deferred feature|deferred]]'' form and provides an ''[[#Effecting|effecting]]'' for that feature.

==Effecting==
:A ''[[#Redeclaration|redeclaration]]'' which provides an implementation (as ''[[#Attribute|attribute]]'' or ''[[#Routine|routine]]'') of a feature inherited in ''[[#Deferred feature|deferred]]'' form.

==Effective class==
:A class which only has ''[[#Effective feature|effective features]]'' (that is to say, does not introduce any ''[[#Deferred feature|deferred feature]]'', and, if it inherits any deferred feature, ''[[#Effect|effects]]'' it). Antonym: ''[[#Deferred class|deferred class]]''.

==Effective feature==
:A feature declared with an implementation - either as a routine which is not ''[[#Deferred feature|deferred]]'', or as an ''[[#Attribute|attribute]]''. Antonym: ''[[#Deferred feature|deferred feature]]''.

==Encapsulation==
:See ''[[#Information hiding|information hiding]]''.

==Entity==
:A name in the software text that denotes a run-time value (''[[#Object|object]]'' or ''[[#Reference|reference]]'').

==Event-driven computation==
:A style of software construction where developers define the control structure by listing possible external events and the system's response to each of them, rather than by specifying a pre-ordained sequence of steps.

==Exception==
:The inability of a routine to achieve its ''[[#Contract|contract]]'' through one of its possible strategies. May result in particular from a ''[[#Failure|failure]]'' of a routine called by the original routine. Will be treated as ''[[#Resumption|resumption]]'', ''[[#Organized panic|organized panic]]'' or ''[[#False alarm|false alarm]]''.

==Exporting a feature==
:Making the feature available to ''[[#Client|clients]]''. Exports may be selective (to specified classes only) or general.

==Extendibility==
:The ability of a software system to be changed easily in response to different choices of requirements, architecture, algorithms or data structures.

==Failure==
:The inability of a routine's execution to fulfill the routine's ''[[#Contract|contract]]''. Must trigger an ''[[#Exception|exception]]''.

==False alarm==
:Along with ''[[#Resumption|resumption]]'' and ''[[#Organized panic|organized panic]]'', one of the three possible responses to an ''[[#Exception|exception]]''; resumes the execution of the current strategy, possibly after taking some corrective action.

==Feature==
:The ''[[#Attribute|attributes]]'' and ''[[#Routine|routines]]'' of a class.

==Feature renaming==
:The attribution, by a class, of a new name to an inherited feature, not changing any other property. See also ''[[#Redeclaration|redeclaration]]''.

==Field==
:One of the values making up an ''[[#Object|object]]''.

==Function==
:A ''[[#Routine|routine]]'' which returns a result. (The other form of routine is the ''[[#Procedure|procedure]]''.)

==Garbage collection==
:A facility provided by the ''[[#Runtime (noun, one word)|runtime]]'' to recycle the memory space used by ''[[#Object|objects]]'' that have become useless. Garbage collection is automatic, that is to say does not require any change to the text of the ''[[#System|systems]]'' whose objects are being recycled.

==Generalization==
:The process of turning specialized program elements into general-purpose, ''[[#Reusable software component|reusable software components]]''.

==Generating class==
:Same as ''[[#Generator (of an object)|generator]]''.

==Generator (of an object)==
:The class of which the ''[[#Object|object]]'' is a ''[[#Direct instance (of a class)|direct instance]]''.

==Generic class==
:A class having formal parameters representing types. Such a class will yield a type only through ''[[#Generic derivation|generic derivation]]''.

==Generic derivation==
:The process of providing a type for each formal generic parameter of a ''[[#Generic class|generic class]]'', yielding a type as a result.

==Genericity==
:The support, by a software notation, for type-parameterized ''[[#Module|modules]]'; specifically, in an O-O notation, for ''[[#Generic class|generic classes]]''. Can be ''[[#Unconstrained genericity|unconstrained]]'' or ''[[#Constrained genericity|constrained]]''.

==Heir (of a class)==
:A class that inherits from the given class. Antonym: ''[[#Parent (of a class)|parent]]''.

==Identity==
:See ''[[#Object identity|object identity]]''.

==Information hiding==
:The ability to prevent certain aspects of a class from being accessible to its ''[[#Client|clients]]'', through an explicit ''[[#Exporting a feature|exporting]]'' policy and through reliance on the ''[[#Short form (of a class)|short form]]'' as the primary vehicle for class documentation.

==Inheritance==
:A mechanism whereby a class is defined in reference to others, adding all their features to its own.

==Instance (of a class)==
:An ''[[#Object|object]]'' built according to the mold defined by the class or any one of its proper ''[[#Descendant (of a class)|descendants]]''. See also ''[[#Direct instance (of a class)|direct instance]]'', ''[[#Proper descendant (of a class)|proper descendant]]'', ''[[#Generator (of an object)|generator]]''.

==Instance variable==
:Smalltalk term for ''[[#Attribute|attribute]]''.

==Interface (of a class)==
:See ''[[#Contract|contract]]'', ''[[#Abstract data type (ADT)|abstract data type]]''.

==Invariant==
:See ''[[#Class invariant|class invariant]]'', ''[[#Loop invariant|loop invariant]]''.

==Iterator==
:A control structure describing preordained sequencing of some actions but not defining the actions themselves. Iterators often apply to data structures, such as an iterator describing the traversal of a list or a tree.

==Loop invariant==
:An ''[[#Assertion|assertion]]'' which must be satisfied prior to the first execution of a loop, and preserved by every iteration, so that it will hold on loop termination.

==Loop variant==
:An integer expression which must be non-negative prior to the first execution of a loop, and decreased by every iteration, so that it will garantee loop termination.

==Message==
:Routine call.

==Metaclass==
:A class whose instances are classes themselves.

==Method==
:Smalltalk term for ''[[#Routine|routine]]''.

==Module==
:A unit of software decomposition. In the ''[[#Object-oriented|object-oriented]]'' approach, classes provide the basic form of module.

==Multiple inheritance==
:The unrestricted form of ''[[#Inheritance|inheritance]]'', whereby a class may have any number of [[#Parent (of a class)|parents]]. Antonym: ''[[#Single inheritance|single inheritance]]''.

==Non-separate==
:Antonym of ''[[#Separate|separate]]''.

==Novariance==
:The policy prohibiting any feature ''[[#Redeclaration|redeclaration]]'' from changing the ''[[#Signature (of a feature)|signature]]''. See also: ''[[#Contravariance|contravariance]]'', ''[[#Covariance|covariance]]''.

==Object==
:A run-time data structure made of zero or more values, called ''[[#Field|fields]]'', and serving as the computer representation of an ''[[#Abstract object|abstract object]]''. Every object is an ''[[#Instance (of a class)|instance]]'' of some class.

==Object identity==
:A property that uniquely identifies an ''[[#Object|object]]'' independently of its current contents (''[[#Field|fields]]'').

==Object-oriented==
:Built from ''[[#Class|classes]]'', ''[[#Assertion|assertions]]'', ''[[#Genericity|genericity]]'', ''[[#Inheritance|inheritance]]'', ''[[#Polymorphism|polymorphism]]'' and ''[[#Dynamic binding|dynamic binding]]''.

==Object-oriented analysis==
:The application of ''[[#Object-oriented|object-oriented]]'' concepts to the modeling of problems and systems from both software and non-software domains.

==Object-oriented database==
:A repository of ''[[#Persistent object|persistent objects]]'', permitting their storage and retrieval on the basis of ''[[#Object-oriented|object-oriented]]'' concepts, and supporting database properties such as ''[[#Concurrent|concurrent]]'' access, locking and transactions.

==Object-oriented design==
:The process of building the architecture of ''[[#System|systems]]'' through ''[[#Object-oriented|object-oriented]]'' concepts.

==Object-oriented implementation==
:The process of building executable software systems through ''[[#Object-oriented|object-oriented]]'' concepts. Differs from ''[[#Object-oriented design|object-oriented design]]'' primarily by the level of abstraction.

==Organized panic==
:Along with ''[[#Resumption|resumption]]'' and ''[[#False alarm|false alarm]]'', one of the three possible responses to an ''[[#Exception|exception]]''; abandons the execution of the current strategy, triggering an exception in the caller, after restoring the ''[[#Class invariant|class invariant]]'' for the ''[[#Current object (or: current instance)|current object]]''.

==Overloading==
:The ability to let a feature name denote two or more operations.

==Package==
:A ''[[#Module|module]]'' of non-object-oriented languages such as Ada, providing encapsulation of a set of variables and ''[[#Routine|routines]]''.

==Parallel==
:See ''[[#Concurrent|concurrent]]''.

==Parameterized class==
:See ''[[#Generic class|generic class]]''.

==Parent (of a class)==
:A class from which the given class inherits. Antonym: ''[[#Heir (of a class)|heir]]''.

==Persistence==
:The ability of a software development environment or language to make objects ''[[#Persistent object|persistent]]'' and support the retrieval of ''[[#Persistent object|persistent objects]]'' for use by systems.

==Persistent object==
:An object that (through storage in a file or database or transmission across a network) survives executions of systems that create or manipulate it. Antonym: ''[[#Transient object|transient object]]''.

==Polymorphic data structure==
:A ''[[#Container data structure|container data structure]]'' hosting ''[[#Object|objects]]'' of two or more possible types.

==Polymorphism==
:The ability for an element of the software text to denote, at run time, ''[[#Object|objects]]'' of two or more possible types.

==Postcondition==
:An ''[[#Assertion|assertion]]'' attached to a ''[[#Routine|routine]]'', which must be guaranteed by the routine's body on return from any call to the routine if the ''[[#Precondition|precondition]]'' was satisfied on entry. Part of the ''[[#Contract|contract]]'' governing the routine.

==Precondition==
:An ''[[#Assertion|assertion]]'' attached to a ''[[#Routine|routine]]'', which must be guaranteed by every ''[[#Client|client]]'' prior to any call to the routine. Part of the ''[[#Contract|contract]]'' governing the routine.

==Predicate==
:See ''[[#Assertion|assertion]]''.

==Procedure==
:A ''[[#Routine|routine]]'' which does not return a result. (The other form of routine is the ''[[#Function|function]]''.)

==Processor==
:A mechanism providing a single thread of computation. May be a physical device, such as the CPU of a computer, or a software device, such as a task or thread of an operating system.

==Program==
:See ''[[#System|system]]''.

==Proper ancestor (of a class)==
:A direct or indirect ''[[#Parent (of a class)|parent]]'' of the class.

==Proper descendant (of a class)==
:A direct or indirect ''[[#Heir (of a class)|heir]]'' of the class.

==Redeclaration==
:A feature declaration which, instead of introducing a new feature, adapts some properties (such as the ''[[#Signature (of a feature)|signature]]'', ''[[#Precondition|precondition]]'', ''[[#Postcondition|postcondition]]'', implementation, ''[[#Deferred feature|deferred]]''/''[[#Effective feature|effective]]'' status, but not the name) of a feature inherited from a ''[[#Parent (of a class)|parent]]''. A redeclaration may be a ''[[#Redefinition|redefinition]]'' or an ''[[#Effecting|effecting]]''. See also ''[[#Feature renaming|feature renaming]]''.

==Redefinition==
:A ''[[#Redeclaration|redeclaration]]'' which is not an ''[[#Effecting|effecting]]'', that is to say, changes some properties of a feature inherited as ''[[#Effective feature|effective]]'', or changes the specification of a feature inherited as ''[[#Deferred feature|deferred]]'' while leaving it deferred.

==Reference==
:A run-time value that uniquely identifies an ''[[#Object|object]]''.

==Renaming==
:See ''[[#Feature renaming|feature renaming]]''.

==Representation==
:The physical layout of data in RAM (or other storage), and the choices of what data is stored and what data is computed at run time, in order to represent the ''[[#Abstract data type (ADT)|abstract data type]]'' in question.

==Representation Independence==
:The ability of a class to present an unchanging interface to its ''[[#Client|clients]]'', and implement alternate ''[[#Representation|representations]]'' of the underlying object without the clients needing to know or care about it.  In the ''[[#Object-oriented|object-oriented]]'' method, ''[[#Dynamic binding|dynamic binding]]'' and ''[[#Polymorphism|polymorphism]]'' are major contributors to making this possible.

==Resumption==
:See ''[[#Retrying|retrying]]''.

==Retrying==
:Along with ''[[#Organized panic|organized panic]]'' and ''[[#False alarm|false alarm]]'', one of the three possible responses to an ''[[#Exception|exception]]''; tries a new strategy for achieving the routine's ''[[#Contract|contract]]''.

==Reusability==
:The ability of a software development method to yield software elements that can be used in many different applications, and to support a software development process relying on pre-existing ''[[#Reusable software component|reusable software components]]''.

==Reusable software component==
:An element of software that can be used by many different applications.

==Reversible development==
:A software development process that lets insights gained in later phases affect the results obtained in earlier phases. Normally part of a ''[[#Seamless development|seamless development]]'' process.

==Root class==
:The ''[[#Generator (of an object)|generator]]'' of a system's ''[[#Root object|root object]]''. Executing the system means creating an ''[[#Instance (of a class)|instance]]'' of the root class (the root object), and calling a creation procedure on that instance.

==Root object==
:The first ''[[#Object|object]]'' created in the execution of a system.

==Routine==
:A computation defined in a class, and applicable to the ''[[#Instance (of a class)|instances]]'' of that class. Along with the ''[[#Attribute|attribute]]'', one of the two forms of ''[[#Feature|feature]]''.

==Runtime (noun, one word)==
:Any set of facilities supporting the execution of systems. See ''[[#Run time (noun, two words)|run time]]''.

==Run time (noun, two words)==
:The time when a ''[[#System|system]]'' is being executed. Also used as an adjective, with a hyphen, as in "the run-time value of an ''[[#Entity|entity]]''". See also ''[[#Dynamic|dynamic]]'' and ''[[#Runtime (noun, one word)|runtime]]''.

==Schema evolution==
:Change to one or more classes of which some ''[[#Persistent object|persistent]]'' instances exist.

==Seamless development==
:A software development process which uses a uniform method and notation throughout all activities, such as problem modeling and analysis, design, implementation and maintenance. See also ''[[#Reversible development|reversible development]]''.

==Selective export==
:See ''[[#Exporting a feature|exporting a feature]]''.

==Separate==
:Handled by a different ''[[#Processor|processor]]''. Antonym: non-separate.

==Sequential==
:Running on only one ''[[#Processor|processor]]''. Antonym: ''[[#Concurrent|concurrent]]''.

==Short form (of a class)==
:A form of class documentation generated from the class text, showing only interface properties of the class. The short form documents the ''[[#Contract|contract]]'' attached to the class and the underlying ''[[#Abstract data type (ADT)|abstract data type]]''.

==Signature (of a feature)==
:The type part of the feature's specification. For an ''[[#Attribute|attribute]]'' or a ''[[#Function|function]]'', includes the result type; for a ''[[#Routine|routine]]'', includes the number of arguments and the type of each.

==Single inheritance==
:A restricted form of ''[[#Inheritance|inheritance]]'' whereby each class may have at most one ''[[#Parent (of a class)|parent]]''. Antonym: ''[[#Multiple inheritance|multiple inheritance]]''.

==Software component==
:See ''[[#Reusable software component|reusable software component]]''.

==Specification (of a class)==
:The ''[[#Short form (of a class)|short form]]'' of the class.

==Specification (of a feature)==
:The properties of a feature that are relevant to a ''[[#Client|client]]''. Includes the name, ''[[#Signature (of a feature)|signature]]'', header comment and ''[[#Contract|contract]]'' of the feature.

==Subcontract==
:The ability of a class to let some proper ''[[#Descendant (of a class)|descendant]]'' handle some of its feature calls, thanks to ''[[#Redeclaration|redeclaration]]'' and ''[[#Dynamic binding|dynamic binding]]''.

==Supplier==
:A class that provides another, its ''[[#Client|client]]'', with features to be used through an interface specification (''[[#Contract|contract]]'').

==Static==
:Applying to the text of a ''[[#System|system]]'', not to a particular execution. Antonym: ''[[#Dynamic|dynamic]]''.

==Static binding==
:The premature choice of operation variant, resulting in possibly wrong results and (in favorable cases) run-time system crash.

==Static typing==
:The ability to check, on the basis of the software text alone, that no execution of a system will ever try to apply to an ''[[#Object|object]]'' an operation that is not applicable to that object.

==Synchronous call==
:A call which forces the caller to wait until it completes. Antonym: ''[[#Asynchronous call|asynchronous call]]''.

==System==
:A set of classes that can be assembled to produce an executable result.

==Template==
:C++ term for ''[[#Generic class|generic class]]'' (for ''[[#Unconstrained genericity|unconstrained genericity]]'' only).

==Traitor==
:A ''[[#Reference|reference]]'' to a ''[[#Separate|separate]]'' ''[[#Object|object]]'', associated in the software text with an ''[[#Entity|entity]]'' that is declared as non-separate.

==Transient object==
:An ''[[#Object|object]]'' that exists only during the execution of the system that creates it. Antonym: ''[[#Persistent object|persistent object]]''.

==Type==
:The description of a set of objects equipped with certain operations. In the ''[[#Object-oriented|object-oriented]]'' approach every type is based on a class.

==Type checking, typing==
:See ''[[#Static typing|static typing]]'', ''[[#Dynamic typing|dynamic typing]]''.

==Unconstrained genericity==
:A form of ''[[#Genericity|genericity]]'' where a formal generic parameter represents an arbitrary type. See ''[[#Constrained genericity|constrained genericity]]''.

==Variant==
:See ''[[#Loop variant|loop variant]]''.