The Cohesive knowledge graph

overview

Cohesive has two linked goals:

principle

Adjunctions describe paired constructions that translate between domains in the best available way, even when the translations are not inverses.

principle

Algebras and coalgebras provide complementary ways to model construction and behavior.

principle

The asynchronous computability theorem characterizes which distributed tasks can be solved wait-free in an asynchronous read/write system.

principle

The CALM theorem, "Consistency as Logical Monotonicity", states that a program has a consistent, coordination-free distributed implementation if and only if it can be expressed in monotonic logic.

reference

Categorical principles provide modeling discipline for the Cohesive System Model. They are not the entry point for ordinary readers, but they help keep distinctions precise when relating domain semantics, system graph, operational concerns, and realization substrate.

principle

Compositionality is the principle that complex systems should be understood from parts and the rules by which those parts compose.

principle

Concurrency is the boundary-relative absence of an established ordering between occurrences or enabled work.

principle

Control flow describes how one possible action, operation, step, or continuation becomes enabled, selected, and followed by another at a declared boundary.

discipline

Control theory is the discipline of regulating the behavior of a dynamical system through observation, decision, actuation, and feedback over time.

principle

The Curry–Howard correspondence relates formal proofs to typed programs: propositions correspond to types, proofs correspond to terms inhabiting those types, and proof normalization corresponds to program evaluation.

principle

Database Sheaf Semantics views a database schema as a category, a database instance as a structure-preserving functor into sets, and local database views as sections that can be restricted, compared on overlaps, and sometimes glued into a coherent larger instance.

principle

Duality and symmetry are principles for recognizing paired concepts that explain one another through reversal, complementarity, or mirrored structure.

principle

Enrichment adds structure to relationships. Instead of merely asking whether a relationship exists, an enriched view asks what kind of value the relationship has: order, distance, cost, probability, time, authority, confidence, or information.

principle

Equivalence and equality should not be confused.

principle

Event-state duality is a modeling principle and an instance of duality and symmetry: the relationship between two views of behavior:

reference

An execution kernel is a shared semantic and interpretation boundary through which portable transition and process descriptions become executable without making one runtime, storage engine, workflow product, actor system, or host-language program the source of meaning.

principle

Fibrations and indexed structure describe situations where each object in a base domain has a category of things lying over it.

principle

A fixed point is a value, structure, or behavior that a specified transformation leaves unchanged:

discipline

Functional programming describes computation primarily through values, functions, composition, and evaluation rather than through a distinguished sequence of commands that mutate shared state.

principle

Functoriality is the principle that a mapping between domains should preserve the structure that matters: identities, relationships, composition, and change.

principle

The glitch principle states that a non-trivial device making a discrete decision among finitely many outcomes from a continuous range of possible inputs cannot guarantee a uniform finite decision time for every input.

principle

Happened-before is a strict partial order over occurrences that preserves potential causal influence without requiring one global clock or one total execution order.

principle

A judgement is a context-indexed assertion that a specified relation holds. It makes explicit what is being claimed, under which assumptions and rules, at which boundary, and with what evidence or authority the claim is accepted.

discipline

The lambda calculus is a formal calculus of variables, function abstraction, application, and substitution. It supplies a foundational language for functions and evaluation, and underlies large parts of functional programming, type theory, proof theory, and categorical semantics.

principle

The law of excluded middle is the logical schema:

discipline

Linear logic is a resource-sensitive logic in which assumptions cannot ordinarily be duplicated or discarded implicitly. It makes the use of hypotheses part of proof structure, separating connectives that combine independent resources from connectives that offer alternatives and modalities that explicitly permit reuse.

discipline

Logic studies formal languages, interpretations, and valid inference. It separates the expressions a language permits, the structures in which those expressions have meaning, and the rules by which conclusions follow from assumptions.

principle

Monads, monoids, and their duals provide recurring patterns for sequencing, accumulation, context, observation, and composition.

principle

Naturality is the principle that a transformation should be independent of arbitrary representation choices. It should commute with the structure-preserving maps between representations.

principle

Nondeterminism describes a model in which one context admits more than one possible continuation. Choice describes how, where, or by whom that multiplicity is resolved.

principle

Optics are structured ways to focus on, observe, transform, or update part of a larger structure.

principle

