220 Parents when certain predicates are true. This can support a types

610 if done dynamically (true dynamic binding). Statically typed dynamic binding

636 also the true essence of object-oriented polymorphism, which allows objects to

652 inherent (true, actual, or dynamic) types of one and two. Only the inherent

935 Parametric polymorphism is also referred to as "true" polymorphism, whereas

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

1143 parametric polymorphism, so no inheritance is required. This is "true" or

1154 in OO. Parametric polymorphism is a related concept where this is also true,

1229 dependencies and expand code size (unlike a single-body or "true"

2191 - True messaging for workflow management and EDI

2198 - Hierarchical namespace with true domains for complete

2201 - Logical name translation for true aliasing

2353 There are several reasons why true object-oriented programming requires garbage

2369 counting an inadequate substitute for true GC.

typed

148 In more conventional languages to fully emulate this style of dynamically typed

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

175 Virtual members in dynamically typed languages are more flexible because

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

610 if done dynamically (true dynamic binding). Statically typed dynamic binding

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

692 strongly typed

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

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

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

1059 statically typed example is, of course, an example of inclusion polymorphism,

1061 typed subtype polymorphism, as provided in Emerald, can be implemented

1117 run-time. Statically typed dynamic binding is a compromise (usually

1135 ML, Metalanguage, is a functional programming language with a strongly typed

view

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:

73 Luca Cardelli wrote a paper titled "Bad Engineering Properties of Object-Oriented Languages" Richard Stallman wrote in 1995, "Adding OOP to Emacs is not clearly an improvement; I used OOP when working on the Lisp Machine window systems, and I disagree with the usual view that it is a superior way to program."

153 a view of types as sets of values.

222 as collections of objects view, which is the same as the types as sets of

223 values view taken by [Cardelli 85]. [Martin 92] provides some examples of

224 this view applied during OOA.

277 extensional view, which may begin the analysis process).

983 in the subtype (subtype is subset of supertype). Cardelli and Wegner view

985 supertype objects, or an extensional view), as contrasted with a feature based

988 extensional view and set union with an intensional view. Details are left as

