Definitions
Having a common glossary of terms is important for accurate, precise, and concise communication among team members. The following definitions are ChiMus distilling and reconciliation of the many great concepts and work that have been contributed to OO. Many of the sources for these terms are mentioned in the References section of this document. A few particularly notable sources are:
- The Dictionary of Object Technology [Firesmith+E 95].
- UML: The Unified Modeling Language [Rational 98]
- Design Patterns, especially [Gamma+HJV 96]
Categorized
The following sections categorize definitions by starting with the core OO concepts (Objects) and growing to more domain-specific definitions.
Object
The core concept to OO is Objects. Everything else in OO is to make understanding, managing, or implementing Objects easier. The definition of Object is the foundation for all other definitions.
Definitions
|
Object
|
An identifiable, encapsulated entity that can only be interacted with by sending messages. |
|
Message
|
A stimulus sent to an object with a name and any parameters (as Objects) that the message requires. A message will cause the receiver Object to return an answer or nothing. In most Object Languages, the sender has to wait for the answer before continuing. |
|
|
|
Identity
|
The ability to tell one object from another object independently of whether their appearance (behavior) is identical. |
|
Behavior
|
The response of an object to a stimulus. An objects behavior is the answers it gives to messages both now and in the future. (See State). |
|
State
|
An abstraction to describe and simplify understanding an objects behavior. An objects behavior can be described as the answers it gives to current messages (which are determined by the current state) and the changes to its state caused by these messages. | More Information
The best source for the concept of Object is Alan Kays writings [Kay 95] and Smalltalk itself [Goldberg+R 83, Squeak]. You could also look at Simula (the progenitor of Smalltalk), but it has other concepts mixed into the language besides Objects. Some methodologies focus on Objects more than others [Wirfs-Brock+WW 90, Wilkinson 95], but all of the main OO methodology books (e.g. [Booch 95, Rumbaugh+BPEL 91, Jacobson+CJO 92]) have objects at the core.
Type
Types allow you to think about the commonality of objects exteriors. They are the first conceptual abstraction above Objects and immediately provide an enormous amount of ability to reasoning about Objects. The amount of abstraction and formality associated with Types can depend on of the project or the current perspective.
Definitions
|
Type
|
Describes a common exterior (public behavior) of a set of Objects. Can also be used to conceptually group and understand objects by their similar behavior. |
|
Operation
|
A description of the ability for an object to respond to a particular message and the contract/requirement for that message. |
|
Interface
|
A description of a Type focused on the Operations that the objects can respond to. |
|
Is-A
|
An object is a Type if an Object supports all the exterior requirements of that Type. |
|
|
|
Extend
|
To define a new Type (called a Subtype) in terms of an existing type (called a Supertype). The new Subtype will have the same contract (operations) as the Supertype but can add new functionality: as either new operations or enhancement in capability to existing operations. |
|
Subtype
|
A Type that extends another Type (called the Supertype). |
|
Supertype
|
A Type that has been extended by another Type. |
More Information
Many methodologies and authors do not make a clear distinction between Type and Class (usually referring to both a "Class" and the context determines what was really meant), so this can cause confusion. The following discuss Types independently of Classes [Kilov+R 94, Fowler 97, Jacobson+CJO 92, Cook+D 94], but all of the main methodology books do focus on Types during analysis [Booch 94, Fowler 97, Rumbaugh+BPEL 91]. The description of contracts and interfaces in [Meyer 97] is the standard and an excellent reference on formal Types and their integration into OOP (but you have to be willing to accept many differences in terminology). Java supports the separation of Type from Class through interfaces and classes, see [Coad+M 96, Gosling+JS 96].
Class
Classes provide a common implementation for similar objects. They describe the interior of objects so it is easier to work with many objects of many different Types. It is important to conceptually separate Classes from Types even though it is a common (bad) practice to use Class for both ideas.
Definitions
|
Class
|
Provides a common implementation for a set of objects. |
|
Method
|
An implementation of an operation for a particular object/class. |
|
Instance Variable
|
A way to store encapsulated state information for a particular object. Instance variables are completely hidden within the Object, but they enable two objects of the same Class to have different external Behavior. |
|
Instance
|
An object is an Instance of a Type if an object supports all the exterior requirements of that type (see "Is-A"). An object is an instance of a Class if it is implemented by that class. |
|
Extent
|
The collection of all instances of a Type or Class. |
|
Inherit
|
To define a new Class in terms of an Existing Class (the Superclass) by starting with the Superclasss implementation and overiding or adding to it. |
More Information
All the methodologies focus on Classes, so any of them would be good for more information. Many are bad at separating the concept of Class from Type (see above under "Type"). Class is the most common term in OO Design and Analysis
Relationship Modeling
The above Type and Class concepts are just the beginning of the tools that can be used to reason about and implement objects. Relationship Modeling adds on the ability to describe relationships among Objects and Types of Objects.
Definitions
|
Link
|
A connection between two objects which allows one or both to know about the other object. By default links are assumed to be bidirectional in analysis, but they can be defined to be only traversable in one direction. |
|
Traverse
|
To move from one object to another by a Link. If a Link is traversable from an Object than that Object can get to (knows about) the other Object. |
|
Association1
|
A relationship between two Types that allows or requires Objects of those Types to be Linked. |
|
Role
|
The name of the "position" within a relationship an Object or Type holds. For example, a binary association has two roles that distinguish the two participants in the relationship. |
|
|
|
Association2
|
An Association1, but must be between Types which have Objects with Identity. See Attribute and ValueObject. |
|
ValueObject
|
An object that does not have identity independent of its value. A ValueObject is immutable and should be considered identical to anything that it is equal to. Primitive data types in Smalltalk (most numbers, Symbols) are ValueObjects. Java Strings are very close to ValueObjects except they are not guaranteed to be identical for the same value (they would be if they did an automatic "intern()"). Java primitive types are not Objects. |
|
Immutable
|
Can not be changed after being created. Immutable objects can not be changed after they are created and fully initialized. |
|
Attribute1
|
A public property of an object that shows an aspect of the state of the object. Frequently there is a minimal collection of attributes that uniquely determine the state of the object. See also Property. |
|
Attribute2
|
See BasicAttribute. |
|
Attribute3
|
See Instance Variable. |
|
BasicAttribute
|
An Attribute1 that takes its value from ValueObjects. This is as opposed to associations, which connect two or more objects with identity. A BasicAttribute is traversable only from the Object to the ValueObject. |
|
Property
|
Synonym for Attribute1 and sometimes for Attribute2. |
|
Feature
|
The Eiffel term for Operation where Operation includes both methods and attributes1. |
More Information
UML [Fowler 97, Rational 98] is now the primary source for the base concepts of Relationship Modeling in OO. More detailed modeling is done in other methods (for example, see [Kilov+R 95]). Many sources provide concepts for and examples of relationship modeling in particular domain areas (see the Patterns references). The biggest problem with Relationship modeling terminology is the overloaded and fuzzy meaning of "attribute", so be careful to consider what meaning was intended in a given context.
Patterns
The following list has definitions for terms that were codified into OO language through well-known Design Patterns. There are many more Patterns than the following definitions, but these are among the most common and accepted terms.
Definitions
|
Adapter
|
An object that can convert an Interface of one Class to the interface another Object expects. |
|
Factory
|
An object that can create other objects. |
|
Functor
|
An object that models an operation. |
|
Observable
|
An object that can be Observed. See Observer. |
|
Observer
|
An object that "looks at" another object (the Observable) and can respond to events in the Observable without the Observable being knowledgeable about the Observer. |
|
Prototype
|
An object that is used as a template for creating other Objects. |
|
Proxy
|
An object that stands in for another object (the RealObject) and manages the client interaction with the RealObject. |
|
Singleton
|
An object that is the only instance of a Class. |
|
Strategy
|
An object that encapsulates an algorithm to be used with an Object. |
|
Visitor
|
An object that represents an operation that can be performed on the elements of an Object structure (frequently a hierarchy or sequence). |
More Information
See [Gamma+HJV 96] for the full patterns to most of these definitions. Some definitions may also be covered in other Pattern resources and Patterns are frequently the source of new terminology.
Pattern: Proxy
The Proxy pattern is important to Information Systems, so the following provides some more details.
Definitions
|
Proxy
|
An object that stands in for another object (the RealObject) and manages the client interaction with the RealObject. |
|
Forwarder
|
A proxy which immediately forwards messages, possibly over process and machine boundaries, to the RealSubject. |
|
Replicate
|
A proxy which holds local state and performs local operations which are later propagated to the RealSubject |
|
Stub
|
A proxy which acts as a placeholder for the RealObject and must become another type of proxy (for example, forwarder or replicate) when interacted with by a client. |
|
RealIdentity
|
The identity of the RealObject that a proxy represents instead of the proxys independent identity. For proxies we are rarely interested in their own identity, we just want to know the identity of the RealObject on the server. |
|
IdentityKey
|
A value that defines the RealIdentity of a Proxy. |
|
Binding
|
Associating a client object to a database object, which turns the client object into a Proxy |
More Information
See [Gamma+HJV 96] for the basic proxy concept. See information on distributed processing (e.g. [GemStone 95]) and Object-Relational Mapping (e.g. [Fussell 96, Fussell 97a]) for details on the Proxy variations.
Pattern: Functor
The Functor pattern is common to all types of OO Systems. The following provide some more definitions.
Definitions
|
Functor
|
"An object that models an operation" [Firesmith+E 95]. For a Java implementation, a basic functor is an Interface with a single, generic, operation. |
|
Proceduref
|
A functor that does not return a value |
|
Functionf
|
A functor that returns an Object |
|
Predicatef
|
A functor that returns a boolean |
|
|
|
Getterf
|
A functor that is designed to retrieve a value from an object (the first parameter) |
|
Setterf
|
A functor that stores into an object (the first parameter) a value (the second parameter) |
More Information
Note that almost all of the definitions above also have a more general meaning, so to be specific you would need to append "Functor" to the end to be precise (e.g. "a Predicate Functor is a functor that returns a boolean")
Architecture
The following terms are related to system architecture.
Definitions
|
Architecture
|
A systems concepts, structures, and interactions. Also, the description of a systems desired architecture before construction. |
|
Framework
|
A strong partition of generalized functionality common to many parts of an application. Also, more formally, a collection of interacting classes that describes most of the behavior a client requires and can be subclassed and parameterized to customize and complete the functionality. |
|
Layer
|
A logical, horizontal division of a system that provides a particular system abstraction to the client above the layer. |
|
Module
|
A base level subsystem: one which does not contain any other subsystems |
|
Partition
|
A vertical division of a system into areas of related functionality. |
|
Subsystem
|
A division of a system into a cohesive unit of functionality (tightly related classes and internal subsystems) with a public interface and a private implementation. |
|
Tier
|
A level on a hierarchy of processes over which a system is divided. |
More Information
See the resources under Architecture (e.g. [Shaw+G 96, Fussell 96]) and also some of the large-picture methodology and project-management books (e.g. [Booch 96, Jacobson+CJO 92]).
Object-Oriented Information Systems
Object-Oriented Information Systems use Objects (called DomainObjects, BusinessObjects, or EntityObjects) to capture the knowledge, operations, and rules about a business within a computer.
Definitions
|
ObjectBase
|
.An ObjectBase captures the knowledge, operations, and rules required to usefully represent a particular part of the world in a computer. An ObjectBase contains all the objects that represent a particular state of your DomainModel and all the knowledge contained therein. Also called an ObjectSpace. |
|
DomainModel
|
All the static rules, constraints, and operations that apply to DomainObjects. The DomainModel can either be conceptual to help understand the behavior of DomainObjects or it can be implemented as DomainClasses. |
|
DomainObject
|
An object which captures knowledge about a domain. DomainObjects allow a computer to inspect, imply, modify, and "reason" about that information in either very simple ways (the facts) or more complex ways (the rules and implications). |
More Information
See [Fussell 96].
Other Terms
The following are some currently unclassified terms.
Definitions
|
Registry
|
An object that remembers other objects and can search through and retrieve them through one or more properties. Usually the objects within a Registry are all of the same type. |
|
Container
|
A Registry but without the implication of a primary registration property (e.g. a "key"). |
|
ExtentRegistry
|
A Registry that contains all the objects of a Type (the Extent of the Type). An ExtentRegistry is a close equivalent to a RelVar or Table in the context of Objects. |
|
ObjectShadow
|
The information needed to see that an object exists without any true representation of the real object. Relational databases could be considered to work with ObjectShadows: they record the information about an object but never have a real object to interact with. |
Java Terms
The following terms are very common in Java and not mentioned elsewhere.
Definitions
|
Bean
|
An Object that knows about its own properties (can introspect) and has several other capabilities. Any Java Object can be a Bean but some Objects have more Bean functionality. |
More Information
See the Java JDKs and information
Alphabetical
The following table contains all the previous mentioned definitions combined and sorted alphabetically.
|
Adapter
|
An object that can convert an Interface of one Class to the interface another Object expects. |
|
Architecture
|
A systems concepts, structures, and interactions. Also, the description of a systems desired architecture before construction. |
|
Association1
|
A relationship between two Types that allows or requires Objects of those Types to be Linked. |
|
Association2
|
An Association1, but must be between Types which have Objects with Identity. See Attribute and ValueObject. |
|
Attribute1
|
A public property of an object that shows an aspect of the state of the object. Frequently there is a minimal collection of attributes that uniquely determine the state of the object. See also Property. |
|
Attribute2
|
See BasicAttribute. |
|
Attribute3
|
See Instance Variable. |
|
BasicAttribute
|
An Attribute1 that takes its value from ValueObjects. This is as opposed to associations, which connect two or more objects with identity. A BasicAttribute is traversable only from the Object to the ValueObject. |
|
Bean
|
An Object that knows about its own properties (can introspect) and has several other capabilities. Any Java Object can be a Bean but some Objects have more Bean functionality. |
|
Behavior
|
The response of an object to a stimulus. An objects behavior is the answers it gives to messages both now and in the future. (See State). |
|
Binding
|
Associating a client object to a database object, which turns the client object into a Proxy |
|
Class
|
Provides a common implementation for a set of objects. |
|
Container
|
A Registry but without the implication of a primary registration property (e.g. a "key"). |
|
DomainModel
|
All the static rules, constraints, and operations that apply to DomainObjects. The DomainModel can either be conceptual to help understand the behavior of DomainObjects or it can be implemented as DomainClasses. |
|
DomainObject
|
An object which captures knowledge about a domain. DomainObjects allow a computer to inspect, imply, modify, and "reason" about that information in either very simple ways (the facts) or more complex ways (the rules and implications). |
|
Extend
|
To define a new Type (called a Subtype) in terms of an existing type (called a Supertype). The new Subtype will have the same contract (operations) as the Supertype but can add new functionality: as either new operations or enhancement in capability to existing operations. |
|
Extent
|
The collection of all instances of a Type or Class. |
|
ExtentRegistry
|
A Registry that contains all the objects of a Type (the Extent of the Type). An ExtentRegistry is a close equivalent to a RelVar or Table in the context of Objects. |
|
Factory
|
An object that can create other objects. |
|
Feature
|
The Eiffel term for Operation where Operation includes both methods and attributes1. |
|
Forwarder
|
A proxy which immediately forwards messages, possibly over process and machine boundaries, to the RealSubject. |
|
Framework
|
A strong partition of generalized functionality common to many parts of an application. Also, more formally, a collection of interacting classes that describes most of the behavior a client requires and can be subclassed and parameterized to customize and complete the functionality. |
|
Functionf
|
A functor that returns an Object |
|
Functor
|
An object that models an operation. |
|
Functor
|
"An object that models an operation" [Firesmith+E 95]. For a Java implementation, a basic functor is an Interface with a single, generic, operation. |
|
Getterf
|
A functor that is designed to retrieve a value from an object (the first parameter) |
|
Identity
|
The ability to tell one object from another object independently of whether their appearance (behavior) is identical. |
|
IdentityKey
|
A value that defines the RealIdentity of a Proxy. |
|
Immutable
|
Can not be changed after being created. Immutable objects can not be changed after they are created and fully initialized. |
|
Inherit
|
To define a new Class in terms of an Existing Class (the Superclass) by starting with the Superclasss implementation and overiding or adding to it. |
|
Instance
|
An object is an Instance of a Type if an object supports all the exterior requirements of that type (see "Is-A"). An object is an instance of a Class if it is implemented by that class. |
|
Instance Variable
|
A way to store encapsulated state information for a particular object. Instance variables are completely hidden within the Object, but they enable two objects of the same Class to have different external Behavior. |
|
Interface
|
A description of a Type focused on the Operations that the objects can respond to. |
|
Is-A
|
An object is a Type if an Object supports all the exterior requirements of that Type. |
|
Layer
|
A logical, horizontal division of a system that provides a particular system abstraction to the client above the layer. |
|
Link
|
A connection between two objects which allows one or both to know about the other object. By default links are assumed to be bidirectional in analysis, but they can be defined to be only traversable in one direction. |
|
Message
|
A stimulus sent to an object with a name and any parameters (as Objects) that the message requires. A message will cause the receiver Object to return an answer or nothing. In most Object Languages, the sender has to wait for the answer before continuing. |
|
Method
|
An implementation of an operation for a particular object/class. |
|
Module
|
A base level subsystem: one which does not contain any other subsystems |
|
Object
|
An identifiable, encapsulated entity that can only be interacted with by sending messages. |
|
ObjectBase
|
.An ObjectBase captures the knowledge, operations, and rules required to usefully represent a particular part of the world in a computer. An ObjectBase contains all the objects that represent a particular state of your DomainModel and all the knowledge contained therein. Also called an ObjectSpace. |
|
ObjectShadow
|
The information needed to see that an object exists without any true representation of the real object. Relational databases could be considered to work with ObjectShadows: they record the information about an object but never have a real object to interact with. |
|
Observable
|
An object that can be Observed. See Observer. |
|
Observer
|
An object that "looks at" another object (the Observable) and can respond to events in the Observable without the Observable being knowledgeable about the Observer. |
|
Operation
|
A description of the ability for an object to respond to a particular message and the contract/requirement for that message. |
|
Partition
|
A vertical division of a system into areas of related functionality. |
|
Predicatef
|
A functor that returns a boolean |
|
Proceduref
|
A functor that does not return a value |
|
Property
|
Synonym for Attribute1 and sometimes for Attribute2. |
|
Prototype
|
An object that is used as a template for creating other Objects. |
|
Proxy
|
An object that stands in for another object (the RealObject) and manages the client interaction with the RealObject. |
|
Proxy
|
An object that stands in for another object (the RealObject) and manages the client interaction with the RealObject. |
|
RealIdentity
|
The identity of the RealObject that a proxy represents instead of the proxys independent identity. For proxies we are rarely interested in their own identity, we just want to know the identity of the RealObject on the server. |
|
Registry
|
An object that remembers other objects and can search through and retrieve them through one or more properties. Usually the objects within a Registry are all of the same type. |
|
Replicate
|
A proxy which holds local state and performs local operations which are later propagated to the RealSubject |
|
Role
|
The name of the "position" within a relationship an Object or Type holds. For example, a binary association has two roles that distinguish the two participants in the relationship. |
|
Setterf
|
A functor that stores into an object (the first parameter) a value (the second parameter) |
|
Singleton
|
An object that is the only instance of a Class. |
|
State
|
An abstraction to describe and simplify understanding an objects behavior. An objects behavior can be described as the answers it gives to current messages (which are determined by the current state) and the changes to its state caused by these messages. |
|
Strategy
|
An object that encapsulates an algorithm to be used with an Object. |
|
Stub
|
A proxy which acts as a placeholder for the RealObject and must become another type of proxy (for example, forwarder or replicate) when interacted with by a client. |
|
Subsystem
|
A division of a system into a cohesive unit of functionality (tightly related classes and internal subsystems) with a public interface and a private implementation. |
|
Subtype
|
A Type that extends another Type (called the Supertype). |
|
Supertype
|
A Type that has been extended by another Type. |
|
Tier
|
A level on a hierarchy of processes over which a system is divided. |
|
Traverse
|
To move from one object to another by a Link. If a Link is traversable from an Object than that Object can get to (knows about) the other Object. |
|
Type
|
Describes a common exterior (public behavior) of a set of Objects. Can also be used to conceptually group and understand objects by their similar behavior. |
|
ValueObject
|
An object that does not have identity independent of its value. A ValueObject is immutable and should be considered identical to anything that it is equal to. Primitive data types in Smalltalk (most numbers, Symbols) are ValueObjects. Java Strings are very close to ValueObjects except they are not guaranteed to be identical for the same value (they would be if they did an automatic "intern()"). Java primitive types are not Objects. |
|
Visitor
|
An object that represents an operation that can be performed on the elements of an Object structure (frequently a hierarchy or sequence). |
|