Pattern languages and catalogs preserve experience about recurring problems, forces, arrangements, and consequences. Cohesive reconciles them by placing each imported pattern into the realms where its claims belong and recording the correspondences among those claims.

discipline

Process calculi are formal languages for describing and reasoning about interacting, concurrent, and mobile processes. They provide syntax for composing process descriptions, operational rules for how interactions advance, and equivalences for deciding when different descriptions exhibit the same relevant behavior.

principle

Process theories are modeling disciplines for work, interaction, change, and behavior that unfold over time.

reference

Programming paradigms are recurring ways of interpreting and organizing computation. They select which structures are primary, which composition laws matter, and which operational details are left to a language, compiler, runtime, or other realization.

discipline

Queueing theory is the mathematical and operational discipline for reasoning about work that arrives, waits, receives finite-capacity service, moves among resources, and completes.

principle

Quorum intersection is the principle that selected participant sets overlap so that later decisions or observations encounter evidence constraining earlier incompatible choices.

principle

Recursion defines a value, structure, or behavior in terms of other instances of the same form. The recursive reference may point to a smaller component, a prior step, a nested process, or another derivation of the same relation.

principle

Reduction, evaluation, and confluence describe how a computation advances through possible intermediate expressions or states, how an execution strategy selects a path, and when divergent paths remain semantically coherent.

discipline

Relational and logic programming are approaches in which programs state which combinations of values, facts, or terms hold or are admissible, rather than prescribing only a function from distinguished inputs to distinguished outputs.

principle

A service is a boundary-relative role in which a provider makes a capability available to a consumer through a contract, including declared semantic and operational guarantees. The role says what can be requested, observed, or relied upon at that boundary; it does not by itself determine where the behavior is implemented, whether it runs in another process, how it is deployed, or which team owns it.

discipline

Session types are behavioral types for structured communication. They describe how a participant may use a channel or protocol endpoint over the course of a conversation: which values or labels it sends and receives, which choices it makes or offers, how the interaction recurs, and when it completes.

principle

Sheaves and gluing provide a local-to-global principle for systems of observations: many observers, contexts, processors, time intervals, schemas, views, or execution cuts may each see part of a system, and the model needs to say when those partial views agree enough to form a coherent larger view.

principle

State machines are a modeling principle for behavior described by current state, admissible transitions, inputs, and outputs.

principle

Stuff, structure, and property are a modeling distinction for separating what a model contains, how it is organized, and what constraints it satisfies.

principle

Substitution replaces variables with terms while preserving the binding, scope, sorting, typing, and contextual relationships that make an expression meaningful. It is a foundational operation in logic, type theory, the lambda calculus, rewriting, proof theory, and compiler semantics.

principle

Synchrony and Asynchrony describe whether events, observations, transitions, or participants are coupled into one boundary-relative unit.

reference

Cohesive aims to provide a standard language for describing systems and a family of compiler-like realizations that project that language into working infrastructure.

principle

Systems Sheaf Semantics uses sheaf-theoretic local-to-global structure to model how observations, state, versions, histories, process state, and knowledge vary over contexts such as observers, boundaries, and causally valid cuts of execution.

discipline

Temporal logic is a family of logics for stating how propositions hold across behaviors, runs, traces, or branching transition structures. It adds modalities for time and succession without requiring every temporal claim to use wall-clock timestamps or metric durations.

principle

Trace and feedback describe systems where outputs are fed back as future inputs.

discipline

Type theory studies terms together with the types that classify them and the judgements that establish when those terms are well formed. It can serve as a foundation for mathematics, a formal system for proofs, and a semantic basis for programming-language type systems. Substitution transports terms and types across contexts, while typed lambda calculi provide foundational term languages for abstraction and application.

principle

A ubiquitous language is a shared, model-grounded language used by domain practitioners and software practitioners within an explicitly bounded context. It gives the terms and statements used in conversation, scenarios, documentation, models, interfaces, tests, and code a common boundary-relative meaning.

principle

Universal constructions are principles for naming "the" object determined by a diagram of related objects and morphisms.

principle

The Yoneda lemma says, roughly, that an object is determined by how it relates to all other objects through maps into or out of it.

semantic construct

Authority is the boundary-relative standing by which an observer, role, protocol outcome, or source is accepted as able to make a claim, decision, transition, or effect count for a modeled subject.

semantic construct

Behavior is a time-varying value: a trajectory through state space:

semantic construct