1040 [The Author notes this is a functional view of polymorphism (as provided in

1381 Mountain View, CA USA 94043

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

attributes

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

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

281 "a group, set, or kind marked by common attributes or a common attribute; a

400 specify required attributes of a matching object (see sections 2.1, 2.7 and

428 additional attributes or properties to other classes. They are intended to be

453 classes provide properties and attributes for objects, changing base classes

454 changes the properties and attributes of a class. A previous example was a

485 available to all subclasses throughout the diagram. All attributes available

552 - Types may inherit attributes from supertypes.

915 and these more specific or additional attributes of an object of a base class

1155 but is of a different flavor (and usually requires object attributes by use.

1951 informed of the functions, attributes and characteristics of objects and

classical

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

189 flexible kind of object which can play the role of classes in classical OO

193 classical object-oriented languages associate method, field and parent

202 thus performing the classical role of a class. In typical prototyping systems,

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

290 design: classical categorization (common properties), conceptual clustering

298 must have a class (in classical OO anyway). Compilers provide an easy way to

406 instantiation relationship. In classical OO, inheritance is a relationship

448 several classes. In classical systems without MI, a class which should inherit

1021 conventional, classical OO and subclass polymorphism.]

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

1236 3.1) What Is The "Classical" Object-Oriented Paradigm?

1267 delegation and classical systems, where parent classes have an extra level

jacobson

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

113 driven design. Jacobson also calls for managing complexity with specialized

114 object categories [Jacobson 94]:

127 Unrelated to Ivar Jacobson but relevant to the topic:

752 model (e.g. FUSION, Jacobson), scenarios (Rumbaugh), or use-cases (Jacobson).

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

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

872 found in [Jacobson 92], and along with recent business process "reengineering"

1411 Jacobson [Jacobson 92]

1466 Hood, Coad and Yourdon, Winter Partners, Shlaer and Mellor, Jacobson,

1478 Jacobson, I. - Object-oriented software engineering, 1993.

methodology

13 Object-oriented programming developed as the dominant programming methodology in the early and mid 1990s when programming languages supporting the techniques became widely available. These included Visual FoxPro 3.0, C++[citation needed], and Delphi[citation needed]. Its dominance was further enhanced by the rising popularity of graphical user interfaces, which rely heavily upon object-oriented programming techniques. An example of a closely related dynamic GUI library and OOP language can be found in the Cocoa frameworks on Mac OS X, written in Objective-C, an object-oriented, dynamic messaging extension to C based on Smalltalk. OOP toolkits also enhanced the popularity of event-driven programming (although this concept is not limited to OOP). Some[who?] feel that association with GUIs (real or perceived) was what propelled OOP into the programming mainstream.

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

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.

82 Carnegie-Mellon University Professor Robert Harper in March 2011 wrote: "This semester Dan Licata and I are co-teaching a new course on functional programming for first-year prospective CS majors... Object-oriented programming is eliminated entirely from the introductory curriculum, because it is both anti-modular and anti-parallel by its very nature, and hence unsuitable for a modern CS curriculum. A proposed new course on object- oriented design methodology will be offered at the sophomore level for those students who wish to study this topic."

241 methodology clearly specifies class-like encapsulation (Adts).

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

771 FUSION methodology.

1475 Henderson-Sellers, B. and Edwards, J.M. - Methodology for Object-oriented

1510 processing) using object-oriented methodology.

1605 a methodology that supports modular production of software;

2029 architecture and methodology for creating

2558 Murphy, G.C., Wong, P. 1992, Towards a Testing Methodology for

2563 Murphy, G. and P. Wong. Object-Oriented Systems Testing Methodology: An

modeling

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

17 Just as procedural programming led to refinements of techniques such as structured programming, modern object-oriented software design methods include refinements[citation needed] such as the use of design patterns, design by contract, and modeling languages (such as UML).

368 for the commonality of objects to be explicitly taken advantage of in modeling

747 expert's perspective and with an emphasis on modeling the real-world (the

756 information modeling and recursive design, or OOA

772 A new Unified Modeling Language (previously Unified Method) is now being worked

871 Object-oriented analysis now includes "Enterprise Modeling" [Martin 92], also

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

876 [Yourdon 92] even calls for "global modeling"!

889 Reuse, quality, an emphasis on modeling the real world (or a "stronger

1482 Rumbaugh, J. et.al. - Object-oriented modeling and design, 1991.

1483 Shlaer, S., Mellor, S.J. - Object-oriented systems analysis: Modeling the

1526 the logical modeling and physical storage of objects; and

net

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

47 Languages designed mainly for OO programming, but with some procedural elements. Examples: C++, C#, VB.NET, Java, Python.

54 ECMAScript language. JavaScript is perhaps the best known prototype- based programming language, which employs cloning from prototypes rather than inheriting from a class. Another scripting language that takes this approach is Lua. Earlier versions of ActionScript (a partial superset of the ECMA-262 R3, otherwise known as ECMAScript) also used a prototype-based object model. Later versions of ActionScript incorporate a combination of classification and prototype-based object models based largely on the currently incomplete ECMA-262 R4 specification, which has its roots in an early JavaScript 2 Proposal. Microsoft's JScript.NET also includes a mash-up of object models based on the same proposal, and is also a superset of the ECMA-262 R3 specification.

1335 From the net:

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

1430 Here are some comparison studies posted to the net:

1583 Recommended (from the net):

1624 [Here's why you don't see the specifications posted to the net or available via

2443 Programming that have been mentioned to me over the net, in email,

patterns

17 Just as procedural programming led to refinements of techniques such as structured programming, modern object-oriented software design methods include refinements[citation needed] such as the use of design patterns, design by contract, and modeling languages (such as UML).

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.

57 Design Patterns: Elements of Reusable Object-Oriented Software is an influential book published in 1995 by Erich Gamma, Richard Helm, Ralph Johnson, and John Vlissides, sometimes casually called the "Gang of Four". Along with exploring the capabilities and pitfalls of object-oriented programming, it describes 23 common programming problems and patterns for solving them. As of April 2007, the book was in its 36th printing.

58 The book describes the following patterns:

59 Creational patterns : Factory method pattern, Abstract factory pattern, Singleton pattern, Builder pattern, Prototype pattern

60 Structural patterns : Adapter pattern, Bridge pattern, Composite pattern, Decorator pattern, Facade pattern, Flyweight pattern, Proxy pattern

61 Behavioral patterns : Chain-of-responsibility pattern, Command pattern, Interpreter pattern, Iterator pattern, Mediator pattern, Memento pattern, Observer pattern, State pattern, Strategy pattern, Template method pattern, Visitor pattern.

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.

119 Patterns** (Typical) - Framework-like, crsp. classes and comm patterns only

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

pub

850 pub

1626 omg.org:pub

1672 pub

1718 ftp.ifi.unizh.ch: pub

2335 anonymous ftp (cs.utexas.edu:pub

2343 pub

2580 pub

2602 pub

2614 pub

2625 pub

2636 pub

2652 pub

2705 pub

report

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

1281 , Java Report & Conf:

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

1449 A Comparison of Six Object-oriented Analysis and Design Methods. Report

1486 We are currently approaching publishers for the publication of this report

2270 "Distributed Object Computing With CORBA", C++ Report, July

2528 The Smalltalk Report, Vol. 1, No. 9, pp.3-7. The author's

2564 Overview. Techical Report TR92-0656, MPR Teltech Ltd., October

2594 Technical Report TR-13

2606 Testing of Object-Oriented Programs", Technical Report

2618 Oriented Programs", Technical Report TR-2

2629 Technical Report TR-1

2640 Report TR92-0655, MPR Teltech Ltd., September 1992.

shared

198 or shared state, otherwise idiosyncratic objects, a powerful and natural

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

464 1.11) What Is Shared (Repeated) Inheritance? (Object-Oriented Technology)

469 with the same name will be shared (receive a single slot) with the greatest

471 specified as virtual (virtual bases) are shared within the same class lattice,

472 allowing both shared and non-shared occurrences of a parent to coexist. All

474 shared must be renamed "along an inheritance path", else they are shared by

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

591 act as a shared parent).

1603 The members of the OMG have a shared goal of developing and using

2087 architectures as a set of DLL and shared libraries

2399 support long-lived data and keep track of ownership of data shared by

specific

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

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.

126 Impl. Hiding - Distr. Arch., specific DBMS, OS

254 specific classes.

637 define methods for each specific case desired. In addition to better coupling

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

725 "An investigation of a specific application area that seeks to identify the

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

915 and these more specific or additional attributes of an object of a base class

1060 subclass polymorphism to be more specific (see section 2.1). Pure statically

1093 This removes the spread of knowledge of specific classes throughout a system,

2227 supplies the means for consolidating data for specific applications.

2645 specific classes that test non-interactive objects such as trees,

tools

1775 tools, and sample applications. HP's DOMF provides a location-transparent

2074 - Network Configuration Tools - simplifies creation of

2240 with any number of third-party GUI and CASE tools. Among the GUIs are

2241 Powerbuilder,, Visual Basic,, and Uniface,. Among the CASE tools are

2424 manual management to provide the programmer with the broadest set of tools,

2504 of 11th. TOOLS USA Conference, Santa Barbara, Aug 1993, pp 407-426.

2505 Frankl, Phyllis G. and Roong-Ko Doong, "Tools for Testing

2570 Purchase, Jan A. and Russel L. Winder, "Debugging tools for

2605 Turner, C. D. and D. J. Robson, "A Suite of Tools for the State-Based

2610 England. Describes a series of tools for the generation and

2611 execution of test cases for OOP. These tools assume a

2615 papers. Get "tools.ps.Z" for A4 paper formatting or get

2687 *Integration with leading programming tools for maximum productivity gains

typically

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.

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.

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

136 do the capability-based approaches which are typically found in object-

204 dynamic multiple inheritance (or more typically simple delegation). Here, the

217 also typically specifies non-shared state when used for representation.

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

666 typically isn't recommended as a general OO practice (see section 1.15, C+W's

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

1232 Functions are typically generic in statically-typed parametrically-polymorphic

1250 sort). Typically, delegation and prototyping languages also have "part

1359 be passed freely between machines. They are typically capability-based since

2364 performance than GC, awkward syntax, and poor semantics, which typically

uk

1868 Company: Enquiries: info@oot.co.uk

2281 From: Paul Johnson (paj@gec-mrc.co.uk)

2512 jgraham@axion.bt.co.uk.

2578 available by anonymous ftp from vega.dur.ac.uk as

2601 This paper is available by anonymous ftp from vega.dur.ac.uk in

2613 This paper is available by anonymous ftp from vega.dur.ac.uk in

2624 This paper is available by anonymous ftp from vega.dur.ac.uk in

2635 This paper is available by anonymous ftp from vega.dur.ac.uk in

2655 IPL Ltd. (in the UK) has a testing tool called Cantata which allows for

2672 UK

2675 email: shaun@iplbath.demon.co.uk

2702 etet_support@uel.co.uk

2703 The software is available via anonymous FTP from bright.ecs.soton.ac.uk

actual

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)

