← Back to catalogue
Published

object-oriented programming

vr.tr.object-oriented-programming · thing-q79872

Enable an AI agent to recognise an object-oriented programming approach, assess how its objects preserve contracts and collaborate, and determine which implementation or design changes are justified.

Thing Registry Activities and processes ACT.ACT

Bundle → Layer → Finding → Questions Filled

6 bundles · 11 layers · 18 findings · 28 questions

Paradigm and object mechanisms Establishes where object-oriented programming is being assessed and how objects are represented.

Application boundary

Defines the unit of assessment and the evidence for its programming approach.

Object-oriented organisation

Records how responsibilities and interactions are organised around objects within the selected boundary.

  1. Which codebase, subsystem or design proposal is assessed, and which responsibilities are assigned to objects? boundary
  2. Which code examples or design records demonstrate object-centred behaviour rather than classes used only as namespaces or records? provenance

Object definition mechanisms

Identifies how instances obtain state and behaviour.

Classes, prototypes and instance structure

Records the mechanisms used to define, instantiate and alter objects without treating classes as mandatory.

  1. Do objects obtain behaviour from classes, prototypes, per-instance members or another documented mechanism? definition
  2. Can an object's members or behaviour providers change after creation, and what language or runtime evidence establishes this? provenance
Identity, state and encapsulation Captures what makes an object the same object and how its state remains valid.

Identity and aliasing

Examines equality, copying and shared references.

Identity, equality and copy contracts

Records when references denote the same object and when distinct objects count as equal.

  1. How are object identity and value equality distinguished, including any equality and hashing contract? definition
  2. When an object is copied or replaced, which identities and references remain shared, and which caller observations must remain equivalent? action

State access and invariants

Identifies protected conditions and paths that can bypass their enforcement.

Invariant enforcement boundary

Records valid object states, permitted mutation paths and the limits of encapsulation.

  1. Which conditions must hold at observable operation boundaries, and which constructors or methods establish and preserve them? definition
  2. Can callers bypass those methods through public fields, mutable values returned by accessors, aliases or reflective access? boundary
Interfaces, dispatch and substitution Connects callable object contracts with implementation selection and replacement.

Operation resolution

Captures how a requested operation resolves to executable behaviour.

Method lookup and dispatch

Records binding, overriding and lookup rules used by the assessed implementation.

  1. For a representative operation, which receiver, declared types, runtime types or prototype links determine the selected implementation? definition
  2. Which language rules and code evidence distinguish overloading, overriding, member hiding and delegation where they occur? provenance

Behavioural compatibility

Assesses polymorphic replacement against observable obligations.

Substitution obligations

Records preconditions, outcomes, failures and state effects that implementations must preserve.

  1. What inputs, results, exceptions and state changes may callers rely on through the shared interface? definition
  2. What evidence shows that a proposed replacement accepts the required inputs and preserves those guarantees? action
Responsibilities and object collaboration Describes how objects divide work and combine behaviour.

Responsibility allocation

Locates decisions, state and operations across collaborating objects.

Collaboration and knowledge boundaries

Records which objects perform a task and how much each knows about others' internals.

  1. For a representative task, which object owns each decision and which collaborators does it invoke? definition
  2. Which interactions depend on collaborators' internal representation or long navigation chains, and what changes would those dependencies propagate? boundary

Reuse and extension

Separates behaviour sharing from interface compatibility.

Inheritance, composition and delegation

Records the intent and consequences of each mechanism used to reuse or extend behaviour.

  1. Which relationships provide implementation reuse, which promise substitution, and which forward work to contained or referenced objects? definition
  2. For a proposed extension, what caller contracts, override dependencies and ownership assumptions determine whether inheritance, composition or delegation is appropriate? action
Object lifecycle and change evidence Records when objects are usable and what evidence permits changes to their behaviour or structure.

Construction and retirement

Captures object readiness, valid transitions and responsibility for resources.

Lifecycle validity

Records how objects become valid, which operations are legal in each state and how obligations end.

  1. When does an object become valid for use, and can partially initialised state escape through callbacks, registration or overridable constructor calls? boundary
  2. Which operations are permitted after each lifecycle transition, and who must release any resources the object owns? action

Behaviour-preserving change

Defines the observations and checks needed to assess object-oriented refactoring.

Refactoring evidence

Records whether a proposed structural change preserves required contracts, identity effects and interactions.

  1. Which observable results, state transitions, identity relationships and collaborator effects must a proposed refactoring preserve? boundary
  2. Which contract checks and representative interaction tests support the change, and which affected behaviours remain unchecked? action
Evidence and external alignment What the world already says about this thing, gathered so the model can be checked against it.

Reported evidence

Findings from the breadth pass, kept separate from the structural claims.