Causality is a dependency relation between events, observations, transitions, decisions, or effects in which one occurrence may have influenced, enabled, required, constrained, or carried information into another.

semantic construct

A command is the interpretation of an event by a given observer as an attempted transition of a target subject.

semantic construct

A domain is a sphere of knowledge, activity, or concern selected as subject matter for understanding, modeling, or action.

semantic construct

An effect is a modeled consequence or obligation established by a semantic decision.

semantic construct

An entity is an enduring, identifiable subject whose state evolves over time under controlled transitions.

semantic construct

An event is a time-bearing occurrence carrying a value. It marks, reports, or induces change depending on how it is interpreted by an observer relative to a boundary.

semantic construct

Identity is what allows a sequence of state observations to be understood as successive versions of the same thing.

semantic construct

Interaction names boundary-relative participation among subjects: how observers, processes, entities, or other participants affect, observe, request, notify, answer, share state with, wait for, or synchronize with one another.

semantic construct

An invariant is a validity constraint that must hold for a modeled subject, transition, process, relation, or boundary.

semantic construct

An observable is a probe, projection, measurement, or field accessor that produces an observation from state.

semantic construct

An **observation** is a contextualized value produced by an observable acting on state. It is the form in which state becomes usable by an observer relative to a boundary.

semantic construct

An observer is a locus of interpretation. It is the participant, context, or execution locus relative to which values, observations, events, commands, queries, boundaries, and state acquire meaning.

semantic construct

A policy is a decision rule that guides or constrains interpretation, authorization, routing, coordination, retention, recovery, or execution.

semantic construct

A process is coherent work unfolding over time.

semantic construct

A query is an observer-relative interpretation of an input event as a request to observe, compute, or return information without requesting a modeled semantic state transition.

semantic construct

A relation is a meaningful connection, dependency, association, correspondence, constraint, derivation, or causal link between semantic subjects.

semantic construct

A shape is the logical structure expected of a value, observation, state view, event payload, command input, query result, or projection result within a model boundary.

semantic construct

A state is the condition or configuration of a subject within a model boundary, modeled as an assignment of values to the subject's relevant dimensions at a time, version, or point in behavior.

semantic construct

A subdomain is a coherent region of a larger domain, distinguished by its subject matter, knowledge, activity, capability, purpose, policy, or strategic value.

semantic construct

Time is the dimension in which occurrences, changes, histories, and behaviors are ordered or compared.

semantic construct

A transition is a semantic decision relation that determines a possible state evolution for one subject boundary from typed input and explicit observations.

semantic construct

Uncertainty is multiplicity in the states, histories, causes, outcomes, or interpretations that an observer cannot yet distinguish at a declared boundary.

semantic construct

A **value** is pure structured data. It is the concrete information used to read, write, transmit, compare, validate, transform, or carry state.

semantic construct

A **version** identifies a point in an entity history at which a particular state became current.

operational concern

ACID is a transaction contract: atomicity, consistency, isolation, and durability.

operational concern

Acknowledgments answer: what does a participant or substrate claim has happened?

operational concern

Admission control decides whether, when, and under which conditions work may enter a bounded system, service, queue, resource, process, or authority scope. Load shedding deliberately refuses, drops, cancels, expires, samples, redirects, or degrades selected work when serving everything would violate more important service or progress constraints.

operational concern

Arbitration resolves local contention among competing eligible occurrences when the system must select, admit, order, or grant one or more of them.

operational concern

The CAP theorem describes an impossibility for distributed shared data under network partition: a system cannot simultaneously guarantee linearizable consistency, availability, and partition tolerance for all executions.

operational concern

Commit Boundaries answer: what becomes accepted as one unit, and within which boundary?

operational concern

Compatibility and evolution describe whether independently versioned producers, consumers, stored histories, schemas, definitions, and realizations can continue to correspond without changing the intended meaning.

operational concern

Concurrency Control answers: How can multiple concurrent histories be reconciled into a single valid history?

operational concern

Consensus answers: how do multiple observers agree on one value despite concurrency, delay, partial failure, or independent local views?

operational concern

Consistency Models constrain which observations are valid for a set of events, transitions, versions, sessions, replicas, and ordering relations.

operational concern

A consistent cut is a selected set of events, versions, observations, or process positions that is closed under the declared causal prerequisites.

operational concern

Consumer coordination describes how eligible observers discover, claim, receive, schedule, and complete work made available through an interaction channel.