648 the actual classes of objects present:

652 inherent (true, actual, or dynamic) types of one and two. Only the inherent

680 actual argument differentiation is possible without dynamic types (as in C++

718 behavior and adding details needed for actual computer system implementation,

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

991 Ada may infer some actual generic parameters (operations) and C++ doesn't

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

1070 all such functions are resolved (statically) for actual objects. Formal object

1072 vtables of function pointers in the actual objects (C++) or equivalent,

1087 selected based on the actual type of object being cut (which in the GUI case is

1182 calling for careful matching of actual and formal generic parameters. The

database

62 Main articles: Object-Relational impedance mismatch, Object-relational mapping, and Object database

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.

1313 See also Appendices B and E and the comp.database.object newsgroup.

1320 object-oriented database. OODBs allow all the benefits of object-orientation,

1323 with a purely relational database.

1339 The Object Database Management Group (ODMG) has set up Gopher and Web

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

1727 exercising objects, a bundled object database for persistent object

1899 Database distribution can be as simple persistent files,

2221 DOME Data Manager (DDMTM) database access manager.

2232 perspective, the enterprise is a single logical database located in

2272 The Object Database Standard: ODMG-93

formal

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

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.

607 although keywords (or formal parameter names, like named parameters) are

677 class differentiated only by their formal argument types. This therefore

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

992 require explicit instantiation of its template functions, formal generic

1070 all such functions are resolved (statically) for actual objects. Formal object

1126 cases) to be available on formal objects and a lack of multiple-polymorphism

1182 calling for careful matching of actual and formal generic parameters. The

1197 The formal type system found in [Cardelli 85], Emerald

1206 See also [Cook 90], "Inheritance Is Not Subtyping", for a formal approach.

1454 S. Hong, G. van den Goor, S. Brinkkemper, A Formal Approach to the

generics

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)

965 Parametric polymorphism is referred to as generics. Generics can be syntactic,

990 Ada generics and C++ templates provide explicit syntactic generics. While

1180 (generics

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

1210 Generics (or Templates in C++) refer to the ability to parameterize types

1214 Generics are orthogonal to inheritance, since types (and classes)

1215 may be generically parameterized. Generics provide for reusability in

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

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

including

3 "Objects" are the foundation of object-oriented programming, and are fundamental data types in object-oriented programming languages. These languages provide extensive syntactic and semantic support for object handling, including a hierarchical type system, special notation for declaring and calling methods, and facilities for hiding selected fields from client programmers. However, objects and object-oriented programming can be implemented in any language.

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

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.

719 including human interaction, task management, and data management details."

760 work. Many other methodologies including Rumbaugh's OMT, Martin and Odell's

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

1078 and even required in many applications including databases, distributed

1106 of several classes, including all of the classes its declared (or most derived)

1874 and networks, including:

2078 including HP-UX, Sun Solaris, NCR 3000 UNIX and NCR

2395 a) Doubly specified empty and remove methods with one including a memory

2663 dynamic testing, including: functional testing, structural

interfaces

