197 Sharing and often instances will simply delegate to parents to access methods

235 Some languages permit arbitrary access to objects and allow methods to be

251 could be declared protected allowing subclass access. C++ also allows a

252 class to specify friends (other (sub)classes and functions), that can access

253 all members (its representation). Eiffel 3.0 allows exporting access to

262 is most common (e.g. Ada, C++, Eiffel), where class methods can access any

263 object of that class and not just the receiver. Methods can only access the

272 above, classes can also specify access permissions for clients and derived

597 can access the internal state of an object of that class to perform some

619 packages can be used to restrict access, as in CLOS). Multi-methods can also

662 Why do multi-methods allow open access to parameters? It allows efficient

665 alternative explanation. While open access can be useful in some cases, it

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

1563 3.8.3) Mail Server Access (OMG

1693 support for heterogeneous environments, support for Remote Data Access

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

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

2125 struggle to provide easy access to data while maintaining and

2138 and file systems; access and distribute data; guarantee system

2159 - and support for Remote Data Access (RDA), Remote Procedure

2203 authentication and access

2221 DOME Data Manager (DDMTM) database access manager.

2224 provides access to distributed data.

2230 to know the physical location of data, the server of access, or the

2239 Access Group's Call Level Interface standard, DDM can interoperate

polymorphic

670 Polymorphic languages can be statically typed to provide strong type checking,

910 stages, or the like. Also, polymorphic. [<Gk polymorphous multiform]

950 Polymorphic Languages: some values and variables may have more than one type.

951 Polymorphic Functions: functions whose operands (actual parameters) can

953 a value, it has many functional types and is therefore polymorphic.

954 Polymorphic Types: types whose operations are applicable to operands of more

956 Parametric Polymorphism: a polymorphic function has an implicit or explicit

967 fast running execution, but in a "true polymorphic system", only a single

1004 ("bounded quantification" by C+W. C+W's parameters are subtype polymorphic

1029 of an object can ever change. Only a reference can be polymorphic: ...".

1048 In C++, virtual functions provide polymorphism. This is because a polymorphic

1053 dynamically typed languages, polymorphic objects are passed messages and will

1058 for the polymorphic object; and hence, polymorphism. This common pure

1108 class, if a polymorphic object (or reference) is made to refer to an object,

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

1116 inherent types of polymorphic objects, keeping track of the types of objects at

1125 any common functions for the more general subtyping or parametric polymorphic

1136 polymorphic type system [Wikstrom 87]. Russell (see Appendix E) is a more

1167 (transitively) from any polymorphic object's class (inclusion polymorphism

1169 performed on any polymorphic object are satisfied by any replacing objects.

1174 satisfy the operations or type constraints of a polymorphic object (subtype

1212 polymorphic functions as found in languages such as Ada, C++, Eiffel, and

1220 a polymorphic sort function taking a base type with a comparison operator.

1230 parametrically polymorphic implementation. Generics can also be viewed as a

2378 works well in simple cases like strings where the data is not polymorphic

collection

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".

10 Objects as a formal concept in programming were introduced in the 1960s in Simula 67, a major revision of Simula I, a programming language designed for discrete event simulation, created by Ole-Johan Dahl and Kristen Nygaard of the Norwegian Computing Center in Oslo. Simula 67 was influenced by SIMSCRIPT and Hoare's proposed "record classes". Simula introduced the notion of classes and instances or objects (as well as subclasses, virtual methods, coroutines, and discrete event simulation) as part of an explicit programming paradigm. The language also used automatic garbage collection that had been invented earlier for the functional programming language Lisp. Simula was used for physical modeling, such as models to study and improve the movement of ships and their content through cargo ports. The ideas of Simula 67 influenced many later languages, including Smalltalk, derivatives of LISP (CLOS), Object Pascal, and C++.

276 objects (as opposed to a collection of objects, as with the more classical

769 evolutionary step beyond the first edition by incorporating a collection of the

2126 updating a collection of incompatible hardware platforms, operating

2276 3.9) Why is Garbage Collection A Good Thing? (Object-Oriented Technology)

2277 There are two entries on garbage collection, the first is an excellent entry

2279 company on the necessity of garbage collection for object-oriented programming

2282 Garbage collection (GC) is a facility in the run-time system associated with a

2284 OO Languages which require garbage collection include Eiffel, Smalltalk and

2285 CLOS. C and C++ can have garbage collection retrofitted (see [3] and [4]

2329 [2] "Uniprocessor Garbage Collection Techniques," by Paul R. Wilson,

2334 and other papers about garbage collection are available in PostScript via

2338 [3] "Garbage Collection in an Uncooperative Environment" by Boehm and

2349 3.9b) Why is Garbage Collection Necessary for Object-Oriented Programming? (Object-Oriented Technology)

2354 collection.

2368 collection has completely solved the above problems and made reference

2407 5. Garbage Collection Works

2409 has to show that garbage collection provides a better alternative. Early

2410 versions of garbage collection were merely crude implementations of

2411 mark-and-sweep that left much to be desired. However, garbage collection has

2414 collection for all or part of their memory. Even C and C++ have at least one

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

2425 and garbage collection is much too important a tool to be absent from any

development

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.

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.

55 Challenges of object-oriented design are addressed by several methodologies. Most common is known as the design patterns codified by Gamma et al.. More broadly, the term "design patterns" can be used to refer to any general, repeatable solution to a commonly occurring problem in software design. Some of these commonly occurring problems have implications and solutions particular to object-oriented development.

737 their development histories, knowledge captured from domain experts,

786 * It assumes a relatively uniform and orderly sequence of development steps

791 software development. [Boehm 86] presents a seminal spiral life-cycle model

796 [Coad 91b] presents the following development cycle breakdown:

816 gap between the phases as is often the case in other software development

831 software development and which is often required of government contractors

875 processing system and software products development as integrated components.

1432 Five Object Oriented Development Methods, Research report, HP Laboratories,

1471 Champeaux, D. de - Object-oriented system development, 1993.

1474 Coleman, D. - Object-oriented development, the Fusion method, 1994.

1508 (*) development of command models and a common interface for the development

1600 ongoing development of the Object Management Architecture are

1729 set of base classes to speed development, and a test script language.

1800 provide programmers with a rapid development environment for creating and

1816 -- easier development, with remote object browsing so

1828 customer input can be incorporated into the product early in its development

1888 DOME is non-intrusive, meaning that the application development

1905 - integral support for GUI development,

2082 2 v1.x. Development

2207 - Co-existence of multiple development and

eiffel

46 Languages called "pure" OO languages, because everything in them is treated consistently as an object, from primitives such as characters and punctuation, all the way up to whole classes, prototypes, blocks, modules, etc. They were designed specifically to facilitate, even enforce, OO methods. Examples: Scala, Smalltalk, Eiffel, JADE, Emerald.

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

155 expanded types in Eiffel) can be viewed as instances of a record type,

253 all members (its representation). Eiffel 3.0 allows exporting access to

262 is most common (e.g. Ada, C++, Eiffel), where class methods can access any

388 inheritance can also share parents within a class lattice (CLOS and Eiffel

393 a linear precedence list, Self provides parent priorities, and Eiffel forces

440 which to choose becomes an issue. Eiffel forces derived classes to rename

473 "features" in Eiffel (C++ members) of a repeated parent that are not to be

497 CLOS, Eiffel, etc.) based on inheritance when type and class are bound together

535 "frozen" features in Eiffel can be "redefined" in a derived class. Whenever

539 not have to be declared. Eiffel and BETA are examples of languages allowing

611 (e.g. C++ and Eiffel) is really in between (checked function pointers).

674 parameters but limiting base class usage (as in Eiffel). If these restrictions

681 and Eiffel). See section 2.3 for another example of multiple-polymorphism.

977 Ada95, C++, CLOS, Eiffel and etc. (subclass polymorphism). Smalltalk also

1025 instances of various classes. In a typed environment such as Eiffel, this is

1030 Meyer is clear between the concept and the Eiffel realization in his

1065 binding is found in languages such as C++ (virtual functions) and Eiffel

1132 also be found in recent versions of Eiffel.

1201 Signatures), Sather (originally Eiffel-based), and an Eiffel superset

