Object-Oriented Programming

Under messaging (Smalltalk, Objective-C, Ruby, Python) the method name is a runtime value the receiver resolves, so an unknown name reaches a hook: doesNotUnderstand:, method_missing, getattr. Under member calls (C++, Go, Rust) the target is fixed at compile time and an unknown name does not compile.

Whether lookup runs through a live, mutable class object or a frozen definition. Python, Ruby and Smalltalk resolve each call through the class at call time, so existing instances gain new methods immediately; C++ and Java fix layout and dispatch when the type is compiled or loaded.

Reads walk the delegation chain until a holder is found; writes normally do not walk — they create an own property on the receiver that shadows the parent's. So prototype state looks shared until the first assignment, while mutating a prototype's array or object stays shared for everyone.

Java's and C++'s new T is pinned to T: it cannot return a cached instance, a subtype, or a failure value, so anything interesting moves into a separate function. Go, Rust and Python's new have no such rule -- construction there is a normal function returning a value, so those abilities need no pattern name.

Where the class is itself an object — Smalltalk, Ruby, Objective-C, Python's classmethod — class-level code has a receiver, so it is inherited, dispatched, and passable as a value. Java, C++ and C# statics have no receiver, so you inject factory objects or use reflection.

No. Encapsulation is a mechanism: bundle state with the operations that reach it. Information hiding is a design property: a module keeps a changeable decision secret. A C header can hide everything with no keywords; getter-and-setter classes hide nothing.

