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

1653 > HP ORB Plus and HP Distributed Smalltalk

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

1661 Runs on SPARC, HP

1737 CORBA Implementation Descriptions: HP ORB Plus and HP Distributed Smalltalk

1738 SUBJECT: HP INTRODUCES DISTRIBUTED-COMPUTING SOLUTION FOR BUILDING

1744 With HP ORB Plus, programmers can develop scalable, object-based

1745 applications that can be distributed throughout the enterprise. HP also

1746 introduced an enhanced version of HP Distributed Smalltalk.

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

1751 HP believes it is best positioned to help customers take advantage of

1752 distributed computing. HP provides a wide variety of distributed-computing

1756 HP ORB PLUS: CORBA AND DCE COMBINED

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

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

1772 HP ORB PLUS DETAILS

1773 HP ORB Plus consists of several components: the Distributed Object

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

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

1784 interoperability of distributed applications across HP and IBM platforms.

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

1797 HP DISTRIBUTED SMALLTALK 2.0

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

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

1804 Applications built using HP Distributed Smalltalk currently run without

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

1809 New HP Distributed Smalltalk 2.0 features include the following:

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

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

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

1827 HP's limited release of HP ORB Plus to key developers is designed so that

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

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

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

1962 HP

2084 NCR, HP Softbench Sun SPARCworks and Borland IDE.

implementation

16 More recently, a number of languages have emerged that are primarily object-oriented yet compatible with procedural methodology, such as Python and Ruby. Probably the most commercially important recent object-oriented languages are Visual Basic.NET (VB.NET) and C#, both designed for Microsoft's .NET platform, and Java, developed by Sun Microsystems. Both frameworks show the benefit of using OOP by creating an abstraction from implementation in their own way. VB.NET and C# support cross-language inheritance, allowing classes defined in one language to subclass classes defined in the other language. Developers usually compile Java to bytecode, allowing Java to run on any operating system for which a Java virtual machine is available. VB.NET and C# make use of the Strategy pattern to accomplish cross-language inheritance, whereas Java makes use of the Adapter pattern[citation needed].

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

124 Component Objects - Utility and Implementation hiding objects

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

150 Below is a simple example to show a most trivial case of OO implementation.

168 [Stroustrup 90] covers the implementation details of virtual member functions

463 implementation discussion in C++.

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

698 however, consider OOP as the implementation

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

777 The usual progression is from OOA to OOD to OOP (implementation) and this

823 selection from among various languages for implementation (choosing the best

825 like OOA and OOD getting too far from OOP (implementation independent), for

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

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

968 implementation is used.

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

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

1641 compliant implementation of CORBA and is available on these platforms:

1654 Full implementation of the OMG CORBA 1.1 Object Request Broker. Also DOMF.

1676 First full and complete implementation of OMG's CORBA.

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

1703 CORBA Implementation Descriptions: The ELECTRA Toolkit

1716 implementation" developed at Cornell, Ithaca NY.)

1724 CORBA Implementation Descriptions: HD_DOMS

1737 CORBA Implementation Descriptions: HP ORB Plus and HP Distributed Smalltalk

1845 CORBA Implementation Descriptions: Iris RDOM

1866 CORBA Implementation Descriptions: Object-Oriented Technologies DOME

1918 CORBA Implementation Descriptions: ORBELINE - The SMART Object Request Broker

1919 ORBeline is a complete implementation of OMG's Common Object Request

1929 CORBA Implementation Descriptions: Orbix

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

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

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

2052 - Naming - network implementation of X.500 directory

2085 Implementation - implementation is for client

2120 CORBA Implementation Descriptions: SUITESOFTWARE (SuiteDOME)

2205 - Implementation of additional protocols through a

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

2371 Implementation hiding is a pillar of object-oriented programming,

method

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.

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.

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.

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.

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

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.

177 The terms method

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

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

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

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

422 or to add a method to a parent class is an example.

429 inherited by any class requiring them. Method combination, or calling

533 (virtual in Simula and C++) method in a derived class, thus providing

536 a method is invoked on an object of the base class, the derived class method

537 is executed overriding the base class method, if any. Overriding in Simula

592 1.18) What Is A Method? (And Receiver And Message) (Object-Oriented Technology)

