EncycloZine

Small-scale and classical software design and programming is based on a functional task view, in which a problem is broken down into steps to be performed by the computer. This methodology has been found to result in high complexity for larger-scale programs, and doesn't model real-world systems effectively. This has led to the development of an "object-oriented" paradigm, in which the software components are designed to mirror the entities in the application domain. This approach improves the conceptual modelling process, and reduces development and maintenance costs. It is especially well-suited to real-time control and data acquisition systems.

Object-oriented languages are outgrowths of functional languages. In object-oriented languages, the code used to write the program and the data processed by the program are grouped together into units called objects. Objects are further grouped into classes, which define the attributes objects must have. A simple example of a class is the class Device. Objects within this class might be Sensor and Actuator.

Objects also have certain functions associated with them, called methods. The computer accesses an object through the use of one of the object's methods. The method performs some action to the data in the object and returns this value to the computer.

Classes of objects can also be further grouped into hierarchies, in which objects of one class can inherit methods from another class. The structure provided in object-oriented languages makes them very useful for complex programming tasks.

Data Abstraction

The fundamental problem of classical functional programming arises from the separation of function and data; this is where the object-oriented methodology offers a new perspective. It can be described in 3 levels:

1. An object is a data structure, representing some aspect of a problem (e.g. a device reading), encapsulated by a set of related functions. The 'encapsulation' ensures the integrity of the data.
2. We recognise similarities between objects in the real world, and group them into classes (e.g. 'cars'). An object is then a particular instance of a class.
3. Further, some classes are similar to others, and can be described by stating their differences; like children, classes may inherit characteristics from their 'parents'.

The first level provides a firm, intuitively satisfying conceptual foundation for software design. The second level introduces a facility for generalisation, and the third level brings out the full possibility for software re-use, e.g. as in the SMALLTALK language. However, the conceptual clarity afforded by encapsulation alone is invaluable for a software design technique, and has the strong advantage of being directly implementable in most commonly used scientific programming languages such as Fortran and C.

An object is an instance of an abstract data type: the encapsulated data (or resource) can be accessed only by the implemented functions, and the external specification need not reveal the object's internal structure. Encapsulation (containment), brings the benefits of:

• localisation and cohesiveness of program text; conceptually related elements of program text are found in the same region, which facilitates comprehension. Objects may be analysed independently of each other, save for their interface couplings;
• protection and decoupling of the contained resources from other objects; this minimises the 'ripple effect' of changes, which Will be constrained by the scope;
• concealment (information hiding) of implementation decisions.

Objects can be designed to represent entities in the application, i.e. 'things' that are natural to the problem. Entities in the problem domain are to be mapped onto objects in the software domain. We may therefore design a software system under a new paradigm, which we shall call 'conceptual modelling'. This is a transformation from a problem domain to a software domain, at a high level of abstraction. The transformation is simplified by choosing natural and mutually compatible representations for the domains. The basic partitioning unit - module/object - is defined in such a way as to allow maximal decoupling between units, i.e. they are highly self-contained. The conceptual model supports both requirements definition and system design, and serves as a bridge between the user and the designer. The spirit of 'top-down' analysis is retained, but now acting on software objects - a combination of functions and data - rather than on functions alone.

Objects and Classes

Object-orientation is based on objects and classes. By providing first class support for the objects and classes of objects of an application domain, the object-oriented paradigm precepts better modeling and implementation of systems. Objects provide a canonical focus throughout analysis, design, and implementation by emphasizing the state, behavior, and interaction of objects in its models, providing the desirable property of seamlessness between activities.

Within the OO context, a class is a specification of

• structure (instance variables),
• behavior (methods),
• and inheritance (parents, or recursive structure and behavior) for objects.

Classes can also specify access permissions for clients and derived classes, visibility and member lookup resolution. This is a feature-based or intensional definition, emphasizing a class as a descriptor/constructor of objects (as opposed to a collection of objects, as with the more classical extensional view, which may begin the analysis process).

The Booch Method of Object-Oriented Software Development

Booch defines two processes describing the format of Object Oriented development:

Macro process:

• Establish core requirements (conceptualization).
• Develop a model of the desired behavior (analysis).
• Create an architecture (design).
• Evolve the implementation (evolution).
• Manage post delivery evolution (maintenance).

• Identify the classes and objects at a given level of abstraction.
• Identify the semantics of these classes and objects.
• Identify the relationships among these classes and objects.
• Specify the interface and then the implementation of these classes and objects.

The micro process represents the daily activity of of a small team of developers or an individual developer, The analysis and design phases are intentionally blurred.