Kinds and varieties

Reported by the breadth pass; each item needs checking against its source before it becomes normative.

  1. Which of these kinds and varieties hold for the sense of object-oriented programming this model covers, and on what evidence? provenance

Identifiers and schemes

Reported by the breadth pass; each item needs checking against its source before it becomes normative.

  1. Which of these identifiers and schemes hold for the sense of object-oriented programming this model covers, and on what evidence? provenance

Standards and regulation

Reported by the breadth pass; each item needs checking against its source before it becomes normative.

  1. Which of these standards and regulation hold for the sense of object-oriented programming this model covers, and on what evidence? provenance

Real-world use

Reported by the breadth pass; each item needs checking against its source before it becomes normative.

  1. Which of these real-world use hold for the sense of object-oriented programming this model covers, and on what evidence? provenance

Typical measurements

Reported by the breadth pass; each item needs checking against its source before it becomes normative.

  1. Which of these typical measurements hold for the sense of object-oriented programming this model covers, and on what evidence? provenance

Failure modes and hazards

Reported by the breadth pass; each item needs checking against its source before it becomes normative.

  1. Which of these failure modes and hazards hold for the sense of object-oriented programming this model covers, and on what evidence? provenance

Regional variation

Reported by the breadth pass; each item needs checking against its source before it becomes normative.

  1. Which of these regional variation hold for the sense of object-oriented programming this model covers, and on what evidence? provenance

Neighbouring kinds and how to tell them apart

Reported by the breadth pass; each item needs checking against its source before it becomes normative.

  1. Which of these neighbouring kinds and how to tell them apart hold for the sense of object-oriented programming this model covers, and on what evidence? provenance

Classifiers Filled

Family
Thing Registry
Category
Activities and processes
Entry kind
thing
Plane
ACT
Domain
ACT.ACT
Other names and narrower kinds
prototype-based programming, object-oriented programming in PHP, Python Programming/Classes, actor-based programming, class-based programming, concurrent object-oriented programming

What it is Filled

Object-oriented programming is a programming paradigm that structures a program as interacting objects associating state with behaviour exposed through methods or messages, commonly using encapsulation and class-based or prototype-based mechanisms to organise and reuse behaviour, with late-bound polymorphic dispatch supported by many implementations but not required by every object-oriented design.

In scope

  • Evidence that a program organises behaviour around objects and their interactions
  • Object identity, state ownership, encapsulation and invariants
  • Class-based or prototype-based object construction and behaviour reuse
  • Method lookup, dynamic dispatch, polymorphism and behavioural contracts
  • Object collaboration, composition, inheritance and substitutability
  • Assessment and modification of an object-oriented design within its implementation context

Out of scope

  • Complete programming-language syntax, compiler implementation and language specification
  • General software requirements, product capabilities and business-domain definitions
  • Database schemas, persistence engines and object-relational mapping configuration
  • Deployment architecture, infrastructure operation and service topology
  • General project management, developer competency and team organisation
  • Functional, procedural or logic programming except where needed to identify boundaries or mixed approaches

Why it exists Filled

Enable an AI agent to recognise an object-oriented programming approach, assess how its objects preserve contracts and collaborate, and determine which implementation or design changes are justified.

Distinguishing features Filled

  • Determine whether objects receive operations through a defined interface and supply associated behaviour; records merely passed among free functions are insufficient evidence by themselves.
  • Determine whether object boundaries organise responsibilities and state access in actual code; the presence of class declarations alone does not establish an object-oriented design.
  • Identify whether operations can select behaviour through a receiver's class, prototype or other object mechanism; distinguish this from branches over externally interpreted type tags without assuming every object-oriented design requires dynamic dispatch.
  • Determine whether classes act as object definitions, namespaces or data containers; distinguish object-oriented use from procedural code packaged inside classes.
  • For an entity-component design, determine whether behaviour resides in collaborating objects or primarily in systems processing passive components; record mixed cases rather than classifying by terminology.

What robots and AI may and may not do Filled

Must not

  • Present one language's object model as the only correct form of the paradigm.
  • Break encapsulation to reach private data it is not meant to access.
  • Push large refactors to shared code without review or tests.
  • Copy licensed code or class libraries against their licence terms.

Only with a human decision

  • Changing public interfaces that other teams or customers depend on.

May

  • Explain object-oriented concepts such as encapsulation, inheritance and polymorphism with examples.
  • Design and refactor object-oriented code in projects it is authorized to change, keeping tests passing.

Moral aspects Filled

  • Design choices shape how easy software is to maintain and secure.
  • Paradigm debates can exclude learners when framed as dogma.

Who is affected

  • Developers
  • Users of the software
  • Students

Owners Filled

Steward

Nobody owns the paradigm; authors and owners of code answer for their programs.

