Responsibility-Driven Primitives: Roles, Objects, and Integration Contracts(Responsibility Driven Design)

 Responsibility-driven design (RDD) provides a practical way to turn domain intent into implementation primitives by assigning who is responsible for what—knowing, doing, or deciding—and mapping those responsibilities to runtime artifacts and interfaces. This post lists the model elements engineers use to translate responsibilities into clear ownership, contracts, and integration surfaces.

Modeling Based on the Author's Perspective

Entity	Description
Responsibility	Discrete obligation assigned to a role: to know, to act, or to decide within a lifecycle.
Knowing Something	Responsibility to hold, validate, and provide authoritative state or facts to collaborators.
Doing Something	Responsibility to execute operations or side-effecting behavior that advances a workflow.
Deciding Something	Responsibility to evaluate conditions and produce deterministic decisions or policies.
Role	Named abstraction that aggregates responsibilities and defines interaction contracts.
Role Item	Concrete assignment or instance of a role within a scenario, with specific permissions and scope.
Object Stereotype	Classification hint that constrains expected behavior, lifecycle, and collaboration patterns.
Object	Runtime artifact encapsulating state and behavior aligned to one or more responsibilities.
Information Holder	Object whose primary responsibility is to persist and expose authoritative domain data.
Database Record	Concrete persistent representation managed by an Information Holder for durability and queries.
Structurer	Object that organizes, aggregates, or transforms data structures without owning business rules.
Service Provider	Object exposing operations (APIs) that implement domain responsibilities as callable contracts.
API	Typed interface contract through which a Service Provider offers capabilities to callers.
Coordinator	Object that orchestrates workflows, sequences tasks, and manages interaction ordering.
Task Manager	Coordinator implementation that schedules, retries, and monitors asynchronous work items.
Interfacer	Object that mediates external integration, protocol translation, and boundary concerns.
API Gateway	Concrete Interfacer that routes, secures, and enforces policies for inbound API traffic.
Cluster	Logical grouping of objects and roles that share cohesion, deployment, or transactional scope.
Cluster Item	Member object or role within a Cluster contributing to a focused capability or service.
Object Neighborhood	Local graph of related objects, message flows, and dependency edges around a focal object.
Related Objects	Directly connected objects that collaborate to fulfill a responsibility or use case.
Message Exchanges	Typed interactions (commands, events, queries) that carry intent and data between objects.
Dependencies	Explicit runtime or design-time couplings that affect change impact, testing, and versioning.

Treat these definitions as implementation primitives: assign responsibilities explicitly, codify contracts at boundaries, and minimize coupling by keeping decision logic and authoritative data clearly owned.