135 Based approaches (e.G. Smalltalk handles) allow powerful dynamic typing, as

142 dynamic typing (checked downcasting) similar to those introduced by Eiffel

147 pointer (such as void* in C++) and an embedded dynamic typing scheme are used

399 Inheritance can also be used for typing, where a type or class can be used to

498 (typing based on subclassing, or subclass polymorphism), since only an object

576 Typing

645 used in languages with static typing for simplicity and efficiency

660 dominate and double dispatch can be suffered, or an embedded dynamic typing

678 requires both static and dynamic typing, because no formal argument

689 general undecidability of dynamic types at compile-time renders dynamic typing

879 inheritance, and dynamic typing in 1967 (in addition to its Algol-60 subset).

884 powerful dynamic typing mechanism (although these existed to some extent in

899 2.1) What Is Polymorphism? (Typing - Object-Oriented Technology)

1047 2.2) What Does Polymorphism Boil Down To In OO Programming Languages? (Typing - Object-Oriented Technology)

1063 2.3) What Is Dynamic Binding? (Typing - Object-Oriented Technology)

1101 2.4) Is There A Difference Between Being A Member Or Instance Of A Class? (Typing - Object-Oriented Technology)

1107 class inherits from. With static typing and inclusion polymorphism based on

1113 2.5) What Is The Difference Between Static And Dynamic Typing? (Typing - Object-Oriented Technology)

1114 Static typing refers to types declared in a program at compile-time, so no type

1115 information is available on objects at run-time. Dynamic typing uses the

1120 both static and dynamic typing, sometimes with static typing providing type-

1121 safe programs and dynamic typing providing multiple-polymorphism [Agrawal 91]

1123 Static typing is more efficient and reliable, but loses power. Typical

1127 (see section 1.19), both of which are overcome with dynamic typing.

1128 Many languages provide dynamic typing: Smalltalk, Self, Objective-C, and etc.

1129 A limited dynamic typing scheme, called RTTI (Run Time Type Identification),

1134 2.6) What Is This I Hear About ML And Functional Programming Languages? (Typing - Object-Oriented Technology)

1138 "pure" example. Section 2.5 discusses why static typing has less power

1139 flexibility than dynamic typing and the same applies to ML (although see the

1151 2.7) What Is A Separation Between Type And Class (Representation)? (Typing - Object-Oriented Technology)

1191 Abstract classes ([Stroustrup 91] and [Meyer 88]) in typing provide a facility

1207 2.8) What Are Generics And Templates? (Typing - Object-Oriented Technology)

booch

83 There are many definitions of an object, such as found in [Booch 91, p77]:

92 reality" [Booch 91, p77]. Other definitions referenced by Booch include

97 definition appears on pg 54). Booch goes on to describe these definitions

109 things, Roles, Incidents, Interactions, and Specifications." [Booch 91, 4.3]

209 usage is atypical] See [Booch 94, pp 154-155] for a brief discussion of

228 [Booch 91, p. 45] defines: "Encapsulation is the process of hiding all of the

280 [Booch 91, p93]

289 [Booch 94, 4.2] proposes 3 views of classification as useful in OO analysis and

304 modification). [Booch 91, p 119] provides another example in Smalltalk with

416 Class hierarchies are subjective [Booch 91, 4.2; Lakoff 87] and usually drawn

