C++ vs Smalltalk
From: email@example.com (Robert C. Martin)
There are two distinct vocabularies in OOT. I call them the C++ and
Smalltalk vocabularies because they is a correlation between
the vocabulary that programmers use, and the language that they use.
Base Class Super Class
Derived Class Sub Class
Member Function Method, or Instance Method.
Call a Member Function Send a message
Static Member Function Class Method
Member Variable Instance Variable
Static Member Variable Class Variable
Pure Virtual Function Subclass Responsibility
Robert Martin | Design Consulting | Training courses offered:
Object Mentor Assoc.| firstname.lastname@example.org | OOA/D, C++, Advanced OO
14619 N. Somerset Cr| Tel: (708) 918-1004 | Mgt. Overview of OOT
Green Oaks IL 60048 | Fax: (708) 918-1023 | Development Contracts.
Table of Eiffel vs C++ vs Smalltalk
[ EiffelTerms.html ]
(Warning: Use a browser that can handle tables (HTML 3.0), Netscape 1.1+)
or else see
[ PreformattedTerms.html ]
The CORBA Model
[Snyder 93, Alan Snyder<email@example.com>, The Essence of Objects: Concepts and Terms, IEEE Software V10n1(Jan 93)pp31-42]
Set of Core Concepts
- All objects embody an abstraction.
- Objects provide services.
- Clients issue requests.
- Objects are encapsulated.
- Requests can identify objects.
- New objects can be created.
- Operations can be generic.
- Objects can be classified in terms of their services.
- Objects can have common implementations.
- Objects can share partial implementations.
Formal Model of Core Concepts
- classification::Equivalence_relation(Objects ).
- (O1): classification ==> (=)mod provide.
- (O3): PART_WHOLE(objects=>Implementations, isin=>part_of).
[ PART_WHOLE in math_21_Order ]
- (O4): Part_Implementations part_of Implementations,
- (O5): New objects can be created.
- (O6): Operations can be generic.
- (O7): Objects are encapsulated.
- is_a::@(Classes,Classes)=Every object in (1st) is also a (2nd).
- has_a::@(Classes,Classes)=Every object of (1st) encapsulates an object of class (2nd).
- like_a::@(Classes,Classes)=(1st) shares an abtraction with (2nd).
Informal Definitions of Terms
- Object::=something that is identifiable and has a visible role in providing a service that a client can request.
- Client::=A human or a program that issues requests for services.
Implicitly an object can act as a client merely by requesting
services from other objects as part of the process whereby it
services its own clients. The relation between a client object and its
server is that of collaborations.
- Encapsulated_0bject::=An object that can only be accessed by clients by issuing requests.
Beware of confusing encapsulation with information hdiing. Encapsulation
is animplementation option. Information hiding is a powerful heuristic for
designing maintainable objects: each object encapsulates a design choice.
- Embedded_object::=An object created by wrapping an existing structure or process that is not an object within an appropriate interface.
- Protected_Object::=An object that restricts the ability of specific clients to request its services.
- Object_reference::=a value that reliably identifies a specific object
- Request::=a client action to cause a service to be performed and identifies an operation denoting the requested service and includes parameters which may identify object.
- Generic_operation::=an operation that has different implementations for different objects, with observably different behavior, but a single uniform request.
- Interface::=describes the ways that an object can be used. Describes a set of potential requests that identify the object as a parameter.
- Interface_Hierarchy::=a classification of interfaces in terms of conformance. A lattice in which higher interfaces are more general and accept requests that are also accepted by conforming objects.
- Type::=An identifiable entity with an associated predicate defined of values. A member of the type satisfies the associated predicate.
- Sub_type::=A type whose members are also members of another type that is called a super-type.
- Super_type::=A type some of whose members can be also members of another type called a subtype.
- Binding::=The process of selecting the code to perform a requested service.
- Dynamic_binding::=A binding made at the time the service is requested.
- Static_Binding::=A binding is made before the service is requested.
- Object_implementation::=An executable description of how to perform the set of services associated with an object plus the data associated with the object.
- State_Variable::=Serves as the concrete realization of the data associated with objects.
- Method::=A procedure that performs a service.
- Implementation_Inheritance::=A mechanism for creating object implementations incrementally in terms of other object implementations.
- Active_objects::=objects that can initiate computation without being requested to do so by a client.
- Composite_objects::=objects that are formed by combining or linking together other objects so that they can be manipulated as a unit.
- Hot_link::=Changes in an object linked into a composite object is reflected in the composite object.
- Event_notification::=A client can register interest in an event or condition occurring in an object and be notified when it occurs.
- Event_driven_control_structure::=A program structure with a top-level loop that waits for events and dispatches them to appropriate handlers.
- Presentation_semantic_split::=Using separate objects to represent meaning in abstract and to display information to the user. There can be many ways to display one meaning.
- Relationships::=Information that is associated with multiple objects not with individual objects.
Classical vs Generalized Model.
- Classical_model_of_objects::=A request has a parameter that identifies the object that provides the service.
Other useful terms
- Persistance::=The property of an object through which its existance trancends time (i.e. the object continues to exist after its creator ceases to exist) and/or space (i.e. the object's location moves from the address space in which it was created). [Booch 91, p70]
. . . . . . . . . ( end of section CORBA) <<Contents | End>>
. . . . . . . . . ( end of section Objects: Concepts and Terms) <<Contents | End>>