593 A method implements behavior, which is defined by [Booch 91, p80]:

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

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

602 notations for invoking a method, and this invocation can be called a message

617 more than one parameter can be used in the selection of a method. Lack of

641 method, but perhaps exponentially. This should be distinguished from double

682 There is some concern about the efficiency of run-time method selection as

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

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

1056 function is invoked. This is the stored method from the derived class that

1057 overrode the virtual method from its base class, providing specialized behavior

1086 cut, are available in the receiving object, the particular method being

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

1181 templates), as any method matching a required signature is accepted,

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

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

2069 object activation when method invocations are required,

2397 the appropriate method.

support

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)

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.

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.

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

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:

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.

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.

208 languages providing high quality support for rapid prototyping, although this

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

519 systems support Multiple Inheritance by employing semantic resolution

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

545 provide inheritance and polymorphism. Ada95 and Modula-3; however, support

564 languages and perhaps object id's for unique objects. Object id's support the

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

659 doesn't support multiple-polymorphism and either efficiency considerations

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

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

1094 as each object knows what operation to support. It also allows a reduction in

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

1318 opposed to a purely value-oriented approach) and because of support for methods

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

1693 support for heterogeneous environments, support for Remote Data Access

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

1754 business benefit, and offers worldwide support and training programs,

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

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

1905 - integral support for GUI development,

2062 support object persistence. Persistent objects can be

2158 - support for heterogeneous environments

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

2214 o Support for Heterogeneous Environments

2248 Support and Deliverables

2249 Customer Support

2250 SUITESOFTWARE places particular emphasis on support and continuing

2253 to problems. SUITESOFTWARE `s support staff is available by

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

2684 to support batch-mode and regression testing

2686 *Complete C and C++ language support

2702 etet_support@uel.co.uk

functions

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.

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.

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.

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

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.

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

158 methods (Smalltalk) or member functions (C++) which are equivalent to a

168 [Stroustrup 90] covers the implementation details of virtual member functions

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

246 data and member functions) may be accessed from anywhere. A Stack's Push and

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

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

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

625 Multiple-polymorphism allows specialized functions or methods to be defined to

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

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

676 declared in a base class may have several functions overriding it in a derived

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

992 require explicit instantiation of its template functions, formal generic

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

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

1039 functions - is sometimes called "polymorphism".

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

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

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

1071 usage must have a consistent way of accessing these functions, as achieved thru

1124 restrictions include only allowing a common set of base class functions (or

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

1211 and functions with types. This is useful for parameterized classes and

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

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

1233 languages. One such popular functional language is ML, in which all functions

1524 3) the Object Services, which will provide the main functions for

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

2061 communication between internal ORB functions is used to

2133 distributed, heterogeneous environment, supplies the functions that

2211 These beneficial functions have resulted in measurable time and labor

2358 of the component nearly impossible. For example, methods and functions

based

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.

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.

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.

110 covers "Identifying Key Abstractions" for objects and classes based on an

134 based, capability-based, and simple static-based approaches. Descriptor-

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

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

282 group division, distinction, or rating based on quality, degree of

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

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

498 (typing based on subclassing, or subclass polymorphism), since only an object

559 Stroustrup's first edition of [Stroustrup 91, '86 p. 37] defines object based

561 programming often referred to as "object based"", which is quite different

613 message based (receiver based) notation.

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

651 The addition expression above will invoke the correct "+" function based on the

655 switching to the "fn" function based on the type of "one" also. This could

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

668 violates subtype polymorphism, because only subclass polymorphism is based on

736 relevant information in a domain based on the study of existing systems and

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

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

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

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

1107 class inherits from. With static typing and inclusion polymorphism based on

1168 based on class, or subclass polymorphism). This insures all operations to be

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

2019 product, and are based on NCR's submission to OMG.

2054 - Logging - provides local and server based error

2066 system and invoking targeted services based on service

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

dome