operational concern

Coordination answers: how is multi-step or multi-participant work made coherent across observers?

operational concern

Correlation and conversations describe how independently occurring messages, requests, replies, observations, attempts, and process steps are recognized as participating in one interaction or longer-lived protocol.

operational concern

CRDTs, conflict-free replicated data types, are replicated data types designed so that independently updated replicas converge without requiring synchronous coordination for every update.

operational concern

Deadlock and livelock are failures of liveness in which enabled or accepted work does not reach its declared completion boundary.

operational concern

Delivery progress and settlement describe what input an application has durably accounted for and how that durable fact authorizes a later change to provider-managed delivery state.

operational concern

Delivery Semantics answers: what guarantees does an interaction edge provide?

reference

Distributed failure scenarios are recurring hazard shapes that appear when effects, observations, commit boundaries, durability, isolation, coordination, and recovery cross independently governed boundaries.

operational concern

The dual-write problem is the failure mode that appears when one operation tries to commit two or more effects across independent commit boundaries without one atomic commit protocol or durable recovery protocol connecting them.

operational concern

Durability answers: which facts, histories, effects, decisions, or execution material survive which failures?

operational concern

Failure models state which faults, delays, losses, corruptions, recoveries, and correlated disruptions a system or protocol admits when making a correctness or progress claim.

operational concern

Fairness constrains complete executions so that eligible participants, messages, or actions are not postponed forever under the stated assumptions.

operational concern

Flow control regulates how much work may be admitted or remain in flight between participants in response to available capacity.

operational concern

Idempotency is the property that repeated handling of the same semantic input does not produce duplicate domain effects.

operational concern

Interaction control flow identifies which participant or mediating locus actively drives each operation at a distributed interaction boundary.

operational concern

Isolation describes what concurrent operations are allowed to observe of one another while they execute.

operational concern

A linearization point is the logical instant at which an operation takes effect in the abstract sequential history used to justify linearizability. It must lie between that operation's invocation and response.

operational concern

Load balancing governs how admitted work is distributed among eligible capacity-bearing destinations at a declared boundary so that service, capacity, fairness, locality, and failure objectives can be met.

operational concern

Locality is an operational property of the relationship between a workload and its dependencies. It describes how placement and reuse affect the cost of accessing, moving, or reconstructing those dependencies.

operational concern

Metastability is the operational condition in which a system enters a locally persistent, usually degraded operating regime that continues after the disturbance that triggered it has disappeared.

operational concern

Observability and provenance describe the evidence by which observers can inspect, explain, correlate, and diagnose system behavior across boundaries and time.

operational concern

Operational control describes authorized interventions that inspect or change how a running system admits, routes, schedules, pauses, drains, replays, quarantines, purges, resumes, or tests work.

operational concern

Ordering defines the scope within which events, commands, observations, or effects are sequenced.

operational concern

Parallelism describes overlapping execution of work on distinct execution resources at a declared boundary.

operational concern

Partitioning governs how a population of subjects, data, or work is divided into assignment scopes at a declared boundary, and how the assignment behaves as the population, partition set, or rule changes.

operational concern

Persistence answers: what is recorded as authoritative material?

operational concern

Progress Conditions classify liveness guarantees for concurrent or distributed operations.

operational concern

Rate Limiting constrains how quickly work may be accepted, dispatched, delivered, or processed.

operational concern

Reconstitution answers: how is usable state recovered?

operational concern

Recovery defines how a system returns to coherent operation after failure, interruption, conflict, timeout, overload, or partial progress.

operational concern

Retention, expiration, and quarantine describe how long interaction material remains available, when it ceases to be admissible for ordinary processing, and how exceptional material is isolated for inspection, repair, replay, reconciliation, or disposal.

operational concern

Retry is the controlled repetition of an operation after a transient failure, timeout, conflict, or unavailable dependency.

operational concern

Safety and Liveness separate two kinds of operational property of a distributed system.

operational concern

Scalability is a system property describing how its sustainable capacity, efficiency, and service quality change as workload, resources, or topology vary, subject to latency, correctness, availability, backlog, and cost bounds at a stated boundary.

operational concern

Scheduling determines which enabled work receives execution opportunity, in what order, on which resources, and under which priority, fairness, deadline, locality, and capacity rules.

operational concern

