Subject-Oriented Programming (A Critique of Pure Objects) by William Harrison and Harold Ossher critiques the classical object-oriented model, which emphasizes encapsulation, polymorphism, and inheritance. The authors argue that this model is inadequate for developing large, integrated application suites, as it forces developers to either forego object-oriented advantages or assume all future applications, treating extrinsic information as intrinsic. Instead, they propose a subject-oriented programming model that emphasizes subjective views of objects, allowing different applications to define their own state and behavior for shared objects without requiring them to be explicitly dependent on each other. In subject-oriented programming, each application is a subject or a composition of subjects, defining only the state and behavior relevant to itself. Subjects can separately define and operate on shared objects without needing to know the details of other subjects. Only object identity is shared. A subject is definitional or schematic, corresponding to a traditional class hierarchy, but does not contain any state. Subjects can be combined to form compositions, with composition rules determining how components are combined. These rules can vary, allowing for flexible and efficient interactions between subjects. The authors discuss various aspects of subject-oriented programming, including operation invocation, object creation and initialization, state references, and points of agreement between subjects. They also explore different strategies for matching classes across subjects, including explicit matching, inferred matching, interface-based matching, and operational classification. These strategies allow for flexible and efficient handling of different class hierarchies and classifications. The authors present a model of subject-oriented programming, where a subject is represented as a tuple (N, I, D, P), with N being a set of class names, I a set of interfaces, D a class description function, and P a superclass function. A composition is a tuple (R, Q), where R is a composition rule and Q is a sequence of components. A subject-oriented universe is a tuple (M, A), where M is a composition of subjects and A is a universe activation consisting of a global set of object identifiers (oids) and a set of subject activations. The authors also discuss considerations for implementing efficient subject-oriented support, including package sharing between subjects, data sharing between subjects, separate OID spaces, and subject compositors. They argue that subject-oriented programming provides a more flexible and efficient model for developing integrated application suites, allowing for the coexistence of multiple subjective views of objects.Subject-Oriented Programming (A Critique of Pure Objects) by William Harrison and Harold Ossher critiques the classical object-oriented model, which emphasizes encapsulation, polymorphism, and inheritance. The authors argue that this model is inadequate for developing large, integrated application suites, as it forces developers to either forego object-oriented advantages or assume all future applications, treating extrinsic information as intrinsic. Instead, they propose a subject-oriented programming model that emphasizes subjective views of objects, allowing different applications to define their own state and behavior for shared objects without requiring them to be explicitly dependent on each other. In subject-oriented programming, each application is a subject or a composition of subjects, defining only the state and behavior relevant to itself. Subjects can separately define and operate on shared objects without needing to know the details of other subjects. Only object identity is shared. A subject is definitional or schematic, corresponding to a traditional class hierarchy, but does not contain any state. Subjects can be combined to form compositions, with composition rules determining how components are combined. These rules can vary, allowing for flexible and efficient interactions between subjects. The authors discuss various aspects of subject-oriented programming, including operation invocation, object creation and initialization, state references, and points of agreement between subjects. They also explore different strategies for matching classes across subjects, including explicit matching, inferred matching, interface-based matching, and operational classification. These strategies allow for flexible and efficient handling of different class hierarchies and classifications. The authors present a model of subject-oriented programming, where a subject is represented as a tuple (N, I, D, P), with N being a set of class names, I a set of interfaces, D a class description function, and P a superclass function. A composition is a tuple (R, Q), where R is a composition rule and Q is a sequence of components. A subject-oriented universe is a tuple (M, A), where M is a composition of subjects and A is a universe activation consisting of a global set of object identifiers (oids) and a set of subject activations. The authors also discuss considerations for implementing efficient subject-oriented support, including package sharing between subjects, data sharing between subjects, separate OID spaces, and subject compositors. They argue that subject-oriented programming provides a more flexible and efficient model for developing integrated application suites, allowing for the coexistence of multiple subjective views of objects.