13 Object-oriented programming developed as the dominant programming methodology in the early and mid 1990s when programming languages supporting the techniques became widely available. These included Visual FoxPro 3.0, C++[citation needed], and Delphi[citation needed]. Its dominance was further enhanced by the rising popularity of graphical user interfaces, which rely heavily upon object-oriented programming techniques. An example of a closely related dynamic GUI library and OOP language can be found in the Cocoa frameworks on Mac OS X, written in Objective-C, an object-oriented, dynamic messaging extension to C based on Smalltalk. OOP toolkits also enhanced the popularity of event-driven programming (although this concept is not limited to OOP). Some[who?] feel that association with GUIs (real or perceived) was what propelled OOP into the programming mainstream.

1333 Appendix B also contains references for object-oriented interfaces to

1371 Ouverture Project (ESPRIT funded OMG IDL defines inter-module interfaces)

1529 compliant class interfaces.

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

1546 software interfaces; products which offer these interfaces continue to be

1823 interfaces to use objects effectively. So developers don't need to create

1824 their own, HP has supplied several object-service interfaces for developers

1825 to use. That's why HP ORB Plus includes OMG interfaces and implementations

1855 Toolkit(tm). RDOM provides interfaces from Smalltalk (Parcplace),

1860 the Smalltalk and Objective-C language interfaces is expected in June.

iona

1675 > IONA Technologies, Dublin Orbix, info@iona.ie

1931 Iona Technologies Ltd.

1943 With Orbix Version 1.2 IONA has added the ability to dynamically load objects

1953 In version 1.2 IONA has also extended the whole approach to filtering of

1956 built using Orbix. IONA has also extensively extended the number, and scope, of

1959 IONA released Orbix for SunSoft Solaris and SunOS at the Object World

1963 UX. IONA demonstrated a version of Orbix for Microsoft Windows 3.1 at

1965 3.1 is now in beta. In January 1994, IONA and SunSoft Inc. signed an

1973 Iona Technologies Ltd., fax: +353-1-6686573

1974 8-34 Percy Place, email: pth@iona.ie

2004 Documents Available from IONA

lisp

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

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.

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.

73 Luca Cardelli wrote a paper titled "Bad Engineering Properties of Object-Oriented Languages" Richard Stallman wrote in 1995, "Adding OOP to Emacs is not clearly an improvement; I used OOP when working on the Lisp Machine window systems, and I disagree with the usual view that it is a superior way to program."

623 number of new mechanisms added to COMMON LISP" [Kim ch 4, p70 (D. Moon)].

messages

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

11 The Smalltalk language, which was developed at Xerox PARC (by Alan Kay and others) in the 1970s, introduced the term object-oriented programming to represent the pervasive use of objects and messages as the basis for computation. Smalltalk creators were influenced by the ideas introduced in Simula 67, but Smalltalk was designed to be a fully dynamic system in which classes could be created and modified dynamically rather than statically as in Simula 67.[9] Smalltalk and with it OOP were introduced to a wider audience by the August 1981 issue of Byte Magazine.

336 The "class class"es handle messages to classes, such as constructors and

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

558 + Communication with messages

622 (messages) equivalent. Functional syntax was chosen "in order to minimize the

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

1520 handling distribution of messages between application objects in

1813 sending and receiving of remote messages, and reusable

2384 oriented paradigm of objects sending messages to each other (possibly from

papers

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

1364 Apertos (Meta-Object-based Mikro-Kernel. See Appendix E, Papers:28)

1365 Chorus Micro-kernel (written in C++, COOL, See Appendix E, Papers:63)

1366 Choices (research OS, UofI, C++, supports SVR4, See Appendix E, Papers)

1376 For the Spring Papers (free), Contact:

1382 See also APPENDIX E, PAPERS, Persistent Operating Systems entry.

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

2581 papers

2603 papers. Get "toop.ps.Z" for A4 paper and "toopus.ps.Z" for

2615 papers. Get "tools.ps.Z" for A4 paper formatting or get

2626 papers. Get "guide.ps.Z" for A4 paper formatting or get

2637 papers. Get toopinht.ps.Z" for A4 paper formatting or get

parameters

538 is a combination of overloading and multiple-polymorphism because parameters do

607 although keywords (or formal parameter names, like named parameters) are

644 ignoring the inherent type of parameters in messaging. Double dispatch is

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

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

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

991 Ada may infer some actual generic parameters (operations) and C++ doesn't

993 parameters must still be declared and many bodies are generated.

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

1082 operation (along with parameters) to any object on the desktop, each of which

1147 types during assignment (and hence for parameters) and therefore provides

1182 calling for careful matching of actual and formal generic parameters. The

refers

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)

33 Decoupling refers to careful controls that separate code modules from particular use cases, which increases code re-usability. A common use of decoupling in OOP is to polymorphically decouple the encapsulation (see Bridge pattern and Adapter pattern) - for example, using a method interface which an encapsulated object must satisfy, as opposed to using the object's class.

205 term "Prototype" usually refers to prototype theory, a recent theory of

214 differences are significant too:-) Delegation refers to delegating the

457 More specifically, dynamic inheritance refers to the ability to add, delete,

542 Object-Based Programming usually refers to objects without inheritance

925 many different forms. Computer Science refers to Strachey's original

1024 programming, this refers to the ability of an entity to refer at run-time to

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

1237 This refers to the usual class and object model. Its any 2+ level system

1242 This is the 1 Level System as Described under Meta-Classes. Delegation refers

1254 delegation languages usually refers to objects serving as prototypes for

science

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)

925 many different forms. Computer Science refers to Strachey's original

1839 business, engineering, science, medicine and education in approximately 110

2332 eds.), Springer Verlag Lecture Notes in Computer Science #637.

2496 Science Conference, ACM, Inc., New York, NY, 1990, pp. 161-165.

2595 92, Computer Science Division, School of