Links to other meta-models Filled

parent

  • Q223335 - registry parent class

What else AI and robots need to interact with it Filled

Identity and identifiers required Filled

  • Vercy registry: vr.tr.object-oriented-programming
  • Wikidata: Q79872 (https://www.wikidata.org/wiki/Q79872)

Direct properties not applicable Not applicable

  • Assessment boundary: language capability | codebase | subsystem | library | design proposal
  • Object organisation mechanism: class-based | prototype-based | hybrid | other documented mechanism | unresolved
  • Identity semantics: reference identity | value equality | both with explicit distinction | context-dependent | unresolved
  • State exposure: hidden behind operations | exposed read-only | directly mutable | mixed | unresolved
  • Dispatch mechanism: Record supported and used mechanisms, such as static binding, receiver-based dynamic dispatch, multiple dispatch or prototype delegation.
  • Behavioural contract evidence: unspecified | documented | partially checked | checked within a stated boundary | known violation
  • Reuse and substitution relationships: composition | delegation | implementation inheritance | declared subtyping | structural compatibility; identify endpoints and evidence
  • Inheritance depth: Maximum number of inheritance edges from a root to a assessed type, with treatment of multiple inheritance stated
  • Mutable-state sharing: Record which objects share access to mutable state and which operations may modify it.

Plane ACT: no invented physical properties.

Recognition not applicable Not applicable

Not applicable

A programming paradigm is an abstract approach whose use must be assessed from software structure and behaviour rather than visual appearance.

Capabilities and actions required Filled

  • Classify a bounded implementation's object-oriented mechanisms using code and language evidence.
  • Trace an operation from its receiver through method lookup, dispatch and delegated calls.
  • Identify exposed state, invariant violations and unsafe assumptions about object identity.
  • Assess whether a proposed subtype preserves the behavioural expectations of its callers.
  • Propose changes to responsibility allocation, interfaces, composition or inheritance and specify the evidence needed before applying them.
  • Construct checks for object contracts, lifecycle transitions and polymorphic behaviour.

Hazards and failure modes required Filled

  • Poorly controlled shared mutable state can produce inconsistent behaviour and defects that are difficult to reproduce.
  • Deep inheritance hierarchies and tight coupling can make local changes break distant parts of a system.
  • Objects that fail to enforce their invariants can allow invalid data to propagate through an application.
  • Incorrect assumptions about overridden methods can violate caller expectations and undermine reliability or security.

Standards and interfaces required Filled

  • ISO/IEC 19505-1 and ISO/IEC 19505-2, issued jointly by the International Organization for Standardization and the International Electrotechnical Commission, standardize the Unified Modeling Language used to describe object-oriented software designs.

Context of use required Filled

  • Object-oriented programming is used to organize software around objects that combine state with operations on that state.
  • It is commonly encountered in application development, simulations and reusable software frameworks.
  • It supports designs in which components collaborate through defined interfaces and can provide different implementations of shared behaviour.

Sources Filled

  1. The Early History of Smalltalk - Kay's specialist account of OOP as messaging, local retention and protection of state, and extreme late binding, against later class-and-inheritance reductions.
  2. Dimensions of Object-Based Language Design - The still-used split between object-based languages (objects) and object-oriented languages (objects plus inheritance), and other design dimensions.
  3. The Quarks of Object-Oriented Development - Empirical practitioner consensus that encapsulation, inheritance, and polymorphism are the properties people actually treat as definitional.
  4. A Metrics Suite for Object Oriented Design - The CK quantities (WMC, DIT, NOC, CBO, RFC, LCOM) still used to measure OO designs.
  5. On Understanding Types, Data Abstraction, and Polymorphism - How inclusion polymorphism and data abstraction underpin typed OOP, and how that differs from ADTs alone.
  6. Unified Modeling Language (UML) specification - The dominant industrial notation for class, object, and related structure used to describe OO systems.
  7. Wikidata item Q79872: object-oriented programming - identity and sense of the item
  8. Wikipedia: Object-oriented programming - general description of the item

Open questions

  • Which existing Vercy world models already own programming paradigms, object contracts or software design, and should this registry entry link to one of them?
  • What operational recognition threshold should Vercy use for object-oriented programming in mixed codebases, especially where objects lack dynamic dispatch or contain little behaviour?
  • Should the primary assessment unit be the programming approach itself or a bounded application of it, and how should those levels relate?
  • Which language-specific extensions are needed for multiple dispatch, traits, mixins, prototype mutation and metaprogramming?
  • When should concurrency, persistence identity and distributed object lifecycles extend this model rather than remain in neighbouring models?

Machine files

Provenance

thing registry research (pass 2) · unreviewed

Built from: models/things/publications/thing-q79872/spec.json