1212 polymorphic functions as found in languages such as Ada, C++, Eiffel, and

1303 Eiffel

2284 OO Languages which require garbage collection include Eiffel, Smalltalk and

environment

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".

78 Joe Armstrong, the principal inventor of Erlang, is quoted as saying "The problem with object-oriented languages is they've got all this implicit environment that they carry around with them. You wanted a banana but what you got was a gorilla holding the banana and the entire jungle."

382 refer to other objects to respond to messages (environment) and do not

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

398 combinations of state and environment (sometimes with complex rules).

505 sliced replacement in a statically typed environment (see section 2.1).

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

749 (user-)environment). The product, or resultant model,

883 including classes, inheritance, a high-powered graphical environment and a

1025 instances of various classes. In a typed environment such as Eiffel, this is

1757 HP ORB Plus is the only environment that combines the complete CORBA 1.1

1766 The DCE (Distributed Computing Environment) standard provides an

1768 provide a distributed computing environment that's easy to administer. The

1786 "plug-and-play" object-oriented environment. This will give developers,

1800 provide programmers with a rapid development environment for creating and

1867 Product: DOME - Distributed Object Management Environment

1896 environment. This provides great flexibility since new classes

2133 distributed, heterogeneous environment, supplies the functions that

2143 SUITESOFTWARE's Distributed Object Management Environment (DOME)