2608 92, Computer Science Division, School of Engineering and

2609 Computer Science (SECS), University of Durham, Durham,

2619 93, Computer Science

2620 Division, School of Engineering and Computer Science (SECS),

2630 93, Computer Science Division, School of

2631 Engineering and Computer Science (SECS), University of Durham,

subtyping

56 It is intuitive to assume that inheritance creates a semantic "is a" relationship, and thus to infer that objects instantiated from subclasses can always be safely used instead of those instantiated from the superclass. This intuition is unfortunately false in most OOP languages, in particular in all those that allow mutable objects. Subtype polymorphism as enforced by the type checker in OOP languages (with mutable objects) cannot guarantee behavioral subtyping in any context. Behavioral subtyping is undecidable in general, so it cannot be implemented by a program (compiler). Class or object hierarchies need to be carefully designed considering possible incorrect uses that cannot be detected syntactically. This issue is known as the Liskov substitution principle.

264 receiver in per-object protection. This supports a subtyping model, as any

928 adding inclusion polymorphism for subtyping and inheritance.

970 "Subtyping on record types corresponds to the concept of inheritance

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

994 Inclusion polymorphism can refer to subtyping, or having at least as much or

1003 however, inclusion is with respect to subtyping only with abstract types

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

1184 subtyping seems similar. A possible loss of semantic integrity

1194 also specify representation. Subtyping is therefore most useful to avoid

1206 See also [Cook 90], "Inheritance Is Not Subtyping", for a formal approach.

techniques

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)

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.

13 Object-oriented programming developed as the dominant programming methodology in the early and mid 1990s when programming languages supporting the techniques became widely available. These included Visual FoxPro 3.0, C++[citation needed], and Delphi[citation needed]. Its dominance was further enhanced by the rising popularity of graphical user interfaces, which rely heavily upon object-oriented programming techniques. An example of a closely related dynamic GUI library and OOP language can be found in the Cocoa frameworks on Mac OS X, written in Objective-C, an object-oriented, dynamic messaging extension to C based on Smalltalk. OOP toolkits also enhanced the popularity of event-driven programming (although this concept is not limited to OOP). Some[who?] feel that association with GUIs (real or perceived) was what propelled OOP into the programming mainstream.

17 Just as procedural programming led to refinements of techniques such as structured programming, modern object-oriented software design methods include refinements[citation needed] such as the use of design patterns, design by contract, and modeling languages (such as UML).

77 Paul Graham has suggested that the purpose of OOP is to act as a "herding mechanism" that keeps mediocre programmers in mediocre organizations from "doing too much damage". This is at the expense of slowing down productive programmers who know how to use more powerful and more compact techniques.

754 adds OO techniques to the traditional structured analysis principles of Yourdon

