121 Interface - e.G. Gui

135 based approaches (e.g. Smalltalk handles) allow powerful dynamic typing, as

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

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

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

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

658 this should only be used as necessary, e.g. if the implementation language

691 point often mistaken in comp.object. E.g. simple statically

704 and OOP(G).

716 operational characteristics (e.g. reliability, availability, performance)".

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

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

1079 programming and user interaction (e.g. GUIs). Examples can be found in

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

1448 G. van den Goor, S. Hong and S. Brinkkemper,

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

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

2273 edited by: R.G.G. Cattell

2348 and Appendix G.

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

2497 Doong, Roong-Ko and Phyllis G. Frankl, "Case Studies on Testing

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

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

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

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

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

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

interface

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.

121 Interface - E.g. GUI

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

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

265 object other than the receiver is only satisfying an abstract type interface,

365 quality compilers), providing a direct program interface to the system.

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

549 - It supports objects that are data abstractions with an interface of named

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

1038 functions using exactly the same interface - as is provided by virtual

1171 common base interface specification.

1332 interactive user interface facilities, as found in a fully supported OODBMS.

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

1538 In late 1991 OMG adopted its first interface technology, for the Object

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

1820 language compiler, static and dynamic invocation interface and interface

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

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

1936 for the first time, as well as an upgraded Interface Repository, a new

1948 The improved Interface Repository is an integral part of IONA's CORBA

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

2163 DOME is an open system that provides an interface between all of a

2179 the message interface to an object, and dynamically invoke an object.

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

2646 collections, or numbers. It is not suitable for testing user interface

2683 *Programmatic interface to output files and cumulative code coverage

pattern

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

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.

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

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

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

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

section

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)

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.

176 static typechecking requirements are dropped. See section 2.5.

296 [See also section 1.6]

380 compatibility (see section 2.7).

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

521 latter part of section 1.9 for an example of why MI is important.

612 See also section 1.19 below for a discussion on the functional (prefix) verses

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

667 requirement 1 for OO languages and Section 1.2 on Encapsulation) and also

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

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

1010 simplicity. See also section 2.7.

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

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

1122 [Mugridge 91]. See also section 2.3.

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

1133 See section 3.4 for a categorization of common OO languages by type system.

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

1156 See also section 2.1).

1238 as described in section 1.4. See also [Coplien 92].

1426 See also section 1.21 for a discussion on OOA

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

2269 This section is expected to grow considerably in the future.

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

2440 Written Material section.

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

--

116 Use-Cases and Actors - Actors <--> Use-Cases <--> Object Model Objects

943 |-- parametric

944 |-- universal --|

945 | |-- inclusion

946 polymorphism --|

947 | |-- overloading

948 |-- ad hoc --|

949 |-- coercion

1500 -- Richard Soley

1677 > NCR 'Cooperative Frameworks' -- a Distributed Object Foundation

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

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

1761 without modification -- on any other system that supports DCE. HP ORB Plus

1810 -- easier deployment, with the ability to run multiple HP

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

1815 -- run-time version, for full production deployment; and

1816 -- easier development, with remote object browsing so

2008 CORBA Implementation Descriptions: NCR 'Cooperative Frameworks' -- a Distributed Object Foundation

2013 OF 'Cooperative Frameworks' --

2038 toolkits (others are planned for future release) --

2067 characteristics -- rather than names

2100 Address -- Software Products Division-Columbia

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

memory

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.

1390 as well as basic OS i ssues such as memory, file, tasking management.

2262 Disk space and memory requirements are dependent on the installation

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

2355 1. Manual Memory Management Breaks Encapsulation.

2362 Attempts to encapsulate memory management with reference counting, the "poor

2370 2. Implementation Hiding is not Compatible with Manual Memory Management

2372 but explicit memory management requires implementation-dependent

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

2375 However, to manage memory explicitly, a program has to know if it has a copy

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

2381 Manual memory management must make assumptions about a program's order of

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

2390 4. Differing Memory Management Schemes Hinder Reuse

2391 Because no memory management scheme is universal enough for all applications,

2392 manually managed components and libraries often use incompatible memory

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

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

2400 multiple containers, leaving many memory management issues unaddressed.

2405 Any components or libraries that use containers with different memory

2408 It is not enough to merely find fault with manual memory management. One also

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

2677 code. Also does some memory debugging (similar to Purify) and regression

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

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

single

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

171 switch statement on variant parts with a single call, reducing code size

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

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

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

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

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

459 Smalltalk provide dynamic inheritance in some form or other. Single hierarchy

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

523 should be associations and inheritance should be reserved for a single

589 hybrid systems). However, all objects may be classes in single hierarchy

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

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

643 switching on a single argument per call (but for 2 levels), consistently

675 are dropped, multiple-polymorphism results. Thus a single overridable function

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

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

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

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

1217 parameterized base type. This allows a single Stack class to provide

1512 (OMA) Guide document. This document outlines a single terminology for

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

1811 Distributed Smalltalk-based applications on a single system;

1891 be built and tested on a single machine using local resources.

2150 applications and data into a single system. With DOME, companies can

2209 environments on a single node

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

garbage

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

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

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

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

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

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

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

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

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

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

2336 garbage

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

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

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

2363 man's garbage collector", are usually misguided. Reference counting has worse

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

2407 5. Garbage Collection Works

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

2410 versions of garbage collection were merely crude implementations of

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

2413 mature technology.[1] Many object-oriented languages specify garbage

2415 commercially supported garbage collector that can transparently and

2417 Garbage collected programs are usually as fast and responsive as

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

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

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

access