Objects & Contracts

Everything manageable is an Object

Applications, devices, drivers, services, memory regions, surfaces, codecs, windows, and storage Providers converge on identity, interfaces, attachments, capabilities, state, events, lifecycle, and resources.

Composition is preferred over deep inheritance. An object can acquire behavior when a compatible Provider is attached, and lose that behavior when the Provider is detached without pretending the underlying object ceased to exist.

Contracts describe authority

Owner and Provider
Resource type and opaque handle identity
Capabilities and functional rights
Lifecycle state and lifetime policy
Dependencies and communication rules
Versioned interface expectations
Conformance, health, and rollback requirements

Opaque handles at the language boundary

Applications do not receive internal pointers. A typed handle can be assigned, compared, and passed to the owning API, while slot-and-generation validation rejects stale or mismatched resources. The initial graphics binding is the first consumer of this common model.

ArcoBASICArcoBASIC surface binding: resource identity stays opaque

' Create a small drawing surface without exposing its memory address.
LET surface AS SURFACE = GRAPHICS.CreateSurface(32, 24)

' Binding makes this surface the destination for drawing commands.
GRAPHICS.Bind(surface)
GRAPHICS.Clear(COLOR.Magenta())

' Binding borrows the handle; destruction consumes it.
GRAPHICS.DestroySurface(surface)

Universal lifecycle

Where practical, subsystem-specific verbs normalize into create, attach, activate, suspend, detach, and destroy. Replacement adds quiesce, preserve state, transfer, verify, resume, and rollback.

The current hosted Resource Registry validates transitions through Creating, Ready, Quiescing, Unavailable, Failed, and Retired. Persistent system-wide Contracts and enforcement remain a later substrate milestone.

One vocabulary beats a dozen local ones

The real payoff here is not the specific verbs create, attach, activate, suspend, detach, destroy. It is refusing to let every subsystem invent its own private lifecycle language, so a person who understands one Object already understands the shape of every other one.

Pick one small lifecycle vocabulary for your whole system and require every component to map onto it, instead of letting each subsystem name its own states. A driver, a window, and a storage handle should be recognizably the same kind of thing to a caller who has never seen any of them before.
Prefer composition through explicit attachment over deep inheritance. Letting an object gain a capability when a compatible Provider attaches, and lose it cleanly on detach, keeps behavior traceable to a specific cause instead of buried in an ancestry chain.
Make identity opaque and checked at every boundary a stranger can reach. A typed handle with generation validation, rejecting a stale or mismatched resource instead of touching it, is the same discipline as bounds-checking an array: the check belongs at the edge, not scattered through the interior.

LEARNING LAYER

Key terms, in plain language

You do not need a systems background to follow the work. These are the specialized terms used on this page.

Contract: An explicit description of what a component may do, what it requires, which capabilities it receives, and how its lifecycle is managed. It makes authority visible rather than implied.
Provider: A replaceable implementation that supplies a service behind a Contract. Different Providers can implement the same role and may be tested before one receives authority.
Capability: A specific, explicit permission to use a resource or perform an operation. Possessing one grants limited authority without granting unrestricted system access.
Opaque handle: A safe identifier for a resource whose internal memory address and representation stay hidden. Applications pass the handle back to the API that owns it.
Generation check: A version number attached to a reusable handle slot. It prevents an old handle from accidentally referring to a different resource created later in the same slot.