766 "structured" techniques, with greater emphasis on objects. OOram [Reenskaug

1421 Further Ideas And Techniques:

1517 techniques. To fill out this reference model, four areas of

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

2489 Bezier, Boris, "Software Testing Techniques", 2nd edition, Van Nostrand

toolkit

1678 (1) C++ ORB toolkit consisting of over 300 C++ classes and runtime libraries

1679 (2) CORBA 1.1 toolkit

1699 The ELECTRA Toolkit (not finished)

1703 CORBA Implementation Descriptions: The ELECTRA Toolkit

1707 The ELECTRA Toolkit

1713 Its a toolkit for building failure resilient, distributed applications

1715 etc. Electra is based on the HORUS toolkit (which is "the new ISIS

1855 Toolkit(tm). RDOM provides interfaces from Smalltalk (Parcplace),

1884 DOME is an ORB toolkit for the production of user-configured

2039 (1) C++ ORB toolkit consisting of over 300 C++ classes and

2041 (2) CORBA 1.1 toolkit Both are for:

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

address

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.

785 * It does not adequately address changes

789 Modern OO methodologies directly address these points and emphasize the

870 subscribe firstname, lastname, e-mail address.

1574 address <e-mail address) (use this address instead of sender)

2100 Address -- Software Products Division-Columbia

2511 J. Vol 11, No 3. One author's email address is

2529 email address is "ac690@cleveland.freenet.edu".

2708 other FTP sites - sned email to the above address if you can provide

author

79 Richard Mansfield, author and former editor of COMPUTE! magazine, states that "like countless other intellectual fads over the years ("relevance", communism, "modernism", and so on—history is littered with them), OOP will be with us until eventually reality asserts itself. But considering how OOP currently pervades both universities and workplaces, OOP may well prove to be a durable delusion. Entire generations of indoctrinated programmers continue to march out of the academy, committed to OOP and nothing but OOP for the rest of their lives."[38] He also is quoted as saying "OOP is to writing a program, what going through airport security is to flying".

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

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

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

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

1040 [The Author notes this is a functional view of polymorphism (as provided in

1429 inclusion of other major or new methodologies should be sent to the FAQ author.

2431 Other entries or suggestions are welcome, please send to the author of the FAQ.

2508 One author can be reached at pfrankl@polyof.poly.edu.

2553 and which is reused. The author can be reached at

2557 via email. The author can be reached at info@testing.com.

ca

1381 Mountain View, CA USA 94043

1383 From: whitney@oberon.Meakins.McGill.CA ()

1658 Cupertino, CA 95014-9974 (USA)

2458 San Mateo, CA 94403

2520 are dhoffman@csr.uvic.ca and pstropp@cs.uq.oz.au. Describes an

2562 through townsend@mprgate.mpr.ca.

2586 Press, Los Alamitos, CA., pp. 272-281.

2688 MicroTech Pacific Research (mpr.ca) has a C++ class testing tool called

2691 contact Paul Townsend, townsend@mprgate.mpr.ca.

2692 Software Research Inc. (625 Third St, San Francisco, CA 94107-1997,

2696 San Jose, CA 95128, voice: 1-408-298-3824 ) has a coverage tool for

cases

33 Decoupling refers to careful controls that separate code modules from particular use cases, which increases code re-usability. A common use of decoupling in OOP is to polymorphically decouple the encapsulation (see Bridge pattern and Adapter pattern) - for example, using a method interface which an encapsulated object must satisfy, as opposed to using the object's class.

626 handle various cases:

634 The above functions are specialized to each of the cases required allowing

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

672 in many cases, such as requiring overriding methods to have identical

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

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

827 of the implementation language, which in some cases is predetermined. See also

1126 cases) to be available on formal objects and a lack of multiple-polymorphism

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

2611 execution of test cases for OOP. These tools assume a

company

1559 Any company, university

1690 Ref: Datamation, LOOK AHEAD Section, August 1. German Company.

1741 PALO ALTO, Calif.--(BUSINESS WIRE) via First! -- Hewlett-Packard Company

1791 our entire company on it," said Richard Tanler, president and chief

1836 Hewlett-Packard Company is an international manufacturer of measurement

1850 Company: Isis Distributed Systems, Inc., Ithaca NY, USA.

1868 Company: Enquiries: info@oot.co.uk

2098 Company Name -

2099 NCR Corporation (An AT&T Company)

2112 Company Description -

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

conference

129 a review of their last conference is available by email thanks to Adam

1456 International Conference on System Sciences (HICSS) (IEEE Computer Society

2496 Science Conference, ACM, Inc., New York, NY, 1990, pp. 161-165.

2504 of 11th. TOOLS USA Conference, Santa Barbara, Aug 1993, pp 407-426.

2507 Northwest Conference on Software Quality, 1990, pp. 309-324.

2515 International Conference on Software Engineering, May, 1992,

2519 Conference, October 1993, Toronto. Email addresses for authors

2526 7th Australian Software Engineering Conference (to appear), 1993.

2531 at the 10th Annual Pacific Northwest Software Quality Conference,

2560 Conference on Object Oriented Programming Systems, Languages

2585 Conference on Software Maintenance 1990, IEEE Computer Society

conventional

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

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

148 in more conventional languages to fully emulate this style of dynamically typed

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

765 methodologies representing a greater departure from the conventional

1021 conventional, classical OO and subclass polymorphism.]

1438 Fichman R.G. & Kemerer C.F. OO and Conventional Analysis and Design

1440 Fichman, Robert and Kemerer, Chris. Object-Oriented and Conventional Analysis

1442 OOA, OOD, conventional analysis, conventional design, DeMarco SA, Yourdon SA,

cooperative

2010 Subject: re-post: NCR Cooperative Frameworks (new phone no.)

2016 NCR Cooperative Frameworks(TM) were first released for sale

2020 Cooperative Frameworks release 3.0 makes the product

2023 Cooperative Frameworks is a distributed object foundation

2026 Cooperative Frameworks consists of an integrated suite of

2037 NCR Cooperative Frameworks currently has two portable ORB

2050 Cooperative Frameworks come with predefined object services

2077 NCR Cooperative Frameworks run on multiple UNIX platforms,

2079 StarServer UNIX SVR4; and on MS Windows 3.1. Cooperative

2095 Cooperative Framework implementations on supported platforms

2109 Cooperative Frameworks

developed

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.

11 The Smalltalk language, which was developed at Xerox PARC (by Alan Kay and others) in the 1970s, introduced the term object-oriented programming to represent the pervasive use of objects and messages as the basis for computation. Smalltalk creators were influenced by the ideas introduced in Simula 67, but Smalltalk was designed to be a fully dynamic system in which classes could be created and modified dynamically rather than statically as in Simula 67.[9] Smalltalk and with it OOP were introduced to a wider audience by the August 1981 issue of Byte Magazine.

13 Object-oriented programming developed as the dominant programming methodology in the early and mid 1990s when programming languages supporting the techniques became widely available. These included Visual FoxPro 3.0, C++[citation needed], and Delphi[citation needed]. Its dominance was further enhanced by the rising popularity of graphical user interfaces, which rely heavily upon object-oriented programming techniques. An example of a closely related dynamic GUI library and OOP language can be found in the Cocoa frameworks on Mac OS X, written in Objective-C, an object-oriented, dynamic messaging extension to C based on Smalltalk. OOP toolkits also enhanced the popularity of event-driven programming (although this concept is not limited to OOP). Some[who?] feel that association with GUIs (real or perceived) was what propelled OOP into the programming mainstream.

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

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:

70 OOP was developed to increase the reusability and maintainability of source code. Transparent representation of the control flow had no priority and was meant to be handled by a compiler. With the increasing relevance of parallel hardware and multithreaded coding, developer transparent control flow becomes more important, something hard to achieve with OOP.

829 From a greater perspective, the SEI has developed the Capability Maturity Model

1547 developed and offered by commercial companies.

1716 implementation" developed at Cornell, Ithaca NY.)

1778 developed with SunSoft. By following a common specification, HP and SunSoft

2081 and was originally developed on MS OS

environments

1618 distributed environments and seamlessly interconnects multiple

1693 support for heterogeneous environments, support for Remote Data Access

1750 distributed heterogeneous systems environments. Of all computer companies,

2083 environments supported include CFRONT and C++ Workbench from

2152 distribute them across heterogeneous environments throughout the

2158 - support for heterogeneous environments

2185 distributed environments, even easier.

2209 environments on a single node

2214 o Support for Heterogeneous Environments

2216 computing environments, such as OS

2667 environments.

facility

141 languages such as C++, although the new RTTI facility will supply simple

568 object facility. Separate type system support is another extension.

903 Polymorphism is often considered the most powerful facility of an OOPL.

975 schemes [Aho 85]. ML is prototypical in providing this facility.

1008 Owl also had such a facility but with two separate inheritance hierarchies,

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

1130 is even being considered for the C++ standard. A similar facility to safe

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

1193 to inherit from them, providing a subclass polymorphism facility, and ACs can

1774 Management Facility (DOMF), object services, developers' and administrative

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

ibm

1410 IBM [IBM 90,91]

1642 IBM AIX, IBM MVS(port in progress), HP-UX, Macintosh, MS-Windows 3.1, NT,

1662 UX, IBM RS-6000, Data General Aviion, MS-Windows (client

1664 > IBM SOM (System Object Model)

1781 In addition, HP is working with IBM to integrate HP's DOMF with IBM's

1784 interoperability of distributed applications across HP and IBM platforms.

1805 modification on HP, Sun and IBM UNIX(R) system-based workstations. They

1996 IBM AIX C Set++ 4th Qtr

2518 To be Presented at the IBM Center for Advanced Studies Fall

info

352 what is this object's class, give info on this class, etc.) and an

1350 ODMG, send an email message to info@odmg.org and you will receive an

1573 log <info> (logs info on server)

1675 > IONA Technologies, Dublin Orbix, info@iona.ie

1705 list with their info package.

1868 Company: Enquiries: info@oot.co.uk

1925 See Appendix E:65 for a complete description and anon FTP info.

2554 info@testing.com.

2557 via email. The author can be reached at info@testing.com.

2693 voice: 1-415-957-1441, email: info@soft.com) has a coverage tool for C++

introduced

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

11 The Smalltalk language, which was developed at Xerox PARC (by Alan Kay and others) in the 1970s, introduced the term object-oriented programming to represent the pervasive use of objects and messages as the basis for computation. Smalltalk creators were influenced by the ideas introduced in Simula 67, but Smalltalk was designed to be a fully dynamic system in which classes could be created and modified dynamically rather than statically as in Simula 67.[9] Smalltalk and with it OOP were introduced to a wider audience by the August 1981 issue of Byte Magazine.

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.

122 Control - Introduced in design for control purposes

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

1742 today introduced a distributed-computing solution for building scalable,

1746 introduced an enhanced version of HP Distributed Smalltalk.

1798 In a related announcement, HP introduced Version 2.0 of HP Distributed

java

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

47 Languages designed mainly for OO programming, but with some procedural elements. Examples: C++, C#, VB.NET, Java, Python.

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.

1279 Java (comp.lang.java, http:

1280 java.sun.com

1281 , Java Report & Conf:

major

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

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

570 Major:

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

882 referred to as simply Simula. Smalltalk was the next major contributor

926 definitions of polymorphism, as divided into two major forms, parametric and

1271 3.4) What Are The Major Object-Oriented Programming Languages Today?

1429 inclusion of other major or new methodologies should be sent to the FAQ author.

1747 HP ORB Plus and HP Distributed Smalltalk are major components of HP's

2215 DOME runs on the major UNIX platforms as well as in other interactive

2471 As soon as one major class library vendor starts to ship real test code

makes

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

1252 This makes for easy "prototyping", which allows for objects to be constructed

1535 OMG Board of Directors makes a final determination for technology adoption.

2020 Cooperative Frameworks release 3.0 makes the product

2140 middleware achieves this, it makes enterprise computing a reality.

2144 Software System makes it possible for organizations to build large

2183 beyond what many of the standards require, it makes the task of

2228 It can read and write data across numerous DBMSs, and it makes

2357 determine the last use of an object and provide deletion. This makes reuse

2385 different threads) makes it impossible to statically determine the last user

2551 Makes the argument that testing of object-oriented software is

modern

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)

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

