Code Describes; A Machine Performs
A powered circuit can wait in readiness without performing the operation we care about. Computation begins when signals and stored state travel through that structure.
Code gives data an architectural job. An interpreter, compiler, processor, or configuration mechanism reads its symbols and selects, schedules, or constructs behavior from available resources. A source file may describe millions of possible executions; one execution occupies particular devices, memory, wires, time, energy, and communication paths.
A programming language gives thought an executable canvas. It can hold logic, mathematics, facts, rules, behaviors, simulations, and estimates outside the mind, then let a machine test them. The description gains consequence only when a physical or virtual structure carries it.
Controlled Selection Builds Digital Logic
One elementary digital act chooses which source can reach an output:
d = a ? b : c;The control a chooses whether b or c influences d. Hardware names this device a 2:1 multiplexer. Trees of multiplexers, constants, and input signals can realize every combinational Boolean function.
The physical machine must also propagate the choice. Charge and electromagnetic state move through transistors and interconnect; outputs settle; drivers feed loads. Noise margin, delay, fan-out, and energy determine whether the symbol on paper works in silicon.
Many physical systems carry information for an observer. Reliable automatic switches do more: they recognize a condition repeatedly and change a path or state without manual reconnection. Goals come from an agent; control supplies the mechanism that pursues them.
Every Allocation Claims A Place
A language lets us write list.push(x) as though a new location simply appears. The runtime must use reserved capacity or find another finite region, transfer ownership, copy surviving values, update references, and eventually release the former region.
Abstraction hides those operations so programmers can work at a useful level. It cannot erase location. Every allocation assigns bounded storage and a communication path to new state.
A tree makes the principle visible. Carbon becomes part of a leaf only where matter, energy, transport, and structure can meet. A computer uses different materials, yet physical reality still refuses to append into nowhere. Good abstractions state what they promise while an architecture fulfills the promise underneath.
Three Views Expose The Whole Computation
A precise system description answers three independent questions.
Many diagrams mix all three. One box might mean a device, a software instance, a callable function, or an invocation in flight. One arrow might mean a wire, a possible call, a message already sent, or permission to communicate. A polished picture can still hide the machine.
Assign each diagram a view. That single decision resolves more ambiguity than another layer of boxes.
Physics Sets The Operating Envelope
A physical computation occupies finite volume and time. Devices take space. Signals need time to propagate and settle. Storage requires a medium. Heat must escape. Packaging, power delivery, cooling, repair, and fabrication yield can constrain a system before its Boolean expression does.
Two constraints recur at every scale:
- Switching and propagation time: how quickly a device and its interconnect can produce a usable next state under the required voltage, load, process, and temperature.
- Communication capacity across boundaries: how much information can cross a package edge, board connector, rack network, clock-domain boundary, memory interface, or other physical boundary within the required time and energy.
Technology, encoding, geometry, signal integrity, cooling, and topology set clock and bandwidth limits together. Every useful region needs finite interfaces that feed it, synchronize it, observe it, and support repair.
Dense on-chip metal cannot extend unchanged through an arbitrarily large three-dimensional computer. Stacks accumulate thermal and mechanical pressure. Deeply buried components resist test and replacement. A data center needs aisles, power conversion, cables, switches, cooling equipment, and people because a computer at that scale becomes a building.
A useful architectural sketch therefore shows switching and storage inside each region, then names the latency and throughput of every boundary between regions. Movement belongs in the computation.
Logical Structure Assigns Every Resource A Role
Physical structure tells us what exists. Logical structure tells us what each available resource does now.
Machine instructions select behavior from a processor's registers, decoders, arithmetic units, caches, and interconnect. A compiled function spreads its logical structure across those resources and across time. A specialized accelerator brings the logical and physical shapes closer by dedicating a datapath to a narrower role.
Hierarchy keeps both designs manageable. A subsystem exposes a boundary, accepts inputs, produces outputs, and contains decisions that its neighbors do not need. A larger component can connect several subsystems without reproducing their interiors.
Sensors and actuators change the medium while preserving the need for a boundary. A camera converts light into electrical state. A radio crosses between electromagnetic fields and samples. A network stack converts timed electrical or optical changes into frames and messages. Digital systems encode these exchanges as bit streams; the world supplies richer physical phenomena on either side.
Data And Control Make A Protocol
Data carries values through a transformation. Control says when a value holds meaning, where it should go, whether a buffer can accept it, which operation applies, and where a transaction begins or ends.
The distinction describes roles rather than substances. A wire, packet field, or stored bit can carry data at one boundary and control at another. Some protocols dedicate separate signals; others place control beside payloads or encode it in timing.
Together, data and control make communication unfold through time. An interface specifies meaningful changes, their order, and the clock or handshake that governs them. A real connection aligns validity, capacity, ordering, backpressure, reset, and failure behavior on both sides.
Every crossing into another clock, process, device, or administrative domain makes communication part of the computation's structure. Distributed systems begin inside the machine, not at the edge of computer science.
Runtime State Puts The Computation In Motion
Structure describes possibilities. Runtime state selects the possibility unfolding now.
Current inputs and intermediate electrical states determine the settling output of a combinational network. Latches, flip-flops, SRAM, and other storage retain consequences of earlier events. Feedback through that storage creates counters, protocols, state machines, pipelines, and processors.
A useful hardware graph shows selection, logic, routes, and every place that holds a past value. Multiplexer networks express Boolean choice. Storage separates one step from the next. Clocks or event handshakes decide when retained values enter the visible state.
Pipelining assigns state to intermediate positions so several inputs can occupy different stages at once. Memory holds values away from their operations. A hardwired constant belongs to structure; a constant in configuration storage belongs to long-lived state. Placement changes the architecture.
Large systems often join locally synchronous regions through asynchronous protocols or explicit clock-domain crossings. GALS—globally asynchronous, locally synchronous—embraces that structure. A sound boundary protocol carries state safely between regions.
Structural Change Builds A Different Machine
Architecture gains another dimension when a system can change its own graph.
Software creates objects, processes, queues, files, and virtual connections while CPU and GPU circuits largely retain their physical topology. Instructions change logical ownership and state by scheduling the same resources across time.
An FPGA exposes configuration bits that select lookup-table contents, routing paths, I/O behavior, and other resources. Loading a bitstream changes the logical circuit inside the fabric. Partial reconfiguration can replace a bounded region while neighboring regions keep operating through stable interfaces and timing rules.
People and robots can change physical structure directly: add a board, replace a failed module, move a cable, assemble another machine, or install a rack. A live migration changes structure and state together because the service must carry its history into a new home.
Precise verbs make those operations executable. Create assigns existing resources to a new owner. Connect names a path and protocol. Move preserves the required state. Replace keeps a boundary stable while changing its interior.
Temporal reuse and spatial construction mark two ends of one design choice. A processor reuses an arithmetic unit across instructions; a parallel circuit places many units side by side. Vectorization, threading, pipelining, and hardware generation decide which work unfolds through time and which work occupies space.
Identity And Ownership Make Hierarchy Real
A type, class, template, or hardware module describes a possible structure. An instance gains identity through the state that records its memory, pending messages, and authority over resources, even when no dedicated patch of silicon belongs to it.
Hierarchy reaches beyond indentation. A parent allocates a region or resource set, gives a child a controlled interface, and retains authority to replace or release it. Homogeneous reconfigurable fabrics bring those operations into the machine: local cells can become routes, selectors, constants, state, or configuration ports, so grouping and ownership become fabric operations.
Construction, identity, state, communication, and replacement carry physical consequences even when a language hides them. An architecture becomes complete when it assigns those consequences to explicit mechanisms.
Read Any System In Three Passes
Three passes turn an unfamiliar system into a concrete architecture.
- Structure: What has been built? Where are the boundaries? Which paths and operations exist?
- State: What is present now? Where can it wait? Which history must survive the next event?
- Structural change: Which mechanism creates, reconnects, resizes, upgrades, migrates, or retires each part, and who controls it?
The questions illuminate a circuit, software service, data center, or organization while preserving each system's physics and incentives. They turn vague architecture words into mechanisms that an engineer can inspect.
A general architecture of computation now comes into focus: name what exists, follow the state moving through it, and identify the authority that can change its shape.