2234 the application's logical view of the environment into the

2235 enterprise's physical environment of multiple nodes, disparate

2338 [3] "Garbage Collection in an Uncooperative Environment" by Boehm and

2477 environment?

2701 Test Environment Toolkit). To join the group of volunteers, send email to

features

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)

7 Objects can be thought of as wrapping their data within a set of functions designed to ensure that the data are used appropriately, and to assist in that use. The object's methods will typically include checks and safeguards that are specific to the types of data the object contains. An object can also offer simple-to-use, standardized methods for performing particular operations on its data, while concealing the specifics of how those tasks are accomplished. In this way alterations can be made to the internal structure or methods of an object without requiring that the rest of the program be modified. This approach can also be used to offer standardized methods across different types of objects. As an example, several different types of objects might offer print methods. Each type of object might implement that print method in a different way, reflecting the different kinds of data each contains, but all the different print methods might be called in the same standardized manner from elsewhere in the program. These features become especially useful when more than one programmer is contributing code to a project or when the goal is to reuse code between projects.

15 Object-oriented features have been added to many existing languages during that time, including Ada, BASIC, Fortran, Pas cal, and others. Adding these features to languages that were not initially designed for them often led to problems with compatibility and maintainability of code.

20 Benjamin C. Pierce and some other researchers view as futile any attempt to distill OOP to a minimal set of features. He nonetheless identifies fundamental features that support the OOP programming style in most object-oriented languages:

26 Similarly, in his 2003 book, Concepts in programming languages, John C. Mitchell identifies four main features: dynamic dispatch, abstraction, subtype polymorphism, and inheritance.Michael Lee Scott in Programming Language Pragmatics considers only encapsulation, inheritance and dynamic dispatch.[16]

40 records are basis for understanding objects if function literals can be stored in fields (like in functional programming languages), but the actual calculi need be considerably more complex to incorporate essential features of OOP. Several extensions of System F<: that deal with mutable objects have been studied;[18] these allow both subtype polymorphism and parametric polymorphism (generics)

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:

48 Languages that are historically procedural languages, but have been extended with some OO features. Examples: Visual Basic (derived from BASIC), Fortran 2003, Perl, COBOL 2002, PHP, ABAP.

49 Languages with most of the features of objects (classes, methods, inheritance, reusability), but in a distinctly original form. Examples: Oberon (Oberon-1 or Oberon-2) and Common Lisp.

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.

52 In recent years, object-oriented programming has become especially popular in dynamic programming languages. Python, Ruby and Groovy are dynamic languages built on OOP principles, while Perl and PHP have been adding object oriented features since Perl 5 and PHP 4, and ColdFusion since version 5.

63 Both object-oriented programming and relational database management systems (RDBMSs) are extremely common in software today. Since relational databases don't store objects directly (though some RDBMSs have object-oriented features to approximate this), there is a general need to bridge the two worlds. The problem of bridging object-oriented programming accesses and data patterns with relational databases is known as Object-Relational impedance mismatch. There are a number of approaches to cope with this problem, but no general solution without downsides.[20] One of the most common approaches is object-relational mapping, as found in libraries like Java Data Objects and Ruby on Rails' ActiveRecord.

389 provide this as a default at the level of slots and features, respectively).

473 "features" in Eiffel (C++ members) of a repeated parent that are not to be

476 resolution but requires more work for parents with many features.

535 "frozen" features in Eiffel can be "redefined" in a derived class. Whenever

770 best features from several of the major OO methodologies, as does HP's new

1596 Technology topics and issues. This publication features

1809 New HP Distributed Smalltalk 2.0 features include the following:

1821 repository. In addition to these OMG-specific features, most developers

2225 Features

2657 features for C++ testing. From the product literature:

instances