17 Just as procedural programming led to refinements of techniques such as structured programming, modern object-oriented software design methods include refinements[citation needed] such as the use of design patterns, design by contract, and modeling languages (such as UML).

82 Carnegie-Mellon University Professor Robert Harper in March 2011 wrote: "This semester Dan Licata and I are co-teaching a new course on functional programming for first-year prospective CS majors... Object-oriented programming is eliminated entirely from the introductory curriculum, because it is both anti-modular and anti-parallel by its very nature, and hence unsuitable for a modern CS curriculum. A proposed new course on object- oriented design methodology will be offered at the sophomore level for those students who wish to study this topic."

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

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

565 modern notion of relocatable, persistent and distributed objects that can

697 etc. most programmers think of. Modern software engineering methodologies;

789 Modern OO methodologies directly address these points and emphasize the

1137 recent functional language and Haskell [Hudak 92] provides a more modern and

1234 are generic. Russell and Haskel are more modern variants (references are

products

875 processing system and software products development as integrated components.

1532 information from OMG members about existing products to fill

1546 software interfaces; products which offer these interfaces continue to be

1753 products, understands how to help customers adopt new technology for maximum

1794 We plan to use HP ORB Plus to develop new object-based products that

1837 and computation products and systems recognized for excellence in quality

1838 and support. The company's products and services are used in industry,

2100 Address -- Software Products Division-Columbia

2187 its products to industry standards as they are adopted.

2245 trademarks of SUITESOFTWARE. All other products and product names are

2291 although products are available which can help.

properties

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

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

73 Luca Cardelli wrote a paper titled "Bad Engineering Properties of Object-Oriented Languages" Richard Stallman wrote in 1995, "Adding OOP to Emacs is not clearly an improvement; I used OOP when working on the Lisp Machine window systems, and I disagree with the usual view that it is a superior way to program."

290 design: classical categorization (common properties), conceptual clustering

428 additional attributes or properties to other classes. They are intended to be

453 classes provide properties and attributes for objects, changing base classes

454 changes the properties and attributes of a class. A previous example was a

1187 It is possible to specify desired abstract properties of type specifications

1826 for properties, life cycle, associations, event notification and naming.

ps

1582 91-12-1.ps CORBA spec [although it looks a little old]

1720 electra.ps.Z

2337 gcsurvey.ps. [See APPENDIX E]

2603 papers. Get "toop.ps.Z" for A4 paper and "toopus.ps.Z" for

2615 papers. Get "tools.ps.Z" for A4 paper formatting or get

2616 "toolsus.ps.Z" for US letter formatting.

2626 papers. Get "guide.ps.Z" for A4 paper formatting or get

2627 "guideus.ps.Z" for US letter formatting.

2637 papers. Get toopinht.ps.Z" for A4 paper formatting or get

2638 "toopinhtus.ps.Z" for US letter formatting.

real-world

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.

65 OOP can be used to associate real-world objects and processes with digital counterparts. However, not everyone agrees that OOP facilitates direct real-world mapping (see Negative Criticism section) or that real-world mapping is even a worthy goal; Bertrand Meyer argues in Object-Oriented Software Construction that a program is not a model of the world but a model of some part of the world; "Reality is a cousin twice removed". At the same time, some principal limitations of OOP had been noted. For example, the Circle-ellipse problem is difficult to handle using OOP's concept of inheritance.

103 of a set of real-world things such that:

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

123 Entity - Correspond to real-world objects

657 real-world programming situations, unnecessarily. In the author's opinion,

747 expert's perspective and with an emphasis on modeling the real-world (the

refer

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

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.

305 timers. In Smalltalk, the situation is more complex. To make this easy, refer

363 systems, which often refer to systems implemented in terms of themselves, or

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

759 [Yourdon 92] provides a critique, although may only refer to their earlier

994 Inclusion polymorphism can refer to subtyping, or having at least as much or

1007 They refer to this as "best-fitting" types [Black 86]. The original Trellis

1024 programming, this refers to the ability of an entity to refer at run-time to

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

1210 Generics (or Templates in C++) refer to the ability to parameterize types

relational

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.

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.

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

1319 and inheritance. It is also possible to provide relational operations on an

1323 with a purely relational database.

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

1946 traditional flat file databases, relational databases or object oriented

2063 files, relational or object databases

2223 The DOME Data Manager is a complete relational DBMS engine that

rumbaugh

100 to certain objects in our awareness". [Rumbaugh 91] defines: "We define an

418 in [Rumbaugh 91]) allow any topology, with the head of an arrow indicating the

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

