Beyond Objects

For over fifty years, software engineering has been dominated by the idea that systems should be organized by partitioning functionality among objects that correspond to individuals in the problem domain. While this approach has become the industry standard, the author argues that it is the root cause of modern software's fragility and complexity. By forcing developers to assign computations to specific domain objects, the paradigm creates artificial couplings and forces arbitrary design decisions, leading to what is commonly known as 'dependency hell.'

Object-oriented programming is not a single, monolithic idea but a collection of distinct concepts—such as object identity, data abstraction, and domain modeling—that have been conflated over time. The author suggests that the specific combination of two ideas is particularly damaging: the 'Single Target' principle (assigning operations to a specific object) and the requirement that these objects must map directly to real-world entities. This combination forces developers to shoehorn complex system behaviors into objects where they do not naturally belong, resulting in code that is difficult to read, maintain, and evolve.

To move beyond these limitations, the paper advocates for a return to ideas from formal methods, such as relational states and event-based synchronization. Instead of embedding behavior within domain objects, the author proposes a model where individuals, relationships, and actions are treated as distinct phenomena. By decoupling the structure of the problem domain from the modules that implement system behavior, developers can achieve a better separation of concerns and create systems that are more resilient to change.