John D. McGregor
Clemson University, South Carolina, USA
The term object-oriented was one of the buzzwords of the late 1980s, but has become a major focus of the 1990s. In this volume of the Annals of Software Engineering, we present papers that cover a wide range of topics in this area. From a software engineering perspective, there are several threads that run through the papers: process and management, program representation, formal methods for specification. The papers also include such computer science topics as real-time and parallel programming.
Object-oriented refers to an integration of data and operations that represents a single entity of interest termed an object. This integration has been successful because it provides a view of the problem that is more comprehensive than that provided by a functional decomposition or a data-driven approach. Object-oriented development techniques utilize a modeling approach to problem solving in order to support the identification and specification of the concepts embodied in the problem.
Most object-oriented languages provide a facility for grouping objects that share common behavior into classes. In some languages, the class construct is used to provide a typing mechanism. The class definition is divided into a public interface that defines the behavior available from its objects and an implementation that is protected to some degree from access by other objects.
One class may be related to other classes by one of three basic relationships: association, composition or inheritance. Association is a peer-to-peer relationship in which an object of the first class and an object in the second class are at the same level of scope. A composition relationship exists between two objects if one object is created within the implementation of the second object. These first two relationships are operational relationships implemented by a pattern of messages between the objects. The inheritance relationship exists between two classes if one class is a specialization of the concept modeled by the other class. Inheritance is a definitional relationship implemented by a code generation tool such as a compiler or interpreter.
The object-oriented approach is maturing as evidenced by the appearance of second generation languages such as Java and comprehensive development methods such as the Unified Method. By combining constructs that have proven successful, these new techniques are improving practice and extending the range of possible representations. Java, for example, combines the concept of all classes inheriting from a single class, as found in Smalltalk, with much of the syntax of C++.
Methods for designing object-oriented software have evolved in several directions in recent years. Development methods produce a number of views of the system under development. The Use Case model presents a view of the system based on the uses provided by the system to its users. Statecharts model the state of the system or some subsystem. According to Case, Henderson-Sellers and Low, object-oriented methods have not yet integrated support for the persistence of objects. They present a meta-technique for modifying existing methods to incorporate this support. Dori and Goodman consider the integration of processes with objects at all levels throughout the development life cycle. An extensive example illustrates their approach.
Many techniques for program analysis require more detailed information than is contained in the high level models produced by development methods. McGregor, Malloy and Siegmund present a representation scheme that captures information about an object-oriented program in sufficient detail to support a number of program analysis activities. The representation combines the standard concepts of control flow and data dependency with the concepts of object flow and class inheritance relationships. The representation contains information to support a number of testing techniques such as automatic test case generation and selection of regression tests. Other applications that can be applied to the representation include metric data collection, compiler optimization and debugging tools. Welch, Lankala, Farr and Hammer present another approach to representing object-oriented software. Their representation focuses solely on the collection of metrics information. It makes use of the same control and data dependency information.
The discrete nature of objects and the clear separation of the specification of an object from its implementation have made the use of formal methods feasible. Dodani provides an overview of formal approaches for specification of object-oriented systems. His particular focus is on the need for consistency checks between the interacting classes within a system. The concepts are illustrated through a series of case studies. Lin, Kung and Hsia specialize this topic to consider real-time systems. They provide an object timed temporal logic for expressing the constraints represented by real-time properties. The community of objects is divided into three groups: control objects, persistent objects and fault objects. Each object type has specific properties and relationships with other object types. Jian extends VDM to support the development of parallel object-oriented programs. Two types of parallelism, internal and service, are identified and utilized in addition to a virtual atomicity.
Object-oriented software construction techniques integrate the testing process with the development process. Parrish, Cordes and Brown investigate the effect of incremental class development and class testing. They discuss a technique that supports the incremental development and testing of an individual class. They contrast their approach to a model in which the development proceeds class by class where the entire class specification is published at once along with a complete implementation. In addition to defining a program representation, McGregor, Malloy and Siegmund include a brief discussion on the use of the representation for object flow testing.
Object-oriented software development techniques have been shown to reduce the complexity of development, but software techniques alone are not sufficient to ensure a quality product nor a timely delivery. In fact, Booch, while providing an overview of the techniques being used to manage projects that utilize object-oriented techniques, views the chance of success for a project as orthogonal to the development strategy. Booch identifies the architecture of the system as the most significant factor in a successful project, regardless of whether it is object-oriented or not. Cain, Coplien and Harrison have studied a number of software development projects and offer insights into the effective organization of teams and projects. This work uses sociological investigative techniques, cataloging social network diagrams, to collect and organize information. They present a number of visualizations of the data and use these to identify patterns that proved effective in communicating successful organizational strategies for software development projects.
John D. McGregor
Editor