The macro process acts as the controlling framework of the micro process. It represents the activities of the development team on the time scale of weeks to months at a time. The guiding philosophy of the macro process is that of incremental development: the system as a whole is built up step by step, each successive version consisting of the previous ones plus a number of new functions. This approach is extremely well suited to the object oriented paradigm.

C++

C++ is a general-purpose programming language with a bias towards systems programming, that supports low-level programming in traditional styles, data abstraction, object-oriented programming, and generic programming.

C++ was initially developed from the C programming language by the addition of facilities for object-oriented programming from the SIMULA programming language. Over the years, the flexibility and generality of the facilities offered by C++ has been greatly improved without compromising run-time efficiency. C++ is distinguished among programming languages by a combination of efficiency (like C and Fortran) and abstraction facilities.

The "abstraction facilities" provided by C++ allow programs to be expressed in terms natural to application designers (rather than lower-level computer-oriented terminology). Some of these abstraction facilities are also provided by "object-oriented" languages such as Smalltalk and Java, others are only available in experimental "functional" languages. The C++ abstraction mechanisms are distinguished by their run-time efficiency.

Bjarne Stroustrup is the designer and original implementor of C++. C++ has been standardized by ANSI (The American National Standards Institute), BSI (The British Standards Institute), DIN (The German national standards organization), several other national standards bodies, and ISO (The International Standards Organization).

CORBA (Common Object Request Broker Architecture)

CORBA is an architecture and specification for creating, distributing, and managing distributed program objects in a network. It allows programs at different locations and developed by different vendors to communicate in a network through an "interface broker." CORBA defines the Interface Definition Language (IDL) and the Application Programming Interfaces (API) that enable client/server object interaction within a specific implementation of an Object Request Broker (ORB).

CORBA was developed by a consortium of vendors through the Object Management Group (OMG), which currently includes over 500 member companies. Both ISO and X/Open have sanctioned CORBA as the standard architecture for distributed objects (which are also known as components).

CORBA 2.0, adopted in December of 1994, defines true interoperability by specifying how ORBs from different vendors can interoperate.

The (ORB) is the middleware that establishes the client-server relationships between objects. Using an ORB, a client can transparently invoke a method on a server object, which can be on the same machine or across a network. ORB support in a network of clients and servers on different computers means that a client program (which may itself be an object) can request services from a server program or object without having to know where the server is in a distributed network or what the interface to the server program looks like.

The ORB intercepts the call and is responsible for finding an object that can implement the request, pass it the parameters, invoke its method, and return the results. The client does not have to be aware of where the object is located, its programming language, its operating system, or any other system aspects that are not part of an object's interface. In so doing, the ORB provides interoperability between applications on different machines in heterogeneous distributed environments and seamlessly interconnects multiple object systems.

To make requests or return replies between the ORBs, programs use the General Inter-ORB Protocol (GIOP) and, for the Internet, its Internet Inter-ORB Protocol (IIOP). IIOP maps GIOP requests and replies to the Internet's Transmission Control Protocol (TCP) layer in each computer.

Java

UML (Unified Modeling Language)

UML (Unified Modeling Language) is a standard notation for the modeling of real-world objects as a first step in developing an object-oriented program. UML is a graphical language for visualizing, specifying, constructing and documenting the artifacts of software systems. It is the proper successor to the object modeling languages of three leading object-oriented methods: Booch, Object Modeling Technique (OMT) and Object-Oriented Sofware Engineering (OOSE).

UML was originally added to the list of OMG adopted technologies in 1997, and has become the industry-standard language for specifying, visualizing, constructing, and documenting the artifacts of software systems. It simplifies the complex process of software design, making a "blueprint" for construction. The UML definition incorporates:

• Grady Booch's methodology for describing a set of objects and their relationships
• James Rumbaugh's Object-Modeling Technique (OMT)
• Ivar Jacobson's approach which includes a use case methodology

UML is a third-generation method for specifying, visualizing, and documenting the artifacts of an object-oriented system under development. UML represents the unification of the Booch, Objectory, and OMT methods, and additionally incorporates ideas from a number of other methodologists, most notably Wirfs-Brock, Ward, Cunningham, Rubin, Harel, Gamma, Vlissides, Helm, Johnson, Meyer, Odell, Embley, Coleman, Coad, Yourdon, Shlaer, and Mellor. UML is the direct and upwardly compatible successor to the Booch, Objectory, and OMT methods. By unifying these three leading object-oriented methods, UML provides the basis for a common, stable, and expressive object-oriented development method.

UML has been fostered and now is an accepted standard of the Object Management Group (OMG), which is also the home of CORBA, the leading industry standard for distributed object programming. Vendors of CASE products are now supporting UML and it has been endorsed by almost every maker of software development products, including IBM and Microsoft (for its Visual Basic environment).