Object-Oriented Software Construction

1. Software Quality Hinges on External and Internal Factors

In the end, only external factors matter.

External vs. Internal. Software quality is judged by both external factors (speed, ease of use) and internal factors (modularity, readability). While users experience external qualities, internal factors are crucial for developers to achieve those visible qualities.

The User's Perspective. Ultimately, software must satisfy its users, including end-users, purchasers, and those commissioning development. Qualities like extendibility are external factors, even if not immediately apparent to end-users.

Internal Techniques. The book emphasizes modern techniques for achieving internal quality, recognizing that these are not ends in themselves but means to reach external software qualities that truly matter to users.

2. Object Orientation: A Multifaceted Approach

Object technology is at its core the combination of four ideas: a structuring method, a reliability discipline, an epistemological principle and a classification technique.

Holistic Development. Object orientation encompasses the entire software lifecycle, from analysis and design to implementation and maintenance, requiring a language that serves as a vehicle for thought throughout all stages.

Core Concepts. The method centers on classes, contracts, abstract data types, and inheritance, forming a powerful and versatile framework for software construction.

Beyond Implementation. Object orientation is not merely a programming technique but a system architecture method, emphasizing the essential unity of software development over differences in abstraction levels.

3. Modularity: The Cornerstone of Flexible Systems

A software construction method is modular, then, if it helps designers produce software systems made of autonomous elements connected by a coherent, simple structure.

Decomposition and Composition. Modularity involves both decomposing a problem into smaller subproblems and composing reusable elements to build new systems.

Criteria, Rules, and Principles. Modularity is defined by five criteria (decomposability, composability, understandability, continuity, protection), five rules (direct mapping, few interfaces, small interfaces, explicit interfaces, information hiding), and five principles (linguistic modular units, self-documentation, uniform access, open-closed, single choice).

Balancing Act. Achieving modularity requires balancing competing goals, such as decomposability (top-down) and composability (bottom-up), and consciously making tradeoffs between quality factors.

4. Reusability: Avoiding Reinvention Through Commonality

By capturing such a pattern, a reusable software element will be applicable to many different developments.

The Goal of Reusability. Reusability aims to exploit commonality in software systems, avoiding the need to reinvent solutions to problems that have been encountered before.

Benefits of Reusability. Reusability influences all aspects of software quality, including correctness, robustness, extendibility, compatibility, efficiency, portability, ease of use, timeliness, economy, and functionality.

Technical and Non-Technical Obstacles. Achieving reusability requires addressing both technical challenges (module structure, interface design) and non-technical obstacles (NIH syndrome, procurement policies).

5. Object Technology: Structuring Software Around Objects

Software systems perform certain actions on objects of certain types; to obtain flexible and reusable systems, it is better to base their structure on the object types than on the actions.

Object-Based Decomposition. Object technology emphasizes structuring software around object types rather than actions, leading to more flexible and reusable systems.

Classes as Central Units. Classes serve as the basis for both the modular structure and the type system, providing a powerful and versatile mechanism for software construction.

Epistemological Shift. Object technology challenges the traditional view of an "external reality" that predates any program, emphasizing that reality is defined by what we can do with it.

6. Abstract Data Types: Defining Objects by Behavior

In object technology, the objects described by a class are only defined by what we can do with them: operations (also known as features) and formal properties of these operations (the contracts).

Abstract View of Objects. Abstract data types (ADTs) define objects by their operations (features) and formal properties (contracts), rather than their physical implementation.

Formalizing Specifications. ADTs use mathematical notation to express specifications, including preconditions, postconditions, and invariants, providing a precise and unambiguous description of object behavior.

From ADTs to Classes. The transition from ADTs to classes involves implementing the ADT's operations as features, choosing a representation for the objects, and ensuring that the implementation satisfies the formal properties.

7. Design by Contract: Building Reliable Software Through Agreements

The idea is to treat any system as a collection of components which collaborate the way successful businesses do: by adhering to contracts defining explicitly the obligations and benefits incumbent on each party.

Contractual Obligations. Design by Contract treats software components as parties in a contract, with each party having specific obligations (preconditions) and benefits (postconditions).

Assertions as Contracts. Assertions (preconditions, postconditions, and invariants) express the formal properties of software components, serving as the basis for building reliable software.

Benefits of Contracting. Contracting improves software reliability, provides systematic documentation, and serves as a central tool for testing and debugging object-oriented software.

8. Exception Handling: Graceful Recovery from Abnormal Conditions

Robustness is the ability of software systems to react appropriately to abnormal conditions.

Handling the Unexpected. Exception handling provides a mechanism to recover from unexpected abnormal situations, such as hardware malfunctions, erroneous user input, or software bugs.

Exceptions vs. Failures. An exception is an abnormal event that disrupts execution, while a failure is the inability of a routine to fulfill its contract. Exception handling aims to prevent exceptions from leading to failures.

Disciplined Responses. Legitimate responses to exceptions include retrying (attempting to correct the situation and re-execute the routine) and failure (reporting the exception to the caller after cleaning up the environment).

9. Inheritance: Classification and Code Reuse

The classification technique follows from the observation that systematic intellectual work in general and scientific reasoning in particular require devising taxonomies for the domains being studied. Software is no exception, and the object-oriented method relies heavily on a classification discipline known as inheritance.

Classification Mechanism. Inheritance provides a classification mechanism for organizing classes, allowing a class to inherit features from another class (its parent).

Polymorphism and Dynamic Binding. Inheritance enables polymorphism (the ability for an entity to refer to objects of different types) and dynamic binding (the automatic selection of the appropriate feature version at run time).

Redeclaration and Specialization. Inheritance allows descendants to redefine inherited features, adapting them to their specific needs while preserving the overall structure and behavior of the system.

10. Typing: Ensuring Run-Time Safety and Code Integrity

A well-defined type system should, by enforcing a number of type declaration and compatibility rules, guarantee the run-time type safety of the systems it accepts.

Static Typing. Static typing involves enforcing type declaration and compatibility rules to guarantee the run-time type safety of software systems.

Genericity and Typing. Genericity allows type parameterization, enabling the creation of generic classes that can work with different types while maintaining type safety.

Typing Challenges. Typing challenges include covariance, descendant hiding, and the need to balance flexibility with safety.

11. Methodology: Guiding Principles for Software Construction

In software perhaps even more than elsewhere, thought and language are closely connected.

The Role of Methodology. Software methodology provides guidance for analyzing and producing software, but it is not a substitute for talent, experience, and creativity.

Principles and Rules. Effective methodologies are based on sound theoretical foundations and extensive practical experience, offering clear and actionable rules.

The Importance of Style. A sense of style, including consistent naming conventions and text layout, contributes significantly to the readability and maintainability of software.

12. Concurrency: Managing Parallelism and Distribution

Object technology is at its core the combination of four ideas: a structuring method, a reliability discipline, an epistemological principle and a classification technique.

Concurrency and Object Technology. Object technology can be effectively applied to concurrent and distributed systems, enabling the development of complex applications that leverage parallelism.

From Processes to Objects. The object-oriented approach shifts the focus from processes to objects, allowing for a more decentralized and flexible architecture.

Synchronization and Communication. Synchronization and communication are essential aspects of concurrent systems, and object technology provides mechanisms for managing these aspects through separate declarations and wait conditions.

Last updated: February 25, 2025