Each trusts a different unit: subclasses (protected), one flat package (Java package-private), one compiled assembly (C# internal), one compilation module (Kotlin internal), a crate subtree (Rust pub(crate), pub(super)), one package plus the internal directory rule (Go). Pick the smallest unit that still compiles.

The uniform access principle: in Python, Ruby, C#, Kotlin and Swift a stored attribute can become a computed one without changing call sites, so accessors up front are noise. Java has no properties, so x.field cannot later become a computation - the getter buys future freedom, not encapsulation.

An invariant constrains an object's stable states, not every instant. Eiffel evaluates the class invariant on entry to and exit from qualified calls (x.f); D runs invariant blocks around public member functions; Ada 2012 checks Type_Invariant when a value crosses the package's visible boundary. Internal self-calls are skipped so a routine can legally break and rebuild state.

Rust moves ownership, so the caller's binding is unusable afterwards. Swift structs copy by value. Go copies a struct but its slice and map fields still point at the same backing storage. Java, C#, Python and JavaScript share by reference unless you copy by hand.

The caller's. Preconditions are caller obligations. Eiffel's require blames the caller by name, Racket blames the module that crossed the boundary, Kotlin's require throws with no party named, and Rust encodes non-emptiness in the argument type so there is nothing left to check.

Nominal (Java, C#): the type's author writes implements, so retrofitting a library type needs a wrapper. Structural (Go, TypeScript): matching method shape is enough, so a consumer can define the abstraction afterwards. Rust traits are nominal but either side may write the impl, and the orphan rule forces a newtype when neither is local.

Either add it with a default body or do not add it to the abstraction at all. Java default methods dispatch virtually and an implementer's own method always wins; C# default interface members are visible only through an interface-typed reference; Swift extension members that are not protocol requirements dispatch statically; Go publishes a second small interface and type-asserts for it.

The caller must now understand the layer it was insulated from, and its own callers inherit that coupling. Java translates and wraps, Go wraps with %w and reopens deliberately via errors.As, Rust converts through From at the ? boundary, Python chains with raise-from, Erlang crashes to a supervisor instead.

Interfaces promise behaviour, not cost, so a linked implementation answers index-at-i in linear time behind the same call. C++ and Rust omit indexing from list types entirely; Scala splits IndexedSeq from LinearSeq; Java only adds a RandomAccess marker.

Types are only obligations, so they union freely. Implementation conflicts are decidable — pick one, order them, or error. State is the hard layer: a shared ancestor's fields must be duplicated per path or shared, and neither default is right for every program.

Go and Rust have no implementation inheritance, so there is no abstract class: you declare an interface or trait and reuse code by composition or default bodies. In C++ an interface is just an abstract class with only pure virtual functions. Python offers abc.ABC or typing.Protocol.

Flattening (Pharo traits, PHP traits, Rust traits): methods are copied in, composition order is irrelevant, and a clash is reported and resolved by exclusion or aliasing. Chain insertion (Ruby modules, Scala traits): the unit becomes a link in the lookup chain, so order decides and forwarding continues along it.

An erased reference carries a value plus a fixed table of code addresses, but not the concrete type. Members needing the type — constructors, statics, constants, Self returns, generic methods — cannot cross. Rust, Swift and C# declare them and restrict use; Java forbids declaring them.

Publishing a base spends every subclass's one inheritance slot and turns its constructors and protected members into API. Later adding a concrete method can silently capture a subclass's own method — silent in Java, a hiding warning in C#, a compile error in Kotlin and Swift.

Subclassing is code reuse; subtyping is substitutability. C++ private inheritance and Eiffel non-conforming inheritance give reuse with no substitutability; Go embedding and Rust default trait methods give reuse without inheritance; Go and TypeScript grant subtyping with no declaration at all.

Go embedding has no open recursion: inside a promoted method, the receiver is still the embedded value, so redefining a method in the outer struct shadows rather than overrides. Open recursion — late-bound self-calls — is what turns a base class's internal call graph into part of its contract. Go gives up the template method pattern.

Python, Ruby and Scala resolve the parent call dynamically along the receiver's linearized ancestor list, so the target can be a class the caller never mentions. C++ has no super and forces a statically named base. Java, C# and Kotlin bind super to one fixed base.

It gains exhaustiveness: the compiler can enumerate the cases, so a match needs no default branch. Where "known" ends differs — the type itself in Rust and Haskell, the file in Scala 3, the package plus module in Java and Kotlin.

Inheritance shares state, not just code. Protected fields are a second, subclass-facing API you can never narrow, and they freeze the base's representation. Containment reuses no state unless the base publishes accessors — that is the real cost of extend-to-contain.

Single dispatch consults exactly one runtime type — the receiver — so the second object's runtime type is invisible to selection. Julia and Common Lisp key methods on the whole argument tuple, Clojure lets you name the dispatch function, and elsewhere you bounce through a second call on the other object.

An overload set is not a portable API concept — only a name plus an arity survives a boundary. Express variants as distinct names (Go's style), keyword or default parameters (Python), an options object (JavaScript), or argument labels (Objective-C). Never distinguish variants by argument type alone.

Subtype dispatch chooses on the receiver's runtime type. Overloading chooses on the static argument types. Typeclass/trait resolution (Haskell, Rust, Swift) chooses on the whole inferred type, so it can select from the return type. Parametric polymorphism chooses on nothing.

A field read is a load at an offset the compiler fixes from the declared type, so there is nothing to reroute. A virtual call is a table lookup, which can be rerouted. Substitutable state must therefore be method-shaped: properties, accessors, descriptors.

C++ and Java store a table pointer inside the object, fixed at construction. Go and Rust store it in the reference (interface value, fat pointer), so a type can be made dispatchable after it exists. Ruby and Objective-C have no table: they look up by message name and cache.

A cycle fuses its members into one unit: everything in a strongly connected component must be built, tested, versioned and understood together. Go rejects import cycles at compile time with no override; Java and C# allow package-level cycles freely; Python allows the import and fails at runtime on a partially initialised module.

Only where the language has ownership semantics. C++ value members and Rust's move-and-Drop destroy the part with the whole. Swift's ARC leaks if you model it wrong. Under Java, C#, Python or Go a tracing collector frees whatever is unreachable, so the diamond is documentation.

All of them generate forwarding, not delegation. Kotlin by, Scala 3 export and Go embedding emit compile-time stubs that call the inner object; Ruby's Forwardable metaprograms named methods; Python's __getattr__ forwards at run time but is skipped by implicit special-method lookup.

In prototype and dynamic-class languages the link itself is mutable: JavaScript's Object.setPrototypeOf, Python reassigning obj.class or Cls.bases, Ruby's per-object extend and reopened classes. The cost is deoptimization and cache invalidation — and, unlike swapping a part, it changes dispatch for everything reaching that class.

Two costs: an invariant (both ends must always agree, so one mutator owns both writes) and a reclamation cost that depends on the runtime. Java, C# and Go collect the cycle for free; Swift and C++ shared_ptr leak unless one end is weak; Rust rejects the shape and pushes you to Weak or index tables.

Coincidental cohesion: the members share nothing but a file. Java and C# have no free functions, so the dump must take the shape of a class; Python, Go and Rust let functions live directly in a module, so the same dump is a namespace, not a type.

Content coupling — the strongest kind, because the dependent breaks on any internal change. Whether a compiler can stop it depends on the language's unit of protection: per-class in Java, C# and C++, per-package in Go, per-module in Rust, and convention-only in Python.

No. Cohesion is a property of the member set and the state those members touch; all three mechanisms merge back into one type with one field set. C# partial is a compile-time text split, Ruby reopening makes the member list load-order dependent, and Objective-C categories can collide with no diagnostic.

Control coupling: the caller passes a value whose only job is to steer the callee's internal branch, so the caller must know branches it should not. Labels make the flag readable but leave the coupling; only turning the choice into a dispatched, exhaustively checked variant removes it.

Python, Ruby and JavaScript can replace any import, method or global at runtime, so a badly coupled unit still tests green and the pain signal is suppressed. Go and Rust have no runtime patching, so substitutability must be designed in and the probe stays honest.

Single responsibility spends only a unit of change; interface segregation and dependency inversion spend only interfaces — all three carry over untouched. Open/closed's "add a subclass" wording must be restated as "add an implementation". Liskov survives as intent but loses its compiler checks.

Type checkers verify shape only: names, arity, types. Behaviour is left to convention. Eiffel and Ada 2012 inherit contracts so a tightened precondition is unwritable; Java and C# instead mechanise an unsound rule, covariant arrays, and patch it with runtime store checks.

Binding immutability fixes the name; shallow fixes the object's own fields; transitive means nothing reachable can change for anyone. Only transitive enables safe sharing. A read-only interface is just a view — someone may still hold the mutable original.

They differ on three axes: which members count (Kotlin uses primary-constructor properties only; C# records use all instance fields), the subtype policy (Scala's canEqual, C#'s runtime equality contract, final Java records), and reference members such as arrays, which all four compare by identity.

Only when the type guarantees exactly one canonical instance per value. Erlang and Elixir atoms, Lisp and Scheme symbols, Ruby symbols and JavaScript's Symbol.for registry give that guarantee. Java's small-Integer cache and CPython's interned strings do not; they are optimizations.

Value semantics: assignment copies the object, so two names never alias one state. Reference semantics: assignment copies a handle. C#, Swift, Go and C++ let the type's author choose; in Java, Python and JavaScript every object is a reference.

It breaks reflexivity, the base law. Languages cope differently: JavaScript keys Map and Set with SameValueZero so NaN works as a key; Go accepts a NaN map key you can never read back; Rust withholds the Eq trait, so a float cannot key a hash map at all.