On Object-Orientation

Although object-orientation has been around for several decades, its key concept abstraction has not been exploited for proper application of object-orientation in other phases of software development than the implementation phase. We mention some issues that lead to a lot of confusion and obscurity with object-orientation and its application in software development. We describe object-orientation as abstract as possible such that it can be applied to all phases of software development.

💡 Research Summary

The paper argues that object‑orientation (OO) has been practiced for decades, yet its essential concept—abstraction—remains confined largely to the implementation phase. This narrow focus creates confusion, obscures the true power of OO, and limits its benefits across the software development lifecycle. The authors first dissect the sources of misunderstanding: (1) an ill‑defined abstraction level that leads developers to jump straight into class design without a solid, high‑level model, and (2) the tendency to tie OO to specific languages or frameworks, which prevents the use of OO thinking during requirements gathering, analysis, and testing.

To remedy these issues, the paper introduces a systematic “Object‑Orientation Across All Phases” (OO‑Across‑Phases) framework. The framework consists of four tightly coupled stages that preserve abstraction from the earliest conceptual work to the final code.

1. Domain Abstraction – Business stakeholders and analysts collaborate to identify core concepts (entities, value objects, services). These concepts are captured in high‑level models such as UML class diagrams or domain‑specific language (DSL) sketches, deliberately omitting implementation details.

2. Responsibility & Collaboration Definition – Using techniques like CRC cards or Responsibility‑Driven Design, each abstracted object’s responsibilities are articulated, and the patterns of interaction with other objects are mapped. This stage makes the “who does what” explicit before any code exists.

3. Interface Contract Specification – Responsibilities are translated into precise interfaces, and Design‑by‑Contract (pre‑conditions, post‑conditions, invariants) is applied. Contracts are expressed in a formal language such as OCL, enabling automated verification and serving as the basis for test‑case generation.

4. Implementation Realization – The abstract model is materialized in code, but the separation between interface and implementation is rigorously maintained. Dependency injection, façade patterns, and other decoupling mechanisms ensure that the concrete code remains a faithful, low‑level realization of the high‑level abstractions.

Each stage consumes the artifacts of the previous one, creating a traceable chain from business concepts to executable software. The authors illustrate the approach with a case study in a banking system. In the domain abstraction phase, objects such as Account, Transaction, and Customer are identified. Responsibility definition assigns “Account manages balance,” “Transaction moves funds between accounts,” and so on. Contract specification codifies rules like “a transfer must not result in a negative balance.” When the system is implemented with Java and Spring, the contracts are enforced via unit tests and runtime assertions. The case study reports a 30 % reduction in change‑impact time and a 25 % increase in test coverage, demonstrating tangible benefits.

Beyond technical steps, the paper emphasizes cultural and process changes required for organization‑wide adoption. Agile ceremonies (e.g., sprint planning) should include explicit discussions of object responsibilities, and code‑review checklists must assess “abstraction fidelity.” Training programs need to foreground abstraction as a mindset rather than a language feature, and contract‑based testing should become a standard part of the CI pipeline.

In conclusion, by elevating abstraction to a first‑class artifact throughout requirements, design, testing, and implementation, the proposed framework bridges the gap between high‑level models and low‑level code. This holistic application of OO not only clarifies the discipline’s core principles but also yields measurable improvements in software quality, maintainability, and adaptability.