432 explicitly calling them, allowing client class code to remain unchanged [Booch

531 derived classes into a common base (or parent) is generalization [Booch 91,

554 These definitions are also found in [Booch 91, Ch2 and Wegner 87].

569 [Booch 94, 2.2] proposes 7 "Elements of the Object Model"; 4 major and 3 minor:

593 A method implements behavior, which is defined by [Booch 91, p80]:

703 classified bibliography in [Booch 94] also contains entries on OOA(B), OOD(F)

705 [Booch 91]

723 applications within a given domain, [...]". - [Booch 91]

764 models, and even DFD's. Booch, Jacobson, and Wirfs-Brock are examples of OO

768 which is quite powerful. [Booch 94] presents a methodology which is an

773 on by Grady Booch, James Rumbaugh, and Ivar Jacobson at Rational Software which

792 with a risk-driven incremental prototyping approach. [Booch 91, 6.1]

863 See also [Yourdon 92], [Wilkie 93], and [Booch 94] for discussions on this

902 Author, Strachey, Cardelli and Wegner, Booch, Meyer, Stroustrup, and Rumbaugh.

1014 > Booch's Definition [Booch 91, p. 517]:

1019 Booch also has several sections devoted to polymorphism.

1222 See [Booch 87b] for several examples in Ada and [Stroustrup xx] and [Murray

1401 Booch [Booch 94]

1445 Booch OOD, Wirfs-Brock responsibility-driven design.

1465 [Wilkie 93] summarizes, compares, and provides examples of Booch, Wirfs-Brock,

1470 Booch, G. - Object-oriented analysis and design with applications, 1994.

static

21 Dynamic dispatch – when a method is invoked on an object, the object itself determines what code gets executed by looking up the method at run time in a table associated with the object. This feature distinguishes an object from an abstract data type (or module), which has a fixed (static) implementation of the operations for all instances. It is a programming methodology that gives modular component development while at the same time being very efficient.

140 objects [Kim 89, ch 19 and Yaoqing 93]. Simple static approaches are found in

154 Simple statically-typed objects (static and auto vars and temps in C++ and

176 static typechecking requirements are dropped. See section 2.5.

338 variables shared between all instances of a class (static member data in

502 favor of a static type (or even loss of an object's representation to that of

503 the static class, as in C++ slicing). Maintaining the dynamic type of objects

600 the method operates on. An exception exists with C++'s static member functions

645 used in languages with static typing for simplicity and efficiency

671 efficiency, and to support a static programming idiom, but require restrictions

678 requires both static and dynamic typing, because no formal argument

679 differentiation is possible without static types, as in Smalltalk, and no

684 However, static analysis optimizations are commonly available in the

685 literature, potentially providing a single static selection in many cases

1027 [The Author notes Meyer has a following section 10.1.7 on Static Type,

1055 derived class and working its way up). But for static objects, a virtual

1064 Dynamic binding has two forms, static and dynamic. Statically-typed dynamic

1074 function pointers with static typechecking in the base class, and filling them

1107 class inherits from. With static typing and inclusion polymorphism based on

1113 2.5) What Is The Difference Between Static And Dynamic Typing? (Typing - Object-Oriented Technology)

1114 Static typing refers to types declared in a program at compile-time, so no type

1120 both static and dynamic typing, sometimes with static typing providing type-

1123 Static typing is more efficient and reliable, but loses power. Typical

1138 "pure" example. Section 2.5 discusses why static typing has less power

1148 parametric polymorphism without static constraints (by Strachey's definition).

1183 difference between static and dynamic binding in OO and dynamic binding and

1224 While generics have many advantages, typical limitations include a static

1542 Design Inc. includes both static and dynamic interfaces to an inter-

1731 (which includes support for CORBA's static client interface) is available

1820 language compiler, static and dynamic invocation interface and interface

2365 include failure to reclaim cycles, inability to handle stack and static

2388 exceptions, also make static analysis of memory usage at compile-time

information

2 In the domain of object-oriented programming an object is usually taken to mean an ephemeral compilation of attributes (object elements) and behaviors (methods or subroutines) encapsulating an entity. In this way, while primitive or simple data types are still just single pieces of information, object-oriented objects are complex types that have multiple pieces of information and specific properties (or attributes). Instead of merely being assigned a value, (like int =10), objects have to be "constructed". In the real world, if a Ford Focus is an "object" - an instance of the car class, its physical properties and its function to drive would have been individually specified. Once the properties of the Ford Focus "object" had been specified into the form of the car class, it can be endlessly copied to create identical objects that look and function in just the same way. As an alternative example, animal is a superclass of primate and primate is a superclass of human. Individuals such as Joe Bloggs or John Doe would be particular examples or 'objects' of the human class, and consequently possess all the characteristics of the human class (and of the primate and animal superclasses as well).

8 Object-oriented programming has roots that can be traced to the 1960s. As hardware and software became increasingly complex, manageability often became a concern. Researchers studied ways to maintain software quality and developed object-oriented programming in part to address common problems by strongly emphasizing discrete, reusable units of programming logic[citation needed]. The technology focuses on data rather than processes, with programs composed of self-sufficient modules ("classes"), each instance of which ("objects") contains all the information needed to manipulate its own data structure ("members"). This is in contrast to the existing modular programming that had been dominant for many years that focused on the function of a module, rather than specifically the data, but equally provided for code reuse, and self-sufficient reusable units of programming logic, enabling collaboration through the use of linked modules (subroutines). This more conventional approach, which still persists, tends to consider data and behavior separately.

45 Simula (1967) is generally accepted as the first language to have the primary features of an object-oriented language. It was created for making simulation programs, in which what came to be called objects were the most important information representation. Smalltalk (1972 to 1980) is arguably the canonical example, and the one with which much of the theory of object-oriented programming was developed. Concerning the degree of object orientation, following distinction can be made:

50 Languages with abstract data type support, but not all features of object-orientation, sometimes called object-based languages. Examples: Modula-2 (with excellent encapsulation and information hiding), Pliant, CLU.

71 Responsibility-driven design defines classes in terms of a contract, that is, a class should be defined around a responsibility and the information that it shares. This is contrasted by Wirfs-Brock and Wilkerson with data-driven design, where classes are defined around the data-structures that must be held. The authors hold that responsibility-driven design is preferable.

230 [Coad 91, 1.1.2] defines: "Encapsulation (Information Hiding). A principle,

736 relevant information in a domain based on the study of existing systems and

756 information modeling and recursive design, or OOA

873 efforts places information systems within an organizational perspective by

874 modeling entire organizations or a large part of them, with the information

1115 information is available on objects at run-time. Dynamic typing uses the

1345 addresses and contact information for ODBMS vendors, ODMG membership

1346 information, updates to Release 1.1 of The Object Database Standard:

1349 If you cannot access these servers, but would like information on the

1444 Yourdon-Constantine SD, Martin information engineering design, Wasserman OOSD,

1450 Center of Telematics and Information Technology, University of Twente,

1451 the Netherlands, and Computer Information Systems Department, Georgia

1493 3.8.1) Contact Information (OMG

1499 Feel free to call, fax or email for more information.

1530 The OMG adoption cycle includes Requests for Information and

1532 information from OMG members about existing products to fill

1567 Information via Mail Server:

1593 newsletter. First Class provides current information on Object

1598 case histories, OT training information and the latest object-

1749 integrated, desktop access to enterprise-wide information and resources in

1792 executive officer of Information Advantage, Inc. "Our object-based

2115 access to information and to each other -- anytime,

2123 task of connecting employees with the information they need. In a

2130 on-line data, information technology (IT) managers are turning to

2164 customer's applications, making it possible to share information

2668 For more information contact IPL:

instance

1 Object-oriented programming (OOP) is a programming paradigm using "objects" – data structures consisting of data fields and methods together with their interactions – to design applications and computer programs. Programming techniques may include features such as data abstraction, encapsulation, messaging, modularity, polymorphism, and inheritance. Many modern programming languages now support OOP, at least as an option. In computer science, an object is any entity that can be manipulated by the commands of a programming language, such as a value, variable, function, or data structure. (With the later introduction of object-oriented programming the same word, "object", refers to a particular instance of a class)

2 In the domain of object-oriented programming an object is usually taken to mean an ephemeral compilation of attributes (object elements) and behaviors (methods or subroutines) encapsulating an entity. In this way, while primitive or simple data types are still just single pieces of information, object-oriented objects are complex types that have multiple pieces of information and specific properties (or attributes). Instead of merely being assigned a value, (like int =10), objects have to be "constructed". In the real world, if a Ford Focus is an "object" - an instance of the car class, its physical properties and its function to drive would have been individually specified. Once the properties of the Ford Focus "object" had been specified into the form of the car class, it can be endlessly copied to create identical objects that look and function in just the same way. As an alternative example, animal is a superclass of primate and primate is a superclass of human. Individuals such as Joe Bloggs or John Doe would be particular examples or 'objects' of the human class, and consequently possess all the characteristics of the human class (and of the primate and animal superclasses as well).

6 An object-oriented program will usually contain different types of objects, each type corresponding to a particular kind of complex data to be managed or perhaps to a real-world object or concept such as a bank account, a hockey player, or a bulldozer. A program might well contain multiple copies of each type of object, one for each of the real-world objects the program is dealing with. For instance, there could be one bank account object for each real-world account at a particular bank. Each copy of the bank account object would be alike in the methods it offers for manipulating or reading its data, but the data inside each object would differ reflecting the different history of each account.

8 Object-oriented programming has roots that can be traced to the 1960s. As hardware and software became increasingly complex, manageability often became a concern. Researchers studied ways to maintain software quality and developed object-oriented programming in part to address common problems by strongly emphasizing discrete, reusable units of programming logic[citation needed]. The technology focuses on data rather than processes, with programs composed of self-sufficient modules ("classes"), each instance of which ("objects") contains all the information needed to manipulate its own data structure ("members"). This is in contrast to the existing modular programming that had been dominant for many years that focused on the function of a module, rather than specifically the data, but equally provided for code reuse, and self-sufficient reusable units of programming logic, enabling collaboration through the use of linked modules (subroutines). This more conventional approach, which still persists, tends to consider data and behavior separately.

9 An object-oriented program may thus be viewed as a collection of interacting objects, as opposed to the conventional model, in which a program is seen as a list of tasks (subroutines) to perform. In OOP, each object is capable of receiving messages, processing data, and sending messages to other objects. Each object can be viewed as an independent "machine" with a distinct role or responsibility. The actions (or "methods") on these objects. The terms "objects" and "oriented" in something like the modern sense of object- oriented programming seem to make their first appearance at MIT in the late 1950s and early 1960s. In the environment of the artificial intelligence group, as early as 1960, "object" could refer to identified items (LISP atoms) with properties (attributes); Alan Kay was later to cite a detailed understanding of LISP internals as a strong influence on his thinking in 1966.[3] Another early MIT example was Sketchpad created by Ivan Sutherland in 1960-61; in the glossary of the 1963 technical report based on his dissertation about Sketchpad, Sutherland defined notions of "object" and "instance" (with the class concept covered by "master" or "definition"), albeit specialized to graphical interaction. Also, an MIT ALGOL version, AED-0, linked data structures ("plexes", in that dialect) directly with procedures, prefiguring what were later termed "messages", "methods" and "member functions".

19 Not all of these concepts are to be found in all object-oriented programming languages. For example, object-oriented programming that uses classes is sometimes called class-based programming, while prototype-based programming does not typically use classes. As a result, a significantly different yet analogous terminology is used to define the concepts of object and instance.

85 similar objects are defined in their common class; the terms instance and

156 whose record fields are called instance variables (Smalltalk) or member data

161 Members will denote both instance variables and methods. Inheritance is

178 member function, instance variable

237 Object Pascal provide no protection for objects, meaning instance variables

255 For another example, Smalltalk's class instance variables are not accessible

259 class. All Smalltalk instance variables can be accessed by subclasses,

270 of structure (instance variables), behavior (methods), and inheritance

286 behavior." "A single object is simply an instance of a class."

320 Meta-Class. The Meta-Class is a class and is therefore an instance of

342 In the authors opinion, a myth. The story goes an object is an instance of a

343 class (Meta-Object), a class is an instance of a Meta-Class, which must also

344 be an instance of a Meta-Meta-Class, which must also be an instance of a Meta-

346 a Meta-Class being an instance of itself or with a "Meta-Class - Meta-Class

354 modification (e.g. add the following method or instance to this class,

442 "slots" (instance variables) with the same name into a single slot, as did

445 same names for instance variables of subclasses illegal.

467 then a potential to share that class. Only one instance of the class will

980 polymorphism specifies an instance of a subclass can appear wherever an

981 insta nce of a superclass is required. For subtyping (subtype polymorphism),

1101 2.4) Is There A Difference Between Being A Member Or Instance Of A Class? (Typing - Object-Oriented Technology)

1103 a reference) is defined to be an instance of exactly one class (in classical

1112 a class is one of its instance variables in C++.

1262 where reuse occurs at a finer degree of granularity - method and instance

2310 instance many C compilers limit expression nesting, identifier

defined

9 An object-oriented program may thus be viewed as a collection of interacting objects, as opposed to the conventional model, in which a program is seen as a list of tasks (subroutines) to perform. In OOP, each object is capable of receiving messages, processing data, and sending messages to other objects. Each object can be viewed as an independent "machine" with a distinct role or responsibility. The actions (or "methods") on these objects. The terms "objects" and "oriented" in something like the modern sense of object- oriented programming seem to make their first appearance at MIT in the late 1950s and early 1960s. In the environment of the artificial intelligence group, as early as 1960, "object" could refer to identified items (LISP atoms) with properties (attributes); Alan Kay was later to cite a detailed understanding of LISP internals as a strong influence on his thinking in 1966.[3] Another early MIT example was Sketchpad created by Ivan Sutherland in 1960-61; in the glossary of the 1963 technical report based on his dissertation about Sketchpad, Sutherland defined notions of "object" and "instance" (with the class concept covered by "master" or "definition"), albeit specialized to graphical interaction. Also, an MIT ALGOL version, AED-0, linked data structures ("plexes", in that dialect) directly with procedures, prefiguring what were later termed "messages", "methods" and "member functions".

16 More recently, a number of languages have emerged that are primarily object-oriented yet compatible with procedural methodology, such as Python and Ruby. Probably the most commercially important recent object-oriented languages are Visual Basic.NET (VB.NET) and C#, both designed for Microsoft's .NET platform, and Java, developed by Sun Microsystems. Both frameworks show the benefit of using OOP by creating an abstraction from implementation in their own way. VB.NET and C# support cross-language inheritance, allowing classes defined in one language to subclass classes defined in the other language. Developers usually compile Java to bytecode, allowing Java to run on any operating system for which a Java virtual machine is available. VB.NET and C# make use of the Strategy pattern to accomplish cross-language inheritance, whereas Java makes use of the Adapter pattern[citation needed].

25 Open recursion – a special variable (syntactically it may be a keyword), usually called this or self, that allows a method body to invoke another method body of the same object. This variable is late-bound; it allows a method defined in one class to invoke another method that is defined later, in some subclass thereof.

71 Responsibility-driven design defines classes in terms of a contract, that is, a class should be defined around a responsibility and the information that it shares. This is contrasted by Wirfs-Brock and Wilkerson with data-driven design, where classes are defined around the data-structures that must be held. The authors hold that responsibility-driven design is preferable.

85 similar objects are defined in their common class; the terms instance and

87 defined in [Coplien 92, p280], where "classes play a central role in the

95 problem domain." and [Cox 91]: "anything with a crisply defined boundary"

233 to each module is defined in such a way as to reveal as little as possible

236 defined outside of a class as in conventional programming. Simula and

238 may be accessed wherever visible. CLOS and Ada allow methods to be defined

242 However most object-oriented languages provide a well defined interface to

402 inheritance should be defined instead of over what it is, since it has many

522 Some prefer association to MI, claiming "roles" (as defined in [Rumbaugh 91])

593 A method implements behavior, which is defined by [Booch 91, p80]:

596 A method is a function or procedure which is defined in a class and typically

625 Multiple-polymorphism allows specialized functions or methods to be defined to

635 single, highly cohesive and loosely coupled functions to be defined. This is

781 Process Models for finer grained analysis and design in the Defined Process

841 Level 3: Defined: Standard processes are defined and used for all projects.

901 defined in many ways, so many definitions are presented from: Websters',

1054 respond in whatever way the object has defined (usually starting from its most

1103 a reference) is defined to be an instance of exactly one class (in classical

1111 oriented languages, since a member is defined as above in CLOS, but a member of

1162 performed on that type are well defined (statically bound) and providing for

1219 or user defined type, or even a Stack of Stacks of ... Another example is

1326 Persistence is often defined as objects (and their classes in the case of

1614 The CORBA, as defined by the OMG's Object Request Broker (ORB),

domain

2 In the domain of object-oriented programming an object is usually taken to mean an ephemeral compilation of attributes (object elements) and behaviors (methods or subroutines) encapsulating an entity. In this way, while primitive or simple data types are still just single pieces of information, object-oriented objects are complex types that have multiple pieces of information and specific properties (or attributes). Instead of merely being assigned a value, (like int =10), objects have to be "constructed". In the real world, if a Ford Focus is an "object" - an instance of the car class, its physical properties and its function to drive would have been individually specified. Once the properties of the Ford Focus "object" had been specified into the form of the car class, it can be endlessly copied to create identical objects that look and function in just the same way. As an alternative example, animal is a superclass of primate and primate is a superclass of human. Individuals such as Joe Bloggs or John Doe would be particular examples or 'objects' of the human class, and consequently possess all the characteristics of the human class (and of the primate and animal superclasses as well).

95 problem domain." and [Cox 91]: "anything with a crisply defined boundary"

96 (in context, this is "outside the computer domain". A more conventional

111 understanding of the problem domain and [Jacobson 92] provides a novel approach

478 Inheritance is a natural way to model the world or a domain of discourse,

480 common in the AI domain, where semantic nets use inheritance to understand

707 that form the vocabulary of the problem domain, and in OOD, we invent the

711 "OOA is the challenge of understanding the problem domain, and then the

713 "To us, analysis is the study of a problem domain, leading to a specification

720 And on Domain Analysis:

721 "Whereas OOA typically focuses upon one specific problem at a time, domain

723 applications within a given domain, [...]". - [Booch 91]

724 [The following quotes on domain analysis are from [Berard 93]]

728 "Systems analysis states what is done for a specific problem in a domain

729 while domain analysis states what can be done in a range of problems in a

730 domain. ...A domain analysis is only useful in many similar systems are to

731 be built so that the cost of the domain analysis can be amortized over the

733 The key to reusable software is captured in domain analysis in that it

736 relevant information in a domain based on the study of existing systems and

737 their development histories, knowledge captured from domain experts,

738 underlying theory, and emerging technology within the domain." - Kang et al.

739 Object-oriented domain analysis (OODA) seeks to identify reusable items

742 interact on a fairly frequent basis with the domain analysis effort.

745 concepts (objects and classes), a particular problem within a problem domain

746 (from its requirements, domain and environment) from a user-oriented or domain

751 external interface of the system to be built, often obtained from a domain

820 A problem domain has many realizations, or differing OOAs. An OOA has many

2075 directory entries required for cross domain operation

2076 in a multiple domain heterogeneous network.

programs

1 Object-oriented programming (OOP) is a programming paradigm using "objects" – data structures consisting of data fields and methods together with their interactions – to design applications and computer programs. Programming techniques may include features such as data abstraction, encapsulation, messaging, modularity, polymorphism, and inheritance. Many modern programming languages now support OOP, at least as an option. In computer science, an object is any entity that can be manipulated by the commands of a programming language, such as a value, variable, function, or data structure. (With the later introduction of object-oriented programming the same word, "object", refers to a particular instance of a class)

4 Objects are used in software development to implement abstract data structures, by bringing together the data components with the procedures that manipulate them. Objects in object- oriented programming are key in the concept of inheritance; thereby improving program reliability[attribution needed], simplification of software maintenance[attribution needed], the management of libraries, and the division of work in programmer teams. Object-oriented programming languages are generally designed to exploit and enforce these potential advantages of the object model. Objects can also make it possible to handle very disparate objects by the same piece of code, as long as they all have the proper method. Simple, non-OOP programs may be one "long" list of statements (or commands). More complex programs will often group smaller sections of these statements into functions or subroutines each of which might perform a particular task. With designs of this sort, it is common for some of the program's data to be 'global', i.e. accessible from any part of the program. As programs grow in size, allowing any function to modify any piece of data means that bugs can have wide-reaching effects.

8 Object-oriented programming has roots that can be traced to the 1960s. As hardware and software became increasingly complex, manageability often became a concern. Researchers studied ways to maintain software quality and developed object-oriented programming in part to address common problems by strongly emphasizing discrete, reusable units of programming logic[citation needed]. The technology focuses on data rather than processes, with programs composed of self-sufficient modules ("classes"), each instance of which ("objects") contains all the information needed to manipulate its own data structure ("members"). This is in contrast to the existing modular programming that had been dominant for many years that focused on the function of a module, rather than specifically the data, but equally provided for code reuse, and self-sufficient reusable units of programming logic, enabling collaboration through the use of linked modules (subroutines). This more conventional approach, which still persists, tends to consider data and behavior separately.

45 Simula (1967) is generally accepted as the first language to have the primary features of an object-oriented language. It was created for making simulation programs, in which what came to be called objects were the most important information representation. Smalltalk (1972 to 1980) is arguably the canonical example, and the one with which much of the theory of object-oriented programming was developed. Concerning the degree of object orientation, following distinction can be made:

91 objects typically existed in Simula programs to simulate some aspect of

302 The Meta-Class can also provide services to application programs, such as

315 programs (no Meta-Class except for in the compiler and perhaps for type-safe

323 be first class objects and therefore classes are available to programs.

581 Meta-Class) and because C++ classes are not accessible to programs. Classes

1121 safe programs and dynamic typing providing multiple-polymorphism [Agrawal 91]

1322 programs, an equivalence that would be lost if an alternative were chosen, as

1327 OODBs) that outlive the programs that create them. Object lifetimes can be

1361 them is available to programs.

1754 business benefit, and offers worldwide support and training programs,

2312 problems for programs that generate C.

2386 of an object. For example, event driven GUI programs frequently have no

2416 compatibly manage both new and existing programs. [2]

2417 Garbage collected programs are usually as fast and responsive as

2421 scheduling destructor calls smoothly. Of course, garbage collected programs

2423 manually managed programs. Finally, garbage collection can be mixed with

2498 Object-Oriented Programs", Proceedings of the 4th Symposium on

2506 Object-Oriented Programs", Proceedings of the 8th Pacific

2544 Object-Oriented Programs", IEEE Software, July 1991, pp. 72-80.

2574 Programs", JOOP, 5(3):45-53, June 1992.

2593 Turner, C. D. and D. J. Robson, "The Testing of Object-Oriented Programs",

2599 programs. Testing of OOP is compared with traditional software

2606 Testing of Object-Oriented Programs", Technical Report

2618 Oriented Programs", Technical Report TR-2

2700 testing of C++, C and Perl programs. The system is called ETET (Extended

member

9 An object-oriented program may thus be viewed as a collection of interacting objects, as opposed to the conventional model, in which a program is seen as a list of tasks (subroutines) to perform. In OOP, each object is capable of receiving messages, processing data, and sending messages to other objects. Each object can be viewed as an independent "machine" with a distinct role or responsibility. The actions (or "methods") on these objects. The terms "objects" and "oriented" in something like the modern sense of object- oriented programming seem to make their first appearance at MIT in the late 1950s and early 1960s. In the environment of the artificial intelligence group, as early as 1960, "object" could refer to identified items (LISP atoms) with properties (attributes); Alan Kay was later to cite a detailed understanding of LISP internals as a strong influence on his thinking in 1966.[3] Another early MIT example was Sketchpad created by Ivan Sutherland in 1960-61; in the glossary of the 1963 technical report based on his dissertation about Sketchpad, Sutherland defined notions of "object" and "instance" (with the class concept covered by "master" or "definition"), albeit specialized to graphical interaction. Also, an MIT ALGOL version, AED-0, linked data structures ("plexes", in that dialect) directly with procedures, prefiguring what were later termed "messages", "methods" and "member functions".

156 whose record fields are called instance variables (Smalltalk) or member data

158 methods (Smalltalk) or member functions (C++) which are equivalent to a

165 A virtual member in statically typed languages is a base class member that can

168 [Stroustrup 90] covers the implementation details of virtual member functions

178 member function, instance variable

179 member data, subclass

203 parents (as any other member) can be added or changed dynamically, providing

245 mechanism with public, private and protected members. Public members (member

246 data and member functions) may be accessed from anywhere. A Stack's Push and

273 classes, visibility and member lookup resolution. This is a feature-based or

338 variables shared between all instances of a class (static member data in

390 Inheritance also provides for member lookup, or internal environment. Various

394 renaming for any parent member conflicts.

435 Yes, it does. Any name can be simply resolved to a class member with single

438 methods (at least one way, C++ hides some member functions). Since several

439 distinct parents can declare a member within a multiple inheritance hierarchy,

441 parent members that conflict. Self prioritizes parents. CLOS merges member

499 which is a member of (inherits from) a class is polymorphically assignment

518 the issues of shared bases and member conflict resolution. But most modern

540 any member to be redefined and not just methods, as is typical.

600 the method operates on. An exception exists with C++'s static member functions

1101 2.4) Is There A Difference Between Being A Member Or Instance Of A Class? (Typing - Object-Oriented Technology)

1105 other is called the complete object [Stroustrup 90]. An object is a member

1109 that object must be a member of the polymorphic object's class.

1111 oriented languages, since a member is defined as above in CLOS, but a member of

1561 end-user or vendor, can become a member of this body. Administrative

2186 SUITESOFTWARE is a member of various standards groups and conforms

p