752 model (e.g. FUSION, Jacobson), scenarios (Rumbaugh), or use-cases (Jacobson).

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

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

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

1416 Rumbaugh et al. [Rumbaugh 91]

1467 Wasserman et al, Rumbaugh, Reenskaug et al, and Colbert.

1482 Rumbaugh, J. et.al. - Object-oriented modeling and design, 1991.

term

11 The Smalltalk language, which was developed at Xerox PARC (by Alan Kay and others) in the 1970s, introduced the term object-oriented programming to represent the pervasive use of objects and messages as the basis for computation. Smalltalk creators were influenced by the ideas introduced in Simula 67, but Smalltalk was designed to be a fully dynamic system in which classes could be created and modified dynamically rather than statically as in Simula 67.[9] Smalltalk and with it OOP were introduced to a wider audience by the August 1981 issue of Byte Magazine.

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.

90 "The term object was first formally applied in the Simula language, and

205 term "Prototype" usually refers to prototype theory, a recent theory of

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

268 A class is a general term denoting classification and also has a new meaning

337 "new", and also "class variables" (a term from Smalltalk), which are

511 oriented languages which are then associated with the term "inheritance"

532 p56]. Overriding is the term used in Smalltalk and C++ for redefining a

621 term "multi-method") consider the functional and receiver based forms

1253 piece by piece at run-time, although the term "prototyping" in the context of

x

13 Object-oriented programming developed as the dominant programming methodology in the early and mid 1990s when programming languages supporting the techniques became widely available. These included Visual FoxPro 3.0, C++[citation needed], and Delphi[citation needed]. Its dominance was further enhanced by the rising popularity of graphical user interfaces, which rely heavily upon object-oriented programming techniques. An example of a closely related dynamic GUI library and OOP language can be found in the Cocoa frameworks on Mac OS X, written in Objective-C, an object-oriented, dynamic messaging extension to C based on Smalltalk. OOP toolkits also enhanced the popularity of event-driven programming (although this concept is not limited to OOP). Some[who?] feel that association with GUIs (real or perceived) was what propelled OOP into the programming mainstream.

1682 SunOS 4.x, Solaris 2.3, and OSF

1987 Solaris 2.x SPARCompiler 3.0.2 NOW

1988 Solaris 2.x SPARCompiler 4.0 NOW

1989 Solaris 2.x GNU 2.5.7 NOW

1991 IRIX 5.x Native NOW

2036 OSI protocols, X.25