object-oriented programming
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.
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.
- Which codebase, subsystem or design proposal is assessed, and which responsibilities are assigned to objects? boundary
- 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.
- Do objects obtain behaviour from classes, prototypes, per-instance members or another documented mechanism? definition
- 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.
- How are object identity and value equality distinguished, including any equality and hashing contract? definition
- 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.
- Which conditions must hold at observable operation boundaries, and which constructors or methods establish and preserve them? definition
- 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.
- For a representative operation, which receiver, declared types, runtime types or prototype links determine the selected implementation? definition
- 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.
- What inputs, results, exceptions and state changes may callers rely on through the shared interface? definition
- 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.
- For a representative task, which object owns each decision and which collaborators does it invoke? definition
- 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.
- Which relationships provide implementation reuse, which promise substitution, and which forward work to contained or referenced objects? definition
- 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.
- When does an object become valid for use, and can partially initialised state escape through callbacks, registration or overridable constructor calls? boundary
- 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.
- Which observable results, state transitions, identity relationships and collaborator effects must a proposed refactoring preserve? boundary
- 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.
- 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.
- 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.
- 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.
- 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.
- 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.
- 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.
- 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.
- 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
- 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.
- 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.
- The Quarks of Object-Oriented Development - Empirical practitioner consensus that encapsulation, inheritance, and polymorphism are the properties people actually treat as definitional.
- A Metrics Suite for Object Oriented Design - The CK quantities (WMC, DIT, NOC, CBO, RFC, LCOM) still used to measure OO designs.
- On Understanding Types, Data Abstraction, and Polymorphism - How inclusion polymorphism and data abstraction underpin typed OOP, and how that differs from ADTs alone.
- Unified Modeling Language (UML) specification - The dominant industrial notation for class, object, and related structure used to describe OO systems.
- Wikidata item Q79872: object-oriented programming - identity and sense of the item
- 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