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

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

wirth

14 At ETH Z?rich, Niklaus Wirth and his colleagues had also been investigating such topics as data abstraction and modular programming (although this had been in common use in the 1960s or earlier). Modula-2 (1978) included both, and their succeeding design, Oberon, included a distinctive approach to object orientation, classes, and such. The approach is unlike Smalltalk, and very unlike C++.

66 However, Niklaus Wirth (who popularized the adage now known as Wirth's law: "Software is getting slower more rapidly than hardware becomes faster") said of OOP in his paper, "Good Ideas through the Looking Glass", "This paradigm closely reflects the structure of systems 'in the real world', and it is therefore well suited to model complex systems with complex behaviours" (contrast KISS principle).

wrapping

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.

2042 - wrapping existing databases and legacy

writing

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

1822 writing distributed, object-oriented applications require additional

yaoqing

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

567 ch 19 and Yaoqing 93] provide another example of a distributable and migratable

yegge

67 Steve Yegge and others noted that natural languages lack the OOP approach of strictly prioritizing things (objects

80 Steve Yegge, making a roundabout comparison with Functional programming, writes, "Object Oriented Programming puts the Nouns first and foremost. Why would you go to such lengths to put one part of speech on a pedestal? Why should one kind of concept take precedence over another? It's not as if OOP has suddenly made verbs less important in the way we actually think. It's a strangely skewed perspective."

zurich

1698 > CS Dept. University of Zurich, Switzerland. maffeis@ifi.unizh.ch

1706 CS Dept. University of Zurich, Switzerland. maffeis@ifi.unizh.ch

---

2339 Weiser. Software --- Practise and Experience vol 18(9), pp 807-820.

------------

1978 ------------

-------------------------------------------------------

1982 -------------------------------------------------------

abadi

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.

abandoned

1009 although it was abandoned in favor of a single class-based approach for

abap

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

absent

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

abstracts

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

aca

1639 > DEC ObjectBroker Version 2.5 (Version 2.1 was ACA)

academic

1681 Complete implementation of CORBA. Free academic; com. eval licence avail.

academy

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

acceptable

1006 acceptable and no inheritance relation is required (subtype polymorphism).

accesses

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.

accidental

1177 restriction is somewhat less type-safe, because accidental matches of method

accommodate

2139 security; and scale up to accommodate even the largest systems. When

accommodates

2166 and its open platform structure accommodates future technologies.

accomplished

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.

achieve

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.

achieves

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

acknowledgment

2197 acknowledgment and start-on-demand

acks

2461 something. See the section "ACKs" at the end.

acronym

349 MOP is an acronym for Meta-Object Protocol. This is a system with

activerecord

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.

actor

1297 Actor

acts

594 Behavior is how an object acts and reacts, in terms of its state changes

acyclic

2534 designing software that avoids acyclic component

adage

66 However, Niklaus Wirth (who popularized the adage now known as Wirth's law: "Software is getting slower more rapidly than hardware becomes faster") said of OOP in his paper, "Good Ideas through the Looking Glass", "This paradigm closely reflects the structure of systems 'in the real world', and it is therefore well suited to model complex systems with complex behaviours" (contrast KISS principle).

adam

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

adamw

130 Wildavsky, send requests to adamw@panix.com.

adapted

2576 could be adapted for object-oriented software.

ada's

240 and Ada have packages for encapsulation, CLOS's are optional while Ada's

addison-wesley

2592 Addison-Wesley, 1992, ISBN:0-201-60890-1.

addressed

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.

adds

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

adequate

2566 Perry, D.E. and G.E. Kaiser, "Adequate Testing and Object-Oriented

adequately

785 * It does not adequately address changes

adj

909 polymorphous adj. having, assuming, or passing through many or various forms,

administer

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

administrators

1787 system administrators and end users language-neutral, enterprise-wide,

adopt

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

advocates

292 He advocates starting with the former approach, turning to the second approach

aed-

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

aforementioned

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

agreed-upon

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.

agrees

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.

aho

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

aims

1505 consortium with two primary aims:

aircraft

857 Hughes Aircraft", IEEE Software, July 1991

airport

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

alamitos

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

albeit

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

alcatel

868 ami-request@aut.alcatel.at

alcool-

1140 appendixes for an experimental dynamic extension to ML, Alcool-90 and [Cardelli

alexander

76 Alexander Stepanov suggested that OOP provides a mathematically-limited viewpoint and called it "almost as much of a hoax as Artificial Intelligence. I have yet to see an interesting piece of code that comes from these OO people. In a sense, I am unfair to AI: I learned a lot of stuff from the MIT AI Lab crowd, they have done some really fundamental work....".

algol

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

algol-

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

aliasing

2201 - Logical name translation for true aliasing

align

1966 agreement to align their implementations of CORBA. The two companies

allocated

2307 resort to statically allocated arrays. This in turn leads to

allocation

2698 allocation checking.

alter

421 by making a small change to a class. Creating a subclass to alter a method

alterations

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.

alto

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

amd

1861 The C++ interface in August. Customers include AMD, Consilium and Swiss

ami-request

868 ami-request@aut.alcatel.at

amortized

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

analogous

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.

analysed

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

analysts

741 objects, and kits [frameworks]. OORA analysts and OOD designers will

analyze-design

793 proposes a "round-trip gestalt" design with analyze-design iterations and

analyze-design-implement-test

795 "parallel-recursive design" with analyze-design-implement-test iterations.

ancestor

375 ancestor

andrew

1647 Andrew Comas

annotated

702 See also section 3.7, the Annotated Bibliography, and APPENDIX D. The

announced

1833 available mid- 1994; prices will be announced then. HP ORB Plus runs on the

announcement

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

announcements

1599 oriented product announcements. All OMG activities and the

announces

2012 NCR ANNOUNCES BETA AVAILABILITY

ansi

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.

anti-modular

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

anti-parallel

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

anytime

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

aol

1336 From: dbmsfacts@aol.com (DBMSfacts)

apertos

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

apollo

1834 HP Apollo 9000 Series 700 workstations and HP 9000 Series 800 business

apparent

936 ad-hoc polymorphism isn't (apparent polymorphism).

appearance

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

appendices

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

appendixes

1140 appendixes for an experimental dynamic extension to ML, Alcool-90 and [Cardelli

apple

1806 also will run on Apple Macintosh computers and on any PC running the Windows

application-specific

2295 programmer has to write an application-specific garbage collector.

apply

2309 the assumptions behind the chosen limits no longer apply. For

approaching

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

appropriately

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.

approximate

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.

approximately

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

architectural

1515 of both technical and architectural goals; and an architecture

archives

2642 There is a smalltalk class library in the Univ. of Illinois archives

arenas

1549 arenas besides the distributed system problem, the Group supports Special

arguably

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:

argues

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.

arguments

618 encapsulation implies all arguments can be accessed by a multi-method (although

aristotlean

278 Original Aristotlean classification defines a "class" as a generalization of

arnold

1431 Arnold, P., Bodoff, S., Coleman, D., Gilchrist, H., Hayes, F., An Evolution of

arrow

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

art

2333 This is an excellent summary of the state of the art in GC algorithms. This

article

2589 Publications. The article talks some about why testing is

aspect

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

assembler

1367 GEOS (GeoWorks', written in Object Assembler, OO superset of 8086)

asserts

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

assessing

830 (CMM), a process-based TQM model for assessing the level of an organization's

assessment

853 Kitson, D.H. and Masters, S. "An Analysis of SEI Software Process Assessment

assist

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.

assoc

128 * There was a Software Frameworks Assoc. and magazine until last year, but

assumes

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

assured

2695 Quality Assured Software Engineering (938 Willowleaf Dr., Suite 2806,

atlanta

1452 State University, Atlanta, USA, 1992, 163 pages.

atomic

780 life-cycle models and their use. Humphrey also details Worldy and Atomic

atoms

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

attached

30 Methods which act on the attached objects.

atypical

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

au

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

audience

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.

aug

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

australian

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

aut

868 ami-request@aut.alcatel.at

auto

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

automatics

1329 automatics having the shortest default

autonomy

2226 DDM provides autonomy for distributed data sites, but it also

auto-tested

2476 safer with a class library that could be auto-tested in your

avail

1681 Complete implementation of CORBA. Free academic; com. eval licence avail.

aviion

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

avoiding

638 and cohesion, multiple-polymorphism reduces program complexity by avoiding

awareness

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

awkward

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

axion

2512 jgraham@axion.bt.co.uk.

axp

1877 1 (AXP), OpenVMS,

ba

2671 Bath BA1 5LR

bad

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

bailin

1443 Bailin OO requirements specification, Coad-Yourdon OOA, Shlaer-Mellor OOA,

barbara

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

barry

1352 Doug Barry

bars

2647 components such as windows, cursors, or scroll bars. The filein

batch-mode

2684 to support batch-mode and regression testing

bath

2671 Bath BA1 5LR

beginning

1730 Revision 1.0 has been shipping since beginning of '92. Revision 1.1

behaviors

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

behaviour

2324 also available with good real-time behaviour.

behaviours

66 However, Niklaus Wirth (who popularized the adage now known as Wirth's law: "Software is getting slower more rapidly than hardware becomes faster") said of OOP in his paper, "Good Ideas through the Looking Glass", "This paradigm closely reflects the structure of systems 'in the real world', and it is therefore well suited to model complex systems with complex behaviours" (contrast KISS principle).

bekkers

2331 Management, Sept. 1992, St. Malo, France, Yves Bekkers and Jacques Cohen,

belong

447 object-oriented programming, because many objects in the real world belong to

belonging

959 Inclusion Polymorphism: an object can be viewed as belonging to many different

beneficial

2211 These beneficial functions have resulted in measurable time and labor

benjamin

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:

bertrand

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.

best-fitting

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

bezier

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

bibliographies

1348 adding more links to related sites, bibliographies, and a FAQ for ODBMSs.

billion

1840 countries. HP has 94,900 employees and had revenue of $16.4 billion in its

bjarne

824 language to implement the design). But some, such as Bjarne Stroustrup, don't

blatantly

2465 confidence, they must be blatantly correct. The classes must be easily

blocks

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

bloggs

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

board

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

-bob

2286 below). [Ada has switchable GC, too -bob]

bodies

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

bodoff

1431 Arnold, P., Bodoff, S., Coleman, D., Gilchrist, H., Hayes, F., An Evolution of

boehm's

784 Boehm's seminal work on the Spiral Model:

boil

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

bon

1400 BON [Nerson 92]

book-new

42 Question book-new.svg

bootstrapped

364 bootstrapped). Reflective systems are inevitably reflexive (as are most

boris

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

bot

907 crystallographically distinct forms. 3. Zool., Bot. existence of an

boundaries

101 object as a concept, abstraction or thing with crisp boundaries and meaning for

boundary

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

bounded

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

breakdown

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

breaks

2355 1. Manual Memory Management Breaks Encapsulation.

brethren

2418 their manually managed brethren. [3] In fact, multi-media programmers

bridging

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.

bright

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

bringing

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

broad

2251 education. The broad technical and business systems background of our

broadcasting

2193 store-and-forward, broadcasting, and subscribing functionality

broadest

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

broadly

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.

broadway

2545 Love, Tom. Object Lessons. SIGS Books, 588 Broadway #604, New York, NY

broking

1908 - location broking,

brook

1651 110 Spit Brook Road

browser

1949 implementation. The Interface Repository operates as a dynamic browser which is

browsing

1816 -- easier development, with remote object browsing so

bsd

1368 Mach (CMU, supports BSD 4.3, really message-based)

builder

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

bulldozer

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.

burden

2396 delete, placing the memory management burden on the client, who must call

bus

1543 application request handling software "bus."

bus-based

2192 - Queue- and bus-based (rather than send-based) design provides

byte

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.

bytecode

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

cacm

1462 Analysis and Design. CACM

calculi

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)

california

2274 published by Morgan Kaufmann Publishers, San Mateo, California

canonical

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:

capable

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

carefully

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.

cargo

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

carnegie-mellon

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

carrier

1389 Carrier principle, Object Directories

carrying

2402 sharing and carrying expensive performance costs when complex objects are

casually

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.

categorized

133 The implementation of objects could roughly be categorized into descriptor-

cattell

2273 edited by: R.G.G. Cattell

c-based

385 don't specify new state by default (to do so requires cloning), C-based (C++,

ccitt

2175 - CCITT X.500

central

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

ceres

1395 ETHOS was implemented as an operating system for the Ceres computers

cfront

2083 environments supported include CFRONT and C++ Workbench from

chain

1795 retailers can distribute to end users throughout headquarters, all chain

chain-of-responsibility

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.

challenge

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

challenged

43 This section does not cite any references or sources. Please help improve this section by adding citations to reliable sources. Unsourced material may be challenged and removed. (August 2009)

champaign

2556 Foundations, Champaign, Illinois, 1992. Copies may be obtainable

chaotic

839 Level 1: Initial: Every project is handled differently; ad hoc and chaotic.

chapters

2481 This book has two chapters on testing of object-oriented software,

characterizes

916 (or type) when assuming or becoming an object of a derived class characterizes

characters

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

charts

817 methodologies, such as the analysis (DFD's) to design (structure charts) to

cheatham

2494 Cheatham Thomas J., and Lee Mellinger, "Testing Object-Oriented

check

1146 Smalltalk is an example of a dynamically-typed language which does not check

checker

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.

checks

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.

chemically

906 crystallization into 2 or more chemically identical but

chief

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

choice

606 Selector would be another good choice for message_name in the above examples,

chorus

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

chris

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

christopher

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.

chs

462 See also [Kim 89, chs 1, 3] for a discussion and [Coplien 92] for some

circle-ellipse

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.

circular

2318 circular data structures. Two systems that use a reference count GC

circumstances

2292 2: In some circumstances the decision about whether to deallocate

citations

43 This section does not cite any references or sources. Please help improve this section by adding citations to reliable sources. Unsourced material may be challenged and removed. (August 2009)

cited

864 often cited model. There is also an ISO 9000 standard [ISO] applicable to

cl

847 ricis.cl.uh.edu

claiming

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

claims

1028 dynamic type, which is relevant, but claims "... there is no way the type

class'

297 A Meta-Class is a class' class. If a class is an object, then that object

classic-ada

1275 Classic-Ada

classifications

964 classifications.

classified

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

class-like

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

cleveland

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

clients

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

cliffs

2480 Prentice-Hall, Englewood Cliffs, NJ. $35.

clojure

81 Rich Hickey, creator of Clojure, described object systems as over simplistic models of the real world. He emphasized the inability of OOP to model time properly, which is getting increasingly problematic as software systems become more concurrent.

cloned

206 classification where any object can be inherited from or cloned to serve as a

closest

391 schemes exist, for example C++ finds the closest match within a scope but

clos's

240 and Ada have packages for encapsulation, CLOS's are optional while Ada's

closure

345 Meta-Meta-Class, ... Closure can be achieved with an instance-of loop, as with

clu

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

clustering

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

cmm's

837 based software process (TSP?). Other CMM's in the works at the SEI include a

coad-yourdon

1443 Bailin OO requirements specification, Coad-Yourdon OOA, Shlaer-Mellor OOA,

coalgebraic

35 coalgebraic data types

cocoa

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.

codified

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.

coercion

949 |-- coercion

coexist

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

co-existence

2207 - Co-existence of multiple development and

cognitive

213 window and icon objects display different behavior (although cognitive

cohen

2331 Management, Sept. 1992, St. Malo, France, Yves Bekkers and Jacques Cohen,

coherence

1096 simple call. It also allows small packages of behavior, improving coherence

cohesive

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

coincidentally

1503 and coincidentally, MIT '82, SM '85, PhD '89 (EECS)

coined

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

coldfusion

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

collaboration

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.

collate

2460 I just collate the stuff that is sent to me by people who REALLY know

colleagues

14 At ETH Z?rich, Niklaus Wirth and his colleagues had also been investigating such topics as data abstraction and modular programming (although this had been in common use in the 1960s or earlier). Modula-2 (1978) included both, and their succeeding design, Oberon, included a distinctive approach to object orientation, classes, and such. The approach is unlike Smalltalk, and very unlike C++.

collecting

735 "The process of identifying, collecting, organizing, and representing the

collectors

2419 sometimes choose treadmill collectors [4] over hand-management because of its

columbia

2102 West Columbia SC 29170

comm

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

commentaries

1597 commentaries from software industry leaders, informative user

committed

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

committee

2474 about it. If you had to recommend a class library to a committee that

committees

1534 by Technical and Business committees to review these responses, the

commonality

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

common-object-request-broker

1769 CORBA (common-object-request-broker architecture) specification provides a

communicating

1523 communicating with OMG-conforming object-oriented systems;

communism

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

community

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.

compact

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.

compaction

2325 [Further, GC can perform compaction improving locality of reference.]

companies'

1785 This is part of the companies' planned approach toward a standards-based,

company's

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

comparative

1434 de Champeaux, Dennis and Faure, Penelope. A comparative study of object-

compare

1460 to compare ten OO methods and should be available shortly.

compared

2599 programs. Testing of OOP is compared with traditional software

compares

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

comparing

2303 and comparing whole objects rather than just references. This is a

compatibly

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

competence

283 competence, or condition".

competitive

1793 applications for retailers provide the means to a competitive business edge.

compile-coupling

2539 leads to errors in large designs. Compile-coupling

compiled

1069 possibilities of usage is undecidable. When the complete program is compiled,

complaints

514 but in the author's opinion many of their complaints are easily answered. In

completely

2368 collection has completely solved the above problems and made reference

complexities

370 classification, and generalization to understand and deal with the complexities

complicated

517 Others complain multiple inheritance is too complicated because it brings up

complicates

2122 Variety may make life more interesting, but it only complicates the

comprise

1527 4) the Common Facilities will comprise facilities which are useful in

compromise

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

compute

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

computer-related

2412 advanced as rapidly as most computer-related technologies and is now a robust,

concatenating

163 as variant parts and with multiple-inheritance concatenating several records

concealing

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.

concurrency

577 Concurrency

conditions

1188 with mechanisms similar to Eiffel's pre-, post-, and invariant conditions.

confidence

2465 confidence, they must be blatantly correct. The classes must be easily

configured

1895 can be configured and constructed to best suit the runtime

conflicts

394 renaming for any parent member conflicts.

conform

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

conforming

2238 locations, and it is also interoperable. By conforming to the SQL

conforms

2186 SUITESOFTWARE is a member of various standards groups and conforms

confused

362 "Reflective" systems are systems with MOPs (not to be confused with reflexive

confusion

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

connecting

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

consensus

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.

considers

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

consilium

1861 The C++ interface in August. Customers include AMD, Consilium and Swiss

consistency

819 Seamlessness together with naturalness is a big advantage for consistency.

consolidating

2227 supplies the means for consolidating data for specific applications.

consortium

1505 consortium with two primary aims:

constantine

755 and Constantine. Their complete approach ([Shlaer 88, 92]) consists of

constrained

1026 constrained by inheritance: ...

constructor

275 constructor of

constructors

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

consulting

1687 > ROLSCH CONSULTING (RC-ORB)

content

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

continually

844 continually

continuing

2250 SUITESOFTWARE places particular emphasis on support and continuing

contractors

831 software development and which is often required of government contractors

contribute

229 details of an object that do not contribute to its essential characteristics."

contributing

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.

contributor

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

controls

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.

conveyance

880 It was intended as a conveyance of object-oriented design. Simula 1 was a

convinced

1790 "We're so convinced of the value of object technology that we're staking

convoluted

69 verbs).] This problem may cause OOP to suffer more convoluted solutions than procedural programming.

cook

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

cool

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

cooper

1846 From: rcbc@cs.cornell.edu (Robert Cooper)

co-operate

2298 modules must co-operate closely. This leads to a tight binding

cooperating

1854 cooperating objects. RDOM is built on top of the Isis Distributed

cope

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.

copying

2302 5: In order to avoid problems 3 and 4, programmers may end up copying

copy-on-write

2377 counting to encapsulate copy-on-write memory management. However, this only

copyrighted

2246 copyrighted by, trademarks of, or registered trademarks of their

corba-compliant

1726 CORBA-compliant DOMS. Includes a GUI API driver for prototyping and

corba-conformant

1901 DOME has a CORBA-conformant interface, and is CORBA 1.0 compliant

corba's

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

core

2219 The DOME software system is composed of the core DOME product, DOME

coroutines

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

corporate

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

correspond

123 Entity - Correspond to real-world objects

costs

2402 sharing and carrying expensive performance costs when complex objects are

co-teaching

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

counterparts

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.

countless

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

countries

1840 countries. HP has 94,900 employees and had revenue of $16.4 billion in its

couple

2439 to the Software section. Also a couple of articles added to the

courses

2444 or other means. Sections include Written Material, Courses, and

cousin

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.

covariant

673 signatures with the methods they substitute (as in C++) or allowing covariant

covered

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

covering

2147 DOME - Covering the Enterprise

craft

2550 Marick, Brian. The Craft of Software Testing, Prentice-Hall, in press.

creat

865 software quality and ami working group in Europe helping to creat the ISO

creational

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

creator

81 Rich Hickey, creator of Clojure, described object systems as over simplistic models of the real world. He emphasized the inability of OOP to model time properly, which is getting increasingly problematic as software systems become more concurrent.

creators

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.

credited

753 [Shlaer 88] is often credited as the first book on OOA, although their method

crisp

101 object as a concept, abstraction or thing with crisp boundaries and meaning for

crisply

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

criticism

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.

critisisms

783 also provides the following critisisms on the Waterfall Model which had led to

crowd

76 Alexander Stepanov suggested that OOP provides a mathematically-limited viewpoint and called it "almost as much of a hoax as Artificial Intelligence. I have yet to see an interesting piece of code that comes from these OO people. In a sense, I am unfair to AI: I learned a lot of stuff from the MIT AI Lab crowd, they have done some really fundamental work....".

crsp

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

crude

2410 versions of garbage collection were merely crude implementations of

cryall

905 Polymorphism 1. State or condition of being polymorphous. 2. Cryall.

crystallization

906 crystallization into 2 or more chemically identical but

crystallographically

907 crystallographically distinct forms. 3. Zool., Bot. existence of an

csr

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

cumulative

2683 *Programmatic interface to output files and cumulative code coverage

cup

1659 Ian Fuller ian@cup.hp.com (408) 447-4722

cupertino

1658 Cupertino, CA 95014-9974 (USA)

cursors

2647 components such as windows, cursors, or scroll bars. The filein

customer's

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

customizable

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.

cv

1870 1st Floor, Lawrence House, 1A Morrell St, Leamington Spa, England CV32 5SZ

cycles

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

dahl

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

damage

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.

daniel

2517 Hoffman, Daniel and Paul Strooper. A Case Study in Class Testing.

darwen

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.

data-driven

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

datamation

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

data-structures

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

ddmtm

2221 DOME Data Manager (DDMTM) database access manager.

deactivation

2070 and deactivation when not needed

dealing

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.

deallocated

2315 drops to zero the object is automatically deallocated. However this

deallocating

2296 3: An object which is responsible for deallocating storage must be

deborah

18 A survey by Deborah J. Armstrong of nearly 40 years of computing literature identified a number of "quarks", or fundamental concepts, found in the strong majority of definitions of OOP.

december

2091 developers with general availability set for December, 1993;

declaration

1016 variable declaration) may denote objects of many different classes that are

declarations

2622 methods of making class declarations and the implications of

declare

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

declares

443 the earlier flavors. C++ declares an error iff a conflict arises, but a

decorator

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

decouple

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.

decrements

2317 decrements, three increments and six comparisons) and cannot reclaim

definition-

1819 HP's DOMF includes the object request broker, interface- definition-

definitive

2492 by so many people as a definitive software testing work, that

dekorte

1308 dekorte

delegation-based

226 Self is a good example of a delegation-based single hierarchy language

delegation's

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

deleted

1251 inheritance" in which fields and methods can be added and deleted from objects.

deliver

1971 the Isis distributed system, will deliver a fault-tolerant ORB.

delivering

2591 Theilen, David. "No Bugs. Delivering error free code in C and C++.",

delphi

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.

delusion

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

demanding

417 with the parent class on top, but more demanding graphs (as is often the case

demarco

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

demon

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

dennis

1434 de Champeaux, Dennis and Faure, Penelope. A comparative study of object-

denotational

395 Defining inheritance (with a thorough description or denotational semantic

denoted

1017 related by some common superclass; thus, any object denoted by this name is

denoting

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

department

1451 the Netherlands, and Computer Information Systems Department, Georgia

departure

765 methodologies representing a greater departure from the conventional

deploy

1760 designed to let developers write one application and then deploy it --

derivatives

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

descriptor

274 intensional definition, emphasizing a class as a descriptor

descriptor-based

144 Descriptor-based approaches can have pointer semantics and can be statically

designing-in

2530 Lakos, John S. "Designing-In Quality in Large C++ Projects" Presented

design-portability

1522 2) the Object Model, or single design-portability abstract model for

desirable

520 strategies or renaming, and most consider MI to be highly desirable. See the

destructor

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

detected

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.

detection

2680 *Automatic memory leak detection on executables to optimize memory use

determining

1068 which case the overriding function must be called. Statically determining all

detrimental

1911 - dynamic invocation, which is seen as detrimental to performance

developer

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.

developers'

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

developments

1594 Technology developments, both technically and commercially. First

devoted

1019 Booch also has several sections devoted to polymorphism.

dhoffman

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

dialect

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

dictionaries

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

dictionary

904 > Webster's New World Dictionary:

differentially

358 differentially without affecting them and their extant objects. Thus, many

differentiated

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

difficulties

434 1.9) Does Multiple Inheritance Pose Any Additional Difficulties? (Object-Oriented Technology)

difficulty

2420 superior real-time performance as manual management usually has difficulty

digital's

1640 Full implementation of OMG CORBA 1.1. Digital's ObjectBroker is a 100 %

dion

858 Dion, R., "Elements of a Process Improvement Program," IEEE Software, July

directories

1389 Carrier principle, Object Directories

directors

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

disadvantage

1226 disadvantage when causing dynamic compilation (leading to a time

disagree

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

disambiguate

444 class qualifier can be used to explicitly disambiguate. Smalltalk renders

discourse

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

discrepancies

826 fear that great discrepancies could occur between OOD and OOP by losing sight

disjoint

960 classes that need not be disjoint; that is, there may be inclusion of

disk

2262 Disk space and memory requirements are dependent on the installation

display

213 window and icon objects display different behavior (although cognitive

dissertation

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

distill

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:

distinctive

14 At ETH Z?rich, Niklaus Wirth and his colleagues had also been investigating such topics as data abstraction and modular programming (although this had been in common use in the 1960s or earlier). Modula-2 (1978) included both, and their succeeding design, Oberon, included a distinctive approach to object orientation, classes, and such. The approach is unlike Smalltalk, and very unlike C++.

distinctly

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.

distinguish

1265 distinguish a receiver, but packages can help make up the difference.

distinguishes

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.

distr

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

distributable

567 ch 19 and Yaoqing 93] provide another example of a distributable and migratable

diverge

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.

divergences

1902 with the following divergences -

division-columbia

2100 Address -- Software Products Division-Columbia

dll

2087 architectures as a set of DLL and shared libraries

dmi

526 supported by dynamic multiple inheritance (DMI) in many situations.

doclist

1580 doclist.txt

dome's

2189 Because DOME's architecture is object-oriented, there are significant

domeshell

2244 DOME, DOMEshell, DOME Security, DOME Data Manager, and DDM are

domeshelltm

2220 SecurityTM, DOMEshellTM scripting and prototyping language, and the

dominance

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.

dominate

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

donated

2433 [This entry was donated by Doug Shaker and is certainly a FAQ]

dones

2697 C and C++ called MetaC. It also dones some syntax checking and memory

doubly

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

download

1458 [From Shuguang...] readers may download the paper if they want, though they

downsides

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.

dpos

1358 They are almost always distributed systems (DOS or DPOS), allowing objects to

dr

2695 Quality Assured Software Engineering (938 Willowleaf Dr., Suite 2806,

draft

1477 Engineering of Systems, draft manuscript, 1994.

dragoon

1276 Dragoon

drakeford

2509 Graham, J.A., Drakeford, A.C.T., Turner, C.D. 1993. The Verification,

drawing

2293 storage cannot be made by the programmer. Drawing editors and

drawn

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

driver

1726 CORBA-compliant DOMS. Includes a GUI API driver for prototyping and

dropping

1176 (subclass polymorphism), as is typical in most OOPLs. Dropping this

drops

2315 drops to zero the object is automatically deallocated. However this

dshaker

2455 email: dshaker@qualix.com

dst

1709 Date: Tue, 4 May 1993 13:12:36 +0200 (MET DST)

dual

583 meta-classes. But classes play a dual role, because objects can only be

duplication

450 its interface, causing code duplication (and a messy interface).

durable

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

dvi

2582 foot.dvi".

ecs

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

edge

1793 applications for retailers provide the means to a competitive business edge.

edi

2191 - True messaging for workflow management and EDI

edit

1081 multiple-polymorphism, a cut operation in an Edit submenu may pass the cut

editable

426 may be an editable_item and a kind of literature.

edited

2273 edited by: R.G.G. Cattell

editor

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

editorial

1595 Class offers an open editorial forum on numerous Object

editors

2293 storage cannot be made by the programmer. Drawing editors and

eds

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

edwards

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

eecs

1503 and coincidentally, MIT '82, SM '85, PhD '89 (EECS)

effect

1052 is it? To make any difference, the differing forms must have some effect. In

effects

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

efficiently

2374 often use "copy on write" to efficiently implement pass-by-value semantics.

efforts

873 efforts places information systems within an organizational perspective by

eiffel-based

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

eiffel's

1188 with mechanisms similar to Eiffel's pre-, post-, and invariant conditions.

elegant

515 systems that provide inheritance, inheritance provides a simple and elegant way

element

1519 1) the Object Request Broker, or key communications element, for

eliminated

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

eliminates

1092 a system without affecting existing code and eliminates switch statements.

eloquently

2547 This book eloquently elucidates the need for testing of object-

elucidates

2547 This book eloquently elucidates the need for testing of object-

emacs

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

emerged

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

emphasize

789 Modern OO methodologies directly address these points and emphasize the

emphasized

81 Rich Hickey, creator of Clojure, described object systems as over simplistic models of the real world. He emphasized the inability of OOP to model time properly, which is getting increasingly problematic as software systems become more concurrent.

employing

519 systems support Multiple Inheritance by employing semantic resolution

employs

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.

emulate

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

enables

1944 at runtime through its Object Loader function. This enables developers to more

encapsulating

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

endlessly

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

engine

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

englewood

2480 Prentice-Hall, Englewood Cliffs, NJ. $35.

enquiries

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

ensure

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.

ensures

2252 staff of fully trained professionals ensures "real world" responses

ensuring

2533 The focus of this paper is on ensuring quality by

entered

1970 just entered beta testing. Work is underway on Orbix-FT, integration with

enterprise's

2235 enterprise's physical environment of multiple nodes, disparate

entirety

2233 its entirety on the local machine. This is possible because DDM maps

ephemeral

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

equally

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.

e-r

763 analysis methodologies with such constructs as associations (E-R), functional

erich

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.

erlang

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

erosion

2473 market pressure, to do so as well, or face market share erosion. Think

error-checking

2679 *Automatic run-time error-checking on executables to enhance quality

erwin

2242 ERwin,, Popkin,, and Knowledgeware,.

es

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

esprit

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

essays

2479 Berard, Edward. Essays on Object-Oriented Software Engineering.

essence

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

europe

865 software quality and ami working group in Europe helping to creat the ISO

eval

1681 Complete implementation of CORBA. Free academic; com. eval licence avail.

evaluation

2466 testable during initial evaluation by the client programmer. They must

evb

1407 EVB [Jurik 92]

eveleigh

2670 Eveleigh House, Grove Street,

event-driven

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.

evolve

452 Dynamic inheritance allows objects to change and evolve over time. Since base

examine

5 In contrast, the object-oriented approach encourages the programmer to place data where it is not directly accessible by the rest of the program. Instead, the data is accessed by calling specially written functions, commonly called methods, which are either bundled in with the data or inherited from "class objects." These act as the intermediaries for retrieving or modifying the data they control. The programming construct that combines data with a set of methods for accessing and managing those data is called an object. The practice of using subroutines to examine or modify certain kinds of data, however, was also quite commonly used in non-OOP modular programming, well before the widespread use of object-oriented programming.

excellence

1837 and computation products and systems recognized for excellence in quality

exceptionally

2659 making the tool exceptionally easy to use and productive in

exceptions

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

execute

2258 execute DOME plus PostScriptTM versions of DOME documentation.

exemplars

1255 object instantiation, or exemplars.

exercise

989 an exercise for the reader.

exercising

1727 exercising objects, a bundled object database for persistent object

exhaustive

1363 by no means exhaustive.

exhibition

1960 exhibition in San Francisco, Calif., June 1993. Since then it has rolled

existence

907 crystallographically distinct forms. 3. Zool., Bot. existence of an

existential

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

exists

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

expand

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

expanded

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

expense

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.

expensive

2402 sharing and carrying expensive performance costs when complex objects are

experience

2339 Weiser. Software --- Practise and Experience vol 18(9), pp 807-820.

experimentation

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.

experts

737 their development histories, knowledge captured from domain experts,

expert's

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

explanation

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

exploring

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.

exporting

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

exposed

664 than one object to be exposed. See [Kim ch 4, pp70-71 (D. Moon)] for an

exposition

1190 behavior. [Liskov 93] provides a recent exposition.

ext

2111 Ext. 7774

extant

358 differentially without affecting them and their extant objects. Thus, many

extend

1080 [Garfinkel 93, p80] and [Cox 91, pp 64-67]. To extend Garfinkels example with

extending

1459 may continue to request hard copies. We are currently extending the paper

extensive

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.

extensively

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

external

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

extremely

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.

facade

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

facilitates

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.

fact

2418 their manually managed brethren. [3] In fact, multi-media programmers

fads

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

fail

294 fail to suffice.

fairly

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

false

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.

family

758 addition to the structured analysis family (as does Martin and Odell).

family-based

1372 Peace (OO family-based parallel OS, See Appendix E, General)

fancy

642 dispatch, a fancy name for single dispatch after a call, which only provides

faster

66 However, Niklaus Wirth (who popularized the adage now known as Wirth's law: "Software is getting slower more rapidly than hardware becomes faster") said of OOP in his paper, "Good Ideas through the Looking Glass", "This paradigm closely reflects the structure of systems 'in the real world', and it is therefore well suited to model complex systems with complex behaviours" (contrast KISS principle).

fault-tolerant

1971 the Isis distributed system, will deliver a fault-tolerant ORB.

faure

1434 de Champeaux, Dennis and Faure, Penelope. A comparative study of object-

fear

826 fear that great discrepancies could occur between OOD and OOP by losing sight

feasible

714 of externally observable behavior; a complete, consistent, and feasible

feature-based

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

feb

2569 Feb 1990.

fee-free

1536 Adopted specifications are available on a fee-free basis to members and

fewer

172 and program complexity (fewer nested programming constructs) and allowing

fewest

2711 software will have the fewest problems on SunOS or Solaris releases.

fiedler

2501 Fiedler, Steven P., "Object-Oriented Unit Testing", Hewlett-Packard

field

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

filein

2647 components such as windows, cursors, or scroll bars. The filein

filling

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

final

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

finds

391 schemes exist, for example C++ finds the closest match within a scope but

fine

2057 designed around fine grained objects, developers can

fine-grain

2056 - Fine-grain Data Management - class libraries are

firesmith

2503 Firesmith, D.G., "Testing Object-Oriented Software", Proceedings

firstname

870 subscribe firstname, lastname, e-mail address.

first-year

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

fiscal

1841 1992 fiscal year.

fitzpatrick

2513 Harrold, Mary Jean, John D. McGregor, and Kevin J. Fitzpatrick,

fixed

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.

flat

1946 traditional flat file databases, relational databases or object oriented

flavor

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

floor

1870 1st Floor, Lawrence House, 1A Morrell St, Leamington Spa, England CV32 5SZ

flying

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

flyweight

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

focused

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.

focusing

2482 focusing on how to do it.

foot

2582 foot.dvi".

force

1622 the ORB Task Force of the OMG.

forced

2472 with their libraries, all of the other vendors will be forced, by

forcing

1166 used for assignment compatibility forcing an assigned object to inherit

foremost

80 Steve Yegge, making a roundabout comparison with Functional programming, writes, "Object Oriented Programming puts the Nouns first and foremost. Why would you go to such lengths to put one part of speech on a pedestal? Why should one kind of concept take precedence over another? It's not as if OOP has suddenly made verbs less important in the way we actually think. It's a strangely skewed perspective."

formalizing

34 There have been several attempts at formalizing the concepts used in object-oriented programming. The following concepts and constructs have been used as interpretations of OOP concepts:

formally

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

forthcoming

1235 forthcoming, however see APPENDIX E).

forum

1595 Class offers an open editorial forum on numerous Object

foundations

2556 Foundations, Champaign, Illinois, 1992. Copies may be obtainable

foxpro

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.

framework-like

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

fraser

1660 > HyperDesk (Westborough MA) HD-DOMS, rich_fraser@hyperdesk.com

freeing

2212 savings while freeing systems personnel to concentrate on critical

freely

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

freenet

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

frequent

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

frozen

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

ftx

1878 SunOs, Solaris, HP-UX, SGI Unix, Stratus FTX,

fuller

1659 Ian Fuller ian@cup.hp.com (408) 447-4722

funded

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

futile

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:

gained

2538 large projects. Intuition gained from smaller projects

gains

2687 *Integration with leading programming tools for maximum productivity gains

gaithersburg

2485 Lane, Suite 203, Gaithersburg, Maryland 20878. $225.

gang

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.

gap

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

gaps

818 programming gaps found in traditional structured analysis and design.

garcia

1380 2550 Garcia Avenue

garfinkels

1080 [Garfinkel 93, p80] and [Cox 91, pp 64-67]. To extend Garfinkels example with

gcsurvey

2337 gcsurvey.ps. [See APPENDIX E]

gec-mrc

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

gemstone

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

general-purpose

881 simulation language, and the later general-purpose language Simula 67 is now

generated

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

generations

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

geos

1367 GEOS (GeoWorks', written in Object Assembler, OO superset of 8086)

geoworks'

1367 GEOS (GeoWorks', written in Object Assembler, OO superset of 8086)

german

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

gestalt

793 proposes a "round-trip gestalt" design with analyze-design iterations and

gilb

811 [Gilb, 1988]

gilchrist

1431 Arnold, P., Bodoff, S., Coleman, D., Gilchrist, H., Hayes, F., An Evolution of

gk

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

glass

66 However, Niklaus Wirth (who popularized the adage now known as Wirth's law: "Software is getting slower more rapidly than hardware becomes faster") said of OOP in his paper, "Good Ideas through the Looking Glass", "This paradigm closely reflects the structure of systems 'in the real world', and it is therefore well suited to model complex systems with complex behaviours" (contrast KISS principle).

global

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

'global'

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

glossary

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

gorilla

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

government

831 software development and which is often required of government contractors

grady

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

graph-based

2525 Hoffman, D.M. and P.A. Strooper. Graph-Based Class Testing. In

graphs

417 with the parent class on top, but more demanding graphs (as is often the case

greatest

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

gretchen

1461 Monarchi, David and Puhr, Gretchen I. A Research Typology for Object-Oriented

groovy

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

ground

762 D, and many others, also share common ground with SA and other existing

groundwork

1611 groundwork for technology response to Request for Proposals (RFP)

grove

2670 Eveleigh House, Grove Street,

guess

2710 As much of this work is being done by SunSoft, my guess is that the

guidance

2617 Turner, C. D. and D. J. Robson, "Guidance for the Testing of Object-

guideus

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

guiding

767 91] provides support and emphasis on types and roles as guiding principles,

hacking

696 hacking and

hampshire

1652 Nashua, New Hampshire 03062-2698

handbook

2483 Berard, Edward. Project Management Handbook. Must be purchased

hand-management

2419 sometimes choose treadmill collectors [4] over hand-management because of its

hardcopy

2259 Hardcopy versions of all DOME documentation are available for a

harness

2699 A group of volunteers is building a C++ test harness for the automated

harper

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

harrold

2513 Harrold, Mary Jean, John D. McGregor, and Kevin J. Fitzpatrick,

haskel

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

hayes

1431 Arnold, P., Bodoff, S., Coleman, D., Gilchrist, H., Hayes, F., An Evolution of

hd

1724 CORBA Implementation Descriptions: HD_DOMS

heading

132 with the HEADING "subscribe".

headquarters

1795 retailers can distribute to end users throughout headquarters, all chain

heavily

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.

helm

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.

helps

1189 This helps to insure the semantic integrity of replacing objects and their

henderson-sellers

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

herding

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.

heterogenous

1873 DOME provides heterogenous distribution across many platforms

hicss

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

hidden

550 operations and a hidden local state.

hide

232 program should encapsulate or hide a single design decision... The interface

hides

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

highlight

2681 *Graphical test coverage to highlight any code not executed during test runs

highlights

2678 testing. Highlights from CenterLine literature:

high-powered

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

hinder

2390 4. Differing Memory Management Schemes Hinder Reuse

hindering

2301 incompatible, hindering reuse.

hoare's

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

hoax

76 Alexander Stepanov suggested that OOP provides a mathematically-limited viewpoint and called it "almost as much of a hoax as Artificial Intelligence. I have yet to see an interesting piece of code that comes from these OO people. In a sense, I am unfair to AI: I learned a lot of stuff from the MIT AI Lab crowd, they have done some really fundamental work....".

hockey

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.

holding

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

homograph

923 "Poly" means "many" and "morph" means "form". The homograph polymorphism has

horus

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

host

2665 specifically designed to operate in both host and target

hudak

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

hughes

857 Hughes Aircraft", IEEE Software, July 1991

iapx

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.

ibm's

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

ide

2084 NCR, HP Softbench Sun SPARCworks and Borland IDE.

identifiable

93 Smith and Tockey: "an object represents an individual, identifiable item,

identifier

2310 instance many C compilers limit expression nesting, identifier

idiom

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

idiosyncratic

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

ieee-comp

1441 and Design Methods - Comparison and Critique. IEEE-Comp, Oct, 1992, pp 22-39.

ignoring

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

illegal

445 same names for instance variables of subclasses illegal.

imminent

2003 2 is also imminent.

impl

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

implementation-dependent

2372 but explicit memory management requires implementation-dependent

implementing

2051 for implementing distributed systems:

implied

1042 but a newer template function is incomparably preferable, as implied in

imply

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

importance

2536 hierarchical testing. The importance of good physical

improvements

842 Level 4: Managed: A measurable basis for all improvements to the process.

'in

66 However, Niklaus Wirth (who popularized the adage now known as Wirth's law: "Software is getting slower more rapidly than hardware becomes faster") said of OOP in his paper, "Good Ideas through the Looking Glass", "This paradigm closely reflects the structure of systems 'in the real world', and it is therefore well suited to model complex systems with complex behaviours" (contrast KISS principle).

inadequate

2369 counting an inadequate substitute for true GC.

incidents

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

incomparably

1042 but a newer template function is incomparably preferable, as implied in

incompatibilities

2142 overcoming system incompatibilities, and middleware such as

incorporates

1923 scalable, flexible and maintainable. ORBeline incorporates PostModern's

incorporating

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

incorrect

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.

increased

1812 -- up to 400 percent increased performance, through quicker

increasing

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.

incremental-

806 Incremental-

increments

2317 decrements, three increments and six comparisons) and cannot reclaim

indefinitely

1330 lifetime and objects stored indefinitely in an OODB (which are persistent)

individually

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

indoctrinated

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

inefficient

2316 is inefficient (swapping two references will result in three

inevitably

364 bootstrapped). Reflective systems are inevitably reflexive (as are most

inferencing

974 Implicit parametric polymorphism can be implemented with type inferencing

inferred

266 whereby no method or object structure can be inferred in the general case.

infinite

341 1.5) What Is The Infinite Regress Of Objects And Classes? (Object-Oriented Technology)

influence

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

influential

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.

informative

1597 commentaries from software industry leaders, informative user

informed

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

infrequently

896 On resistance to change, system objects change infrequently while processes

inheriting

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.

inhibiting

2401 c) Value semantics store objects rather than references, inhibiting data

initialization

998 polymorphism with respect to assignment (and initialization, or replacement if

injection

174 injection rates during maintanance and debugging).

inlining

1228 efficiency tradeoff), and sources can cause inlining and create source code

innovations

2000 UnixWare Computer Innovations 4th Qtr

insight

1384 Insight ETHOS: On Object-Orientation in Operating Systems

installation

2262 Disk space and memory requirements are dependent on the installation

institution

1560 research institution or individual, whether

insulation

2540 ("Insulation") is also discussed.

insuring

1161 In many languages, a type has a single representation insuring all operations

integrates

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.

intel

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.

intension

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

intensive

2367 arrays and multiple inheritance). Intensive research [1] in garbage

inter-

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

interact

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

interchangeable

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

interchangeably

181 base class, and etc. will be used interchangeably.

interconnects

1618 distributed environments and seamlessly interconnects multiple

interface-

1819 HP's DOMF includes the object request broker, interface- definition-

interfaced

1091 Dynamic binding allows new objects and code to be interfaced with or added to

interior

2366 objects, lack of polymorphism, and problems with interior pointers (e.g.

intermediaries

5 In contrast, the object-oriented approach encourages the programmer to place data where it is not directly accessible by the rest of the program. Instead, the data is accessed by calling specially written functions, commonly called methods, which are either bundled in with the data or inherited from "class objects." These act as the intermediaries for retrieving or modifying the data they control. The programming construct that combines data with a set of methods for accessing and managing those data is called an object. The practice of using subroutines to examine or modify certain kinds of data, however, was also quite commonly used in non-OOP modular programming, well before the widespread use of object-oriented programming.

inter-module

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

internals

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

internet

53 The Document Object Model of HTML, XHTML, and XML documents on the Internet have bindings to the popular JavaScript

interpret

2136 To do this effectively, middleware must be able to interpret the

interpretations

34 There have been several attempts at formalizing the concepts used in object-oriented programming. The following concepts and constructs have been used as interpretations of OOP concepts:

interpreter

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.

interpreters

2294 interpreters often suffer from this. The usual result is that the

intersection

987 MI provides an interesting example here, as it is set intersection with an

interviews

2319 are the Interviews C++ graphics library and the Unix file system (the

int'l

2330 in Memory Management (proceedings of 1992 Int'l Workshop on Memory

introduce

151 It is primarily intended to introduce new terms. See [Cardelli 85] for

introducing

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.

introduction

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)

introductory

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

introspective

351 terminology, an introspective protocol provides a read only capability (e.g.

ints

1218 many instantiations such as a Stack of ints, a Stack of any fundamental

in-turn

2535 dependencies. This in-turn permits incremental,

invariant

1188 with mechanisms similar to Eiffel's pre-, post-, and invariant conditions.

invent

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

invented

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

inventor

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

investigating

14 At ETH Z?rich, Niklaus Wirth and his colleagues had also been investigating such topics as data abstraction and modular programming (although this had been in common use in the 1960s or earlier). Modula-2 (1978) included both, and their succeeding design, Oberon, included a distinctive approach to object orientation, classes, and such. The approach is unlike Smalltalk, and very unlike C++.

investigation

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

invisible

256 from outside of their class (they are not only private, but invisible).

invocations

2069 object activation when method invocations are required,

involves

455 window changing into an icon and then back again, which involves changing a

iplbath

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

iris

1845 CORBA Implementation Descriptions: Iris RDOM

is-a-member-of

1001 is-a-member-of form in OO). Emerald provides another example of an object-

issued

1621 contained response to the Request for Proposals (RFP) issued by

iterative

790 incremental, iterative, evolutionary, concurrent and situational nature of

iterator

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.

iv

1457 Press, Hawaii) 1993, Vol. IV, pp. 689-698.

ivan

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

jacques

2331 Management, Sept. 1992, St. Malo, France, Yves Bekkers and Jacques Cohen,

james

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

jean

2513 Harrold, Mary Jean, John D. McGregor, and Kevin J. Fitzpatrick,

jgraham

2512 jgraham@axion.bt.co.uk.

jim

734 stresses the reusability of analysis and design, not code. - Jim Neighbors

joined

942 joined as specializations of the new "Universal" polymorphism.

joint

1540 from a joint proposal (named "CORBA") of Hewlett-Packard, NCR Corp.,

jointly

1777 DCE standard. This object- enabling technology specification was jointly

jones

1202 [Jones 92] are all examples of OO systems providing subtype polymorphism.

jose

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

joss

2072 JOSS

jscript

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.

judicious

401 [Cardelli 85]). It would be more judicious to have discussions on how

july-august

2588 Magazine, Vol. 2, No. 2, July-August 1992, pp17-18. SIGs

jungle

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

jurik

1407 EVB [Jurik 92]

justify

963 related, but are distinct enough in implementation to justify separate

kaiser

2566 Perry, D.E. and G.E. Kaiser, "Adequate Testing and Object-Oriented

kang

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

kaufmann

2274 published by Morgan Kaufmann Publishers, San Mateo, California

kay's

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.

kerberos-based

1728 storage, a Kerberos-based authentication service, a location service, a

kevin

2513 Harrold, Mary Jean, John D. McGregor, and Kevin J. Fitzpatrick,

keyword

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

keywords

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

kiczales

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

kids

2427 3.10) What Can I Do To Teach OO To The Kids? (Object-Oriented Technology)

kiss

66 However, Niklaus Wirth (who popularized the adage now known as Wirth's law: "Software is getting slower more rapidly than hardware becomes faster") said of OOP in his paper, "Good Ideas through the Looking Glass", "This paradigm closely reflects the structure of systems 'in the real world', and it is therefore well suited to model complex systems with complex behaviours" (contrast KISS principle).

kits

741 objects, and kits [frameworks]. OORA analysts and OOD designers will

kitson

853 Kitson, D.H. and Masters, S. "An Analysis of SEI Software Process Assessment

klimas

2527 Klimas, Edward "Quality Assurance Issues for Smalltalk Based Applications",

knowledgeware

2242 ERwin,, Popkin,, and Knowledgeware,.

kristen

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

l

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

lab

76 Alexander Stepanov suggested that OOP provides a mathematically-limited viewpoint and called it "almost as much of a hoax as Artificial Intelligence. I have yet to see an interesting piece of code that comes from these OO people. In a sense, I am unfair to AI: I learned a lot of stuff from the MIT AI Lab crowd, they have done some really fundamental work....".

labor

2211 These beneficial functions have resulted in measurable time and labor

lakoff

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

lalonde

378 [LaLonde 90]) and can be used as an is-a-kind-of (or is-a) relationship or

lan

2035 IP, NetBIOS, Lan Manager NetBEUI and

lane

2485 Lane, Suite 203, Gaithersburg, Maryland 20878. $225.

language-neutral

1787 system administrators and end users language-neutral, enterprise-wide,

largely

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.

large-scale

1509 and use of large-scale distributed applications (open distributed

largest

2139 security; and scale up to accommodate even the largest systems. When

lastname

870 subscribe firstname, lastname, e-mail address.

late-bound

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

launched

1938 Orbix was launched in June 1993 as the first full and complete implementation

law

66 However, Niklaus Wirth (who popularized the adage now known as Wirth's law: "Software is getting slower more rapidly than hardware becomes faster") said of OOP in his paper, "Good Ideas through the Looking Glass", "This paradigm closely reflects the structure of systems 'in the real world', and it is therefore well suited to model complex systems with complex behaviours" (contrast KISS principle).

lawrence

1870 1st Floor, Lawrence House, 1A Morrell St, Leamington Spa, England CV32 5SZ

layered

2131 middleware - run-time system software that is layered between an

lead

656 lead to the use of switch statements based on type or complex coding in many

leaders

1597 commentaries from software industry leaders, informative user

leak

2680 *Automatic memory leak detection on executables to optimize memory use

leamington

1870 1st Floor, Lawrence House, 1A Morrell St, Leamington Spa, England CV32 5SZ

leavens

2543 Leavens, G. T., "Modular Specification and Verification of

leaving

2400 multiple containers, leaving many memory management issues unaddressed.

lecture

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

length

2311 length, include file nesting and macro stack depth. This causes

lengths

80 Steve Yegge, making a roundabout comparison with Functional programming, writes, "Object Oriented Programming puts the Nouns first and foremost. Why would you go to such lengths to put one part of speech on a pedestal? Why should one kind of concept take precedence over another? It's not as if OOP has suddenly made verbs less important in the way we actually think. It's a strangely skewed perspective."

lessons

2545 Love, Tom. Object Lessons. SIGS Books, 588 Broadway #604, New York, NY

lex

1347 ODMG-93 along with ODL lex and yacc files. In the future, we will be

licata

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

licence

1681 Complete implementation of CORBA. Free academic; com. eval licence avail.

license

1689 Windows 3.1, 12 user license: $99.

lifetime

1330 lifetime and objects stored indefinitely in an OODB (which are persistent)

lifetimes

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

limit

2310 instance many C compilers limit expression nesting, identifier

limiting

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

limits

2309 the assumptions behind the chosen limits no longer apply. For

linear

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

link

2320 link count).

linkage

316 linkage, as in C++).

linn

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.

lisp-based

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

listed

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

listing

306 to the following listing, which is based on the number of levels of distinct

literals

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)

littered

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

lives

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

locality

2325 [Further, GC can perform compaction improving locality of reference.]

localized

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

locals

1328 viewed as a hierarchy, with locals

located

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

locations

2238 locations, and it is also interoperable. By conforming to the SQL

location-transparent

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

log

1573 log <info> (logs info on server)

logs

1573 log <info> (logs info on server)

london

1964 Object World in London, England last October. Orbix for Microsoft Windows

long-

1607 of developers, operating systems and hardware; and enhance long-

longest

1331 having the longest. Persistent object stores do not support query or

long-lived

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

loops

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.

loose

1097 and loose coupling. Another benefit is that code complexity increases not

looser

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

los

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

losing

826 fear that great discrepancies could occur between OOD and OOP by losing sight

love

2545 Love, Tom. Object Lessons. SIGS Books, 588 Broadway #604, New York, NY

low-level

2373 low-level knowledge of how memory is structured. For example, programmers

lr

2671 Bath BA1 5LR

lua

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.

luca

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

lucid

1985 SunOS 4.1 Lucid 3.1 NOW

ma

1660 > HyperDesk (Westborough MA) HD-DOMS, rich_fraser@hyperdesk.com

mac

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.

mach

1368 Mach (CMU, supports BSD 4.3, really message-based)

macro