Service levels state how the outcomes of a service are measured, targeted, and, when applicable, made accountable commitments between a provider and consumer.

operational concern

Temporal completeness describes when an observer or flow operator may treat the input relevant to a time-bounded result as sufficiently complete to emit, finalize, correct, or retract that result.

operational concern

Two-Phase Commit is a coordination protocol for atomic commit across multiple participants.

operational concern

Version Histories describe the shape of state evolution for a subject, entity, document, repository, projection, or replicated object.

structural construct

Boundaries define the scope and context in which observation, interpretation, authority, failure, persistence, delivery, and coordination apply.

structural construct

A bounded context is a system-graph boundary within which a particular domain model is defined and applicable and its ubiquitous language has consistent meaning and ownership.

structural construct

Business Transactions describe domain-level units of work whose progress, acceptance, rejection, compensation, or completion matters to the business.

structural construct

Control models place adaptive observation, decision, and actuation loops in the system graph.

structural construct

Effect models describe how semantic effects are placed, related, scoped, and carried through the system graph.

structural construct

An interaction endpoint is a boundary-relative attachment locus at which a participant, through a port or adapter, sends to or receives from one or more channel directions under an interface and protocol binding.

structural construct

Entity models describe how the semantic entity role is arranged in the system graph.

structural construct

Flow operators are compositional structures that transform, select, divide, combine, order, or distribute values moving through flow views.

structural construct

Flow views describe movement through the system graph over time.

structural construct

Fork and join are paired process-graph structures that expand one continuation into several branch activations and later synchronize selected branch completions into a continuation.

structural construct

An infrastructure graph is the system graph projection that relates modeled system structure and guarantee demands to public realization substrate concepts and capability evidence.

structural construct

An interaction binding relates the semantic and structural parts of an interaction at one exact boundary without making them identical. It states how interface contract roles and protocol roles attach through endpoints to exact channel directions, and which realization is authorized to carry them.

structural construct

An interaction channel is a provider-neutral logical exchange through which values, messages, observations, signals, requests, replies, events, or framed data can move among endpoints. It gives the exchange a stable structural locus, identifies its logical directions, and provides scopes to which required observable properties can be attached.

structural construct

An interaction protocol describes the allowed temporal structure of interactions through an interface. It constrains not only the values that may be exchanged, but also which roles may initiate, which occurrences may follow, how concurrent attempts relate, and how a conversation completes, fails, is cancelled, or remains live.

structural construct

An interface is a declared interaction surface at a boundary. A boundary distinguishes scopes; an interface makes selected crossings of that boundary available and constrains what may cross, in which role, and with what meaning.

structural construct

Invariant scopes describe where semantic invariants are attached in the system graph.

structural construct

Messages and envelopes describe the finite carriers used to move values and interaction metadata across system-graph boundaries.

structural construct

A microservice is a logical service node in a service model with an explicit profile for independent semantic evolution, contract evolution, ownership, deployment, scaling, failure, recovery, and operation. The profile states which of those boundaries align and where independence remains partial rather than treating *micro* as a code-size or process-count rule.

structural construct

Multiplexing combines several distinguishable logical interaction flows onto a shared interaction channel or node. Demultiplexing uses an address, key, type, correlation identifier, or other discriminator to recover the intended logical flow or destination.

structural construct

Observer models describe how semantic observers are placed in the system graph.

structural construct

Partition models describe how subjects, histories, relations, observations, or work are assigned to distinct ownership, ordering, storage, and execution scopes in the system graph.

structural construct

Policy scopes describe where semantic policies are attached in the system graph.

structural construct

Process graphs describe how semantic processes are arranged across time, observer models, entity models, relation models, boundaries, and external systems.

structural construct

Projection models describe how derived observations or derived state views are arranged in the system graph.

structural construct

Relation models describe how semantic relations are represented in the system graph.

structural construct

Replica models describe how one logical subject, history, service role, or derived view is arranged across multiple replica observers in the system graph.

structural construct

Routing models describe how an interaction selects destinations, recipients, paths, or next processing loci in the system graph.

structural construct

A service model is a system-graph view that bundles semantic responsibilities into logical services and connects their provided and required interfaces through interaction channels. Interaction protocols and operational envelopes qualify how those interactions may proceed. It mediates between the domain's entities, relations, queries, and processes and the concrete repositories, deployments, runtimes, and schedulers that realize them.

reference