10 Objects as a formal concept in programming were introduced in the 1960s in Simula 67, a major revision of Simula I, a programming language designed for discrete event simulation, created by Ole-Johan Dahl and Kristen Nygaard of the Norwegian Computing Center in Oslo. Simula 67 was influenced by SIMSCRIPT and Hoare's proposed "record classes". Simula introduced the notion of classes and instances or objects (as well as subclasses, virtual methods, coroutines, and discrete event simulation) as part of an explicit programming paradigm. The language also used automatic garbage collection that had been invented earlier for the functional programming language Lisp. Simula was used for physical modeling, such as models to study and improve the movement of ships and their content through cargo ports. The ideas of Simula 67 influenced many later languages, including Smalltalk, derivatives of LISP (CLOS), Object Pascal, and C++.

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.

29 Instances of classes

104 * all of the real-world things in the set - the instances - have the same

106 * all instances are subject to and conform to the same rules"

155 expanded types in Eiffel) can be viewed as instances of a record type,

197 sharing and often instances will simply delegate to parents to access methods

207 prototype for newly created instances. [The Author also uses the term for

287 The intension of a class is its semantics and its extension is its instances

300 dictionaries for methods, instances, and parents and methods to perform all

303 returning a set of all methods, instances or parents for review (or even

314 All Objects are instances of a Class but Classes are not accessible to

319 All objects are instances of a class and all classes are instances of

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

500 compatible with (can be used in place of) instances or references of that

580 In C++ no, because C++ classes are not instances of an accessible class (a

582 are objects in 3 Level Systems and above because classes are instances of

584 declared to be instances of a class (and class objects instances of a

587 In a Level 3 System and above yes, but only instances of a Meta-Class are

588 Classes. Instances of a Class (ordinary objects) are not classes (excluding

740 localized around objects, e.g., classes, instances, systems of interacting

1025 instances of various classes. In a typed environment such as Eiffel, this is

definition

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".

36 abstract data types (which have existential types) allow the definition of modules but these do not support dynamic dispatch

41 Attempts to find a consensus definition or theory behind objects have not proven very successful (however, see Abadi & Cardelli, A Theory of Objects[18] for formal definitions of many OOP concepts and constructs), and often diverge widely. For example, some definitions focus on mental activities, and some on program structuring. One of the simpler definitions is that OOP is the act of using "map" data structures or arrays that can contain functions and pointers to other maps, all with some syntactic and scoping sugar on top. Inheritance can be performed by cloning the maps (sometimes called "prototyping"). OBJECT:=>> Objects are the run time entities in an object-oriented system. They may represent a person, a place, a bank account, a table of data or any item that the program has to handle.

75 Christopher J. Date stated that critical comparison of OOP to other technologies, relational in particular, is difficult because of lack of an agreed-upon and rigorous definition of OOP. Date and Darwen propose a theoretical foundation on OOP that uses OOP as a kind of customizable type system to support RDBMS.

86 object are interchangeable". This is a "classical languages" definition, as

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

152 another semantic definition of OO using functions for methods and for

274 intensional definition, emphasizing a class as a descriptor

284 [Booch's definition in the context of OOD]

396 definition, or both) can avoid confusion about which inheritance scheme is

563 A more modern definition of "object-oriented" includes single-hierarchy

911 > Author's Definition:

929 > Strachey's Original Definition [Strachey 67]:

937 2.1) What Is Polymorphism? Cardelli and Wegner's Definition [Cardelli 85]:

938 C+W refine Strachey's definition by adding "inclusion polymorphism" to model

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

1020 [The author notes Booch's definition above is clearly in the context of

1022 > Meyer's Definition [Meyer 88, sect. 10.1.5 Polymorphism]:

1031 polymorphism definition above, but here neglects the "becomes" facility

1035 > Stroustrup's Definition [Stroustrup 90, p. 209]:

1044 Rumbaugh's Definition [Rumbaugh 91, p. 2]:

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

1173 from type, by the aforementioned definition of type), a replacing object must

list

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.

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".

44 See also: List of object-oriented programming languages

72 A number of well-known researchers and programmers have analysed the utility of OOP. Here is an incomplete list:

131 **There is a patterns mailing list, email: patterns-request@cs.uiuc.edu,

248 a class. A Stack's representation, such as a list or array, will usually be

393 a linear precedence list, Self provides parent priorities, and Eiffel forces

867 the CMM. To join the ami mailing list email to:

1246 list instead of a parent list. Thus, delegation's primary emphasis is

1249 object can be added to the delegate list, giving dynamic inheritance (of a

1362 Here are some abstracts taken from several postings to the net. This list is

1398 Here is a list of OOSE Methodologies:

1571 index (return a list of all available files)

1575 list <directory> [match] (index a directory, pattern 'match' files)

1577 list mail

1578 list docs

1588 list

1589 list mail

1590 list docs

1625 ftp! These are from the list of literature and periodicals listed in

1704 The OMG also has a (Corporate) Membership list and "known CORBA supporters"

1705 list with their info package.

clos

10 Objects as a formal concept in programming were introduced in the 1960s in Simula 67, a major revision of Simula I, a programming language designed for discrete event simulation, created by Ole-Johan Dahl and Kristen Nygaard of the Norwegian Computing Center in Oslo. Simula 67 was influenced by SIMSCRIPT and Hoare's proposed "record classes". Simula introduced the notion of classes and instances or objects (as well as subclasses, virtual methods, coroutines, and discrete event simulation) as part of an explicit programming paradigm. The language also used automatic garbage collection that had been invented earlier for the functional programming language Lisp. Simula was used for physical modeling, such as models to study and improve the movement of ships and their content through cargo ports. The ideas of Simula 67 influenced many later languages, including Smalltalk, derivatives of LISP (CLOS), Object Pascal, and C++.

12 In the 1970s, Kay's Smalltalk work had influenced the Lisp community to incorporate object- based techniques that were introduced to developers via the Lisp machine. Experimentation with various extensions to Lisp (like LOOPS and Flavors introducing multiple inheritance and mixins), eventually led to the Common Lisp Object System (CLOS, a part of the first standardized object-oriented programming language, ANSI Common Lisp), which integrates functional programming and object-oriented programming and allows extension via a Meta- object protocol. In the 1980s, there were a few attempts to design processor architectures that included hardware support for objects in memory but these were not successful. Examples include the Intel iAPX 432 and the Linn Smart Rekursiv.

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

239 outside of a class, providing functions and procedures. While both CLOS

350 Meta-Classes accessible to users [Kiczales 92, Paepcke 93]. In CLOS

386 Objective-C, etc.), lisp-based (CLOS, Flavors, Scheme, etc.), and Pascal-based

388 inheritance can also share parents within a class lattice (CLOS and Eiffel

392 causes an ambiguity error iff more than one parent has match, CLOS creates

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

458 or change parents from objects (or classes) at run-time. Actors, CLOS, and

468 then appear in the graph (as is always the case in CLOS, because all *members*

497 CLOS, Eiffel, etc.) based on inheritance when type and class are bound together

619 packages can be used to restrict access, as in CLOS). Multi-methods can also

620 imply a functional prefix notation, although the CLOS designers (who coined the

687 But coupling the two cases of selector variables (as found in CLOS,

977 Ada95, C++, CLOS, Eiffel and etc. (subclass polymorphism). Smalltalk also

1000 assignment is based on actual object membership in that type (often of the CLOS

1032 as found in several dynamically typed OO languages such as Actors, CLOS,

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

1264 CLOS [Kim 89, ch 4] has a looser coupling of methods to classes and doesn't

1302 CLOS

2285 CLOS. C and C++ can have garbage collection retrofitted (see [3] and [4]

databases

63 Both object-oriented programming and relational database management systems (RDBMSs) are extremely common in software today. Since relational databases don't store objects directly (though some RDBMSs have object-oriented features to approximate this), there is a general need to bridge the two worlds. The problem of bridging object-oriented programming accesses and data patterns with relational databases is known as Object-Relational impedance mismatch. There are a number of approaches to cope with this problem, but no general solution without downsides.[20] One of the most common approaches is object-relational mapping, as found in libraries like Java Data Objects and Ruby on Rails' ActiveRecord.

64 There are also object databases that can be used to replace RDBMSs, but these have not been as technically and commercially successful as RDBMSs.

137 oriented databases and operating systems (object id's). A "proxy" based

1078 and even required in many applications including databases, distributed

1312 3.5) What Are Object-Oriented Databases And Persistence?

1315 Object-Oriented Databases are databases that support objects and classes. They

1316 are different from the more traditional relational databases because they allow

1324 Another way of looking at Object-Oriented Databases is as a persistent object

1334 relational databases and see APPENDIX E, Papers, Persistent Operating Systems.

1513 object-oriented languages, systems, databases and application

1552 1) Object Oriented Databases;

1802 databases (currently OpenODB from HP and Gemstone from Servio) as their

1946 traditional flat file databases, relational databases or object oriented

1947 databases.

2042 - wrapping existing databases and legacy

2063 files, relational or object databases

2127 systems, applications, databases, network protocols, and the like.

2137 differences between operating systems, network protocols, databases,

2237 DDM can manipulate data across a large number of databases and data