.Open Objects: Concepts and Terms . C++ vs Smalltalk .As_is From: rmartin@oma.com (Robert C. Martin) .As_is .As_is There are two distinct vocabularies in OOT. I call them the C++ and .As_is Smalltalk vocabularies because they is a correlation between .As_is the vocabulary that programmers use, and the language that they use. .As_is .As_is C++ Smalltalk .As_is ------------------------- ------------------------------ .As_is Class Class .As_is Object Object .As_is Base Class Super Class .As_is Derived Class Sub Class .As_is Member Function Method, or Instance Method. .As_is Call a Member Function Send a message .As_is Static Member Function Class Method .As_is Member Variable Instance Variable .As_is Static Member Variable Class Variable .As_is Pure Virtual Function Subclass Responsibility .As_is .As_is -- .As_is Robert Martin | Design Consulting | Training courses offered: .As_is Object Mentor Assoc.| rmartin@oma.com | OOA/D, C++, Advanced OO .As_is 14619 N. Somerset Cr| Tel: (708) 918-1004 | Mgt. Overview of OOT .As_is Green Oaks IL 60048 | Fax: (708) 918-1023 | Development Contracts. .As_is .Open The CORBA Model .Source [Snyder 93, Alan Snyder, The Essence of Objects: Concepts and Terms, IEEE Software V10n1(Jan 93)pp31-42] . Set of Core Concepts OBJECT_0::=Net{ 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. }=::OBJECT_0. . Semi-Formal Model of Core Concepts OBJECT_1::=following .Net Objects::Sets, `Something that is identifiable and has a visible role in providing a service that a client can request`. Abstractions::Sets, properties embodied by objects. Services::Sets, things provided by objects to clients. Clients::Sets, humans or programs that issue 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`. Requests::Sets. 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`. Implementations::Sets. Part_Implementations::Sets. Operations::Sets. embody::Objects(any)-(1)Abstractions. provide::Objects(any)-(1)Services. issue::Clients(any)-(any)Requests. identifies::Requests(any)-(1)Objects. classification::Equivalence_relation(Objects ). |-(O1): classification ==> (=)mod provide. |-(O2): implements::Objects(any)-(any)Implementations. |-(O3): PART_WHOLE(objects=>Implementations, isin=>part_of). .See http://www/dick/maths/math_21_Order.html#PART_WHOLE |-(O4): Part_Implementations part_of Implementations, share::(@Objects)(any)-(1)Part_implementations. (O5):New objects can be created. (O6):Operations can be generic. Generic_operation::=`an operation that has different implementations for different objects, with observably different behavior, but a single uniform request`. (O7):Objects are encapsulated. Encapsulated_object::=`An object that can only be accessed by clients by issuing requests`. Beware of confusing `encapsulation` with `information hiding`. Encapsulation is an implementation 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`. Classes::=Objects/classification. 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)`. Object_reference::=`a value that reliably identifies a specific object` 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`. . Associated Concepts 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] .Close.Net OBJECT_1 .Close CORBA .Close Objects: Concepts and Terms