The system graph is the compositional, boundary-relative graph of a modeled system as a whole, in which semantic subjects and roles become explicit nodes and relations with declared placement, interaction, ownership, scope, and boundaries.

structural construct

Transition models describe how the semantic transition role is arranged in the system graph.

realization substrate

Actor Systems are runtimes that organize execution around addressable actor identities, message delivery, placement, isolation, and serialized handling per actor.

pattern

Additive increase multiplicative decrease, commonly abbreviated AIMD, is a feedback-control pattern that probes for additional capacity with gradual additive increases and responds to congestion or overload with proportional decreases.

realization substrate

Application Hosts are runtime containers for application code, request handling, background work, dependency management, and operational concerns.

realization substrate

Batch and file exchange is a realization substrate for moving finite collections, documents, snapshots, deltas, manifests, or artifacts across system boundaries through durable named objects.

realization substrate

Brokers are concrete messaging substrates that mediate delivery between producers and consumers.

realization substrate

Compute is the concrete capacity that executes work: CPU, memory, processes, containers, virtual machines, functions, tasks, nodes, clusters, and other execution resources.

realization substrate

Consensus Protocols are concrete protocol families that realize consensus under specified network, failure, timing, persistence, and membership assumptions.

pattern

CQRS, command query Responsibility Segregation, is a realization pattern that separates the write side that interprets commands and persists authoritative change from the read side that answers queries by reconstituting queryable observations.

realization substrate

Database Transactions are bounded units of database work whose covered operations commit or abort according to a transaction manager's contract.

realization substrate

Durable execution engines are concrete runtimes or substrate mechanisms that realize the durable execution architecture practice.

pattern

Event sourcing is a realization pattern in which an entity's durable history is represented by committed persistence events rather than only by current-state records.

realization substrate

Infrastructure is the concrete operational environment that provides compute, networking, storage, deployment, security, observability, and platform services.

realization substrate

Network is the realization substrate for interaction across link, network, transport, and application protocol boundaries.

realization substrate

A network channel is a protocol-layer communication locus realized through network addresses, links, paths, datagrams, connections, streams, sessions, frames, buffers, and their control state. It is distinct from the provider-neutral interaction channel and is not a synonym for an application or messaging channel.

pattern

An outbox is a realization pattern that stores an outbound effect obligation in durable persistence, usually in the same local commit boundary as the state change that created the obligation.

pattern

PID control is a feedback-control pattern that forms a control action from proportional, integral, and derivative contributions of an error signal.

realization substrate

Realization is the relation by which semantic roles, system graph, operational concerns, and architecture practices are made concrete in a substrate.

realization substrate

Runtimes are execution environments that host code and provide operational behavior.

realization substrate

Scaling mechanisms are concrete ways to change resource capacity, execution population, or system topology in an attempt to improve scalability or elasticity.

realization substrate

Storage Systems are concrete mechanisms for durable or semi-durable data: databases, event stores, object stores, key-value stores, logs, file systems, caches, and actor state providers.

realization substrate

TLA+ is a formal specification language and tool ecosystem for describing and analyzing concurrent and distributed systems. It provides a concrete realization substrate for selected temporal-logic and state-machine models; it is not the semantic notion of temporal logic itself and is not a production execution runtime.

realization substrate

Workflow Engines are runtimes for defining, coordinating, and operating multi-step workflows across time.

pattern

Write-Ahead Logging, or WAL, is a storage recovery pattern in which durable recovery records are written before the corresponding state changes are allowed to become unrecoverable.

architecture practice

The actor model addresses the problem of organizing concurrent computation around isolated, addressable participants that communicate by message passing.

reference

Analysis Patterns, by Martin Fowler, collects reusable structures discovered while modeling domains such as health care, financial trading, accounting, and organizational relationships.

pattern

An anti-corruption layer addresses the problem of integrating with another model without letting that model's semantics leak into the local boundary.

reference

Architecture practices are named bundles of modeling choices, constraints, and implementation habits that address recurring system-engineering problems.

architecture practice

Asynchronous interaction design is the architecture practice of making independently progressing work explicit when one interaction is split across time, participants, and commit boundaries.

architecture practice

Capacity planning is an architecture and operational practice for relating expected demand, service-level objectives, failure assumptions, and provisioning lead times to the effective capacity and reserve a system must have available.

architecture practice

