1540 From a joint proposal (named "corba") of Hewlett-Packard, ncr Corp.,

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

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

2009 From: Randy Volters <randy.volters@columbiasc.ncr.com>

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

2012 NCR ANNOUNCES BETA AVAILABILITY

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

2018 1991 as "the frameworks" part of the NCR COOPERATION(TM)

2037 NCR Cooperative Frameworks currently has two portable ORB

2077 NCR Cooperative Frameworks run on multiple UNIX platforms,

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

2084 NCR, HP Softbench Sun SPARCworks and Borland IDE.

2094 Product interoperability - Full interoperability between NCR

2099 NCR Corporation (An AT&T Company)

2110 Email: Randy.Volters@ColumbiaSC.NCR.COM

2113 NCR, AT&T's computer business, brings computing and

object-

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

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

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.

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

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

510 The former is a kind of language dependent feature commonly found in object-

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

1036 The use of derived classes and virtual functions is often called "object-

1110 This also provides a good example of differing definitions among object-

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

1468 Wirfs-Brock, R.J. and Johnson, R.E., "Surveying Current Research in Object-

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

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

1788 heterogeneous support for building, managing and using distributed object-

2383 object. While this is often possible in procedural languages, the object-

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

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

orbix

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

1929 CORBA Implementation Descriptions: Orbix

1930 Orbix

1935 The latest release of Orbix, Version 1.2, includes an Object Loader function

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

1940 Architecture (CORBA) standard. With Orbix, programmers can develop

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

1945 easily integrate Orbix applications with existing data stores be they

1954 requests, and has made it easier for users to integrate Orbix with their

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

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

1961 out versions of Orbix for Microsoft Windows NT, Silicon Graphics IRIX and

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

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

1967 demonstrated interoperability between IONA's Orbix running on Microsoft

1979 The full Orbix availability and release schedule looks like:

2002 Release of Orbix on OS

reuse

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.

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.

118 Frameworks*(Typical) - Abstract MO meant for reuse and extension

360 of object-oriented reuse, since the compiler itself is reused thru

420 Differential programming is the use of inheritance to reuse existing classes

483 Inheritance also provides for code and structural reuse. In the above Computer

487 of reuse takes advantage of the is-a-kind-of relationship. Class libraries

488 also allow reuse between applications, potentially allowing order-of-magnitude

516 to reuse code and to model the real world in a meaningful way.

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

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

1606 encourages reuse of code; allows useful integration across lines

1803 storage mechanism to facilitate the reuse of objects.

2301 incompatible, hindering reuse.

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

2390 4. Differing Memory Management Schemes Hinder Reuse

2422 are generally more reliable and easier to develop, maintain, and reuse than

statically

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.

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

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

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

609 If done statically, this can be referred to as invocation, and message passing

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

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

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

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

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

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

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

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

1144 "pure" statically (or strongly) checked parametric polymorphism, by Strachey's

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

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

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

version

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

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.

836 version of the CMM for individuals [Humphrey 95]. Next should follow a team-

966 where each instantiation creates a specialized version of the code allowing

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

1732 now, and a NetWare version is in the works. Submitted a C++ language

1746 introduced an enhanced version of HP Distributed Smalltalk.

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

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

1829 cycle. The initial version will work with the C++ programming language.

1914 DOME was first released in August 1993; version 2 in May 1994.

1935 The latest release of Orbix, Version 1.2, includes an Object Loader function

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

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

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

2428 Smalltalk (in its original 1972 version) was initially intended to make

written

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.

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.

647 If all of the above types are Numbers, code can be written without concern for

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

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

1369 NachOS (written in C++, OS teaching

1374 Spring (Sun, written in C++)

1375 PenPoint OS (Go, written in C++)

1392 It reviews other designs such as Clouds and Choices which where written

1393 It reviews other designs such as Clouds and Choices which where written

1831 interoperability is planned so objects written in different languages can be

2278 written for the FAQ by Paul Johnson and the second is from the FAQ author's

2440 Written Material section.

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

2478 3.11) What Is Available On Object-Oriented Testing? Written Material

2643 which includes a simple Tester class written by Bruce Samuelson

2660 operation. Cantata is suitable for testing software written in

abstract

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

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

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

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.

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

94 unit, or entity, either real or abstract, with a well-defined role in the

118 Frameworks*(Typical) - Abstract MO meant for reuse and extension

260 helping with abstract classes and overriding.

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

544 These languages support abstract data types (Adts) and not classes, which

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

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

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

1514 frameworks; an abstract framework for object-oriented systems; a set

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

2532 Portland, Oregon, October 21, 1993. Abstract:

binding