Skip to main content
biology computer-science performing-arts

​
Serialization

​
Description

Serialization is the move of turning a working thing into a portable, inert encoding so it can be stored or shipped, then later turned back into a working thing. The defining triad is active → inert → active: the middle form does nothing on its own — that inertness is exactly what lets it sit on a disk or cross a wire — and a reconstitution step revives it. In software, an in-memory object graph is serialized to a byte stream and deserialized back into a live object, possibly in another process or machine. The same shape recurs far from CS: a musical score serializes a performance (the score is inert; performing it deserializes); writing serializes speech or thought (reading deserializes); a blueprint serializes a design (building deserializes). The home-domain term-of-art is marshalling when the gap is a network boundary specifically. The load-bearing claim — and the reason this is a distinct primitive rather than a synonym for isomorphism — is the active/inert distinction plus the store-and-reconstitute gap. An isomorphism maps one live structure to another live structure; serialization deliberately routes through a non-executable intermediate and inserts a time-or-space gap during which only the inert form exists. That gap is the whole point: it is what storage and transmission are.

​
Triggers

User-initiated: User describes capturing a live thing into a storable/shippable form and rebuilding it later. Vocabulary cues: “serialize,” “deserialize,” “marshalling,” “wire format,” “snapshot and restore,” “dehydrate/rehydrate,” “save and reload,” “notation and performance.” Agent-initiated: Agent notices a working form being reduced to a portable encoding to cross time or space, with a reconstitution step on the far side. Candidate inference: name the active form, the inert form, and confirm the deserialize path actually recovers a working form (not a lossy one-way capture). Situation-shape signals: Persistence and transport boundaries; save/load; the score-to-performance or blueprint-to-building relation; any place a representation stands in for an executable original across a gap.

​
Exclusions

  • Structure-preserving maps with no inert phase — an isomorphism relates two equally-active forms; serialization adds the active↔inert↔active round-trip.
  • Runtime interface translation — an adapter bridges two co-present live interfaces; serialization is store-now-revive-later, with the active form absent while the inert form travels.
  • One-way capture with no reconstitution — a photo or lossy summary is inert and portable but can’t be rebuilt into the working original; without a deserialization path the primitive doesn’t fire.
  • Encoding of something that was never active — re-encoding already-inert data (transcode, charset conversion) is plain encoding; serialization needs an executable form on at least one end.

​
Structure

Internal structure of serialization: a table of its component slots and the concepts that fill them.

​
Relationships

Relationship neighborhood of serialization: a graph of the concepts it connects to and the concepts it is a part of.
  • isomorphism — the structure-preserving correspondence, routed here through an inert intermediate plus a store/transmit gap.
  • adapter — bridges two co-present live interfaces; serialization bridges a form to itself across time/space via an inert carrier.
  • seam — serialization lives at the boundary between a native format and a foreign storage/wire format; deserialization bugs cluster there.
  • error-correction — the inert form crosses an unreliable gap, so robust serialization pairs with redundancy and integrity checks.

​
Examples

ISO/IEC 23271:2012 (Common Language Infrastructure) — defines serialization as "the process of converting an object or a graph of objects into a linear sequence of bytes." · computer-science

The namesake instance. A live in-memory object — with its fields, references, and possibly a whole graph of connected objects — is the active form: it can be called, it holds behavior and state. Serialization converts that graph into a linear sequence of bytes (the inert form), which can be written to disk, cached, or sent across a network. The bytes do nothing on their own; they are pure encoding. Deserialization reads the bytes back and reconstitutes a live object graph, often in a different process or on a different machine. The CLI standard’s definition fixes exactly this active-graph-to-byte-sequence transform, and marshalling is the same move when the gap is specifically a remote-call boundary.Inference: This is the cleanest illustration of why the inert middle form is constitutive rather than incidental. The object cannot itself travel over a wire — only bytes can — so the active form is deliberately reduced to something that does nothing, precisely so it can cross the gap. The round-trip active → inert → active, with a store-or-transmit interval in the middle, is the whole structure; an in-place object copy that never leaves memory would be an isomorphism-flavored duplication, not serialization, because it skips the inert-and-portable phase that defines the primitive.

Francis Crick, "Central Dogma of Molecular Biology" (Nature 227, 1970), building on Crick, "On Protein Synthesis" (Symp. Soc. Exp. Biol. XII, 1958). · biology

The central dogma reads as a biological serialization. DNA is the inert, stable, transmissible form — a chemically robust double-stranded sequence that does little on its own but encodes build-instructions, and it is exactly the form passed across generations and copied for storage. Transcription (DNA → RNA) and translation (RNA → protein) are the deserialization path that reconstitutes the active form: the working proteins and enzymes that catalyze, signal, and build. The inert sequence stands in for the active machinery across both time (heredity) and space (a cell elsewhere reading the same genome).Inference: The analogy is structurally defensible but has documented breakdown points worth keeping honest, and they sharpen rather than weaken the mapping. DNA is not perfectly inert — methylation and chromatin remodeling alter its expressed meaning without changing the sequence (an annotation layer on the inert form). And the deserialization machinery is recursive: ribosomes and polymerases are themselves products of prior deserialization, so unlike a CS deserializer that is external to its data, biology’s reader is built from what it reads. The serialization shape still lands — active↔inert↔active across a storage gap — but biology adds a self-referential twist that pure software serialization lacks.
A musical score serializes a performance. The performance is the active form — sound unfolding in time, the thing that actually happens. The score is the inert form: static notation on a page that does nothing acoustically but encodes enough of the work’s structure (pitch, duration, meter) to be stored, copied, and shipped to musicians anywhere. Performing the score is deserialization — reconstituting a live, sounding form from the notation. Goodman’s analysis of notation treats the score precisely as what fixes a work’s identity across the gap between composer and distant performer.Inference: This instance foregrounds the lossy character that serialization can have, which the schema accommodates. Standard notation does not capture timbre, micro-timing, or expressive nuance — the deserializer (the performer) supplies interpretation, so two faithful “deserializations” of the same inert form differ audibly. That is unlike a typical CS byte-stream round-trip, which is designed to be lossless. The active↔inert↔active structure is intact; fidelity of reconstitution is a quality axis of a serialization, not a precondition for the primitive to apply.