Clean Architecture addresses the problem of dependency direction: keeping high-value semantic rules from depending on volatile delivery, persistence, framework, and infrastructure choices.

architecture practice

CQRS, command query responsibility segregation, is an architecture-practice bundle that deliberately gives command interpretation and query observation different models, responsibilities, and operational paths when their forces differ materially.

architecture practice

CRDTs are a distributed-systems practice for designing replicated state that can accept concurrent updates and converge without synchronous coordination for every update.

architecture practice

Data Mesh addresses the problem of scaling analytical and operational data ownership across organizational and domain boundaries.

architecture practice

Domain-Driven Design, or DDD, addresses the problem of preserving domain meaning in software as systems grow in complexity.

pattern

Durable execution is an architecture practice for keeping a logical execution coherent across failure, restart, suspension, timeout, or delayed external work.

reference

Enterprise Integration Patterns, or EIP, is a technology-independent pattern language for message-based integration. Cohesive uses the catalog as an important architecture vocabulary while preserving the distinction among domain semantics, system-graph structure, operational concerns, architecture practices, and realization substrate.

architecture practice

Event sourcing is often described as an architecture practice. In the Cohesive System Model, the technical mechanics are captured by event sourcing as a realization substrate pattern.

architecture practice

Event-Driven Architecture addresses the problem of coordinating independent participants through event flow rather than direct synchronous control.

architecture practice

Microservice architecture addresses the problem of independent ownership, deployment, scaling, and evolution across bounded capabilities. These benefits are not exclusive to microservices: a modular monolith can establish similar semantic and code boundaries and can selectively separate deployment or scaling units. The prefix *micro* is relative to a coarser service, application, or deployment boundary; it does not prescribe a code size, endpoint count, process count, or team size.

reference

The microservice pattern language collects architecture-practice patterns that allocate semantic responsibility and authority to independently evolvable services, connect them in service models through provided and required interfaces, govern their conversations with interaction protocols, state their operational guarantees, and select realization mechanisms. It covers decomposition, collaboration, data ownership, transactional messaging, communication, deployment, discovery, reliability, security, observability, testing, and migration.

architecture practice

The modular monolith addresses the problem of maintaining strong internal boundaries and cohesive change units within one repository and one compiler-visible solution or build graph. The shared graph enables static contract checking, compiler-enforced dependency rules, coordinated refactoring, shared code, and common repository and delivery infrastructure across the modules.

pattern

Orchestration and choreography are forms of coordination distinguished primarily by where control of a coherent process resides.

reference

Pattern-Oriented Software Architecture, or POSA, is a multi-volume system of architectural patterns, design patterns, idioms, concurrency and networking patterns, resource-management patterns, and a composed pattern language for distributed computing.

reference

Patterns of Distributed Systems, by Unmesh Joshi, collects recurring implementation structures used in distributed storage, messaging, system management, and compute infrastructure.

reference

Patterns of Enterprise Application Architecture, or PoEAA, catalogs recurring structures for domain logic, application boundaries, relational persistence, web presentation, distribution, offline concurrency, session state, and foundational mapping or gateway roles.

pattern

Ports and Adapters addresses the problem of keeping domain and application semantics independent from specific infrastructure, protocols, user interfaces, and external systems.

pattern

Process managers are an orchestration pattern for coordinating a process across participants, time, effects, and failure boundaries.

pattern

Sagas are process managers specialized for domain process recovery across system boundaries where one atomic transaction is unavailable, too expensive, or misaligned with the domain process.

reference

This note connects the dedicated entries for sagas and process managers.

pattern

The transactional inbox addresses the consumer-side problem of processing a delivered input exactly once in domain meaning when the delivery substrate may redeliver it.

architecture practice

Transactional outbox is the architecture practice of using an outbox to tie an accepted local state change to downstream publication responsibility without a distributed transaction between storage and consumer.

architecture practice

Weak isolation patterns are architecture practices for preserving useful correctness when one ACID transaction or two-phase commit boundary is unavailable, too expensive, or misaligned with the domain process. This is mostly about deciding which weaker guarantees become explicit parts of the domain protocol, entity model, process state, and recovery behavior.

reference

Workflow Patterns is a research-based pattern language for recurring requirements in process-aware information systems and workflow languages. The original catalog identifies twenty implementation-independent control-flow patterns. The broader initiative also catalogs data, resource assignment, exception handling, and event-log imperfections.