Serialization
Serialization is the encoding of structured data or in-memory values into a representation suitable for storage or transmission and later reconstruction.
Data-Oriented Programming: Reduce software complexity
Serialization is the conversion of structured data into a representation suitable for storage or transmission.
- How it is used
- Uses JSON to move structured data between search endpoints, tests, and files.
- How deep it goes
- Explains conversion, generic-access trade-offs, readable output, and test comparison, but stops short of serialization internals.
- Examples
- Demonstrates search endpoint payloads, captured catalog context, JSON file formatting, and deserialized search-result assertions.
- What you can do after
- Apply it via JavaScript JSON.stringify and JSON.parse to store, inspect, reload, and test structured data.
Read how Data-Oriented Programming: Reduce software complexity explains serialization →
Django in Action
Serialization is the conversion of in-memory objects or data structures into a representation suitable for storage or transmission.
- How it is used
- Transforms Django ORM objects into API responses that clients outside the application can consume.
- How deep it goes
- Demonstrates schema declarations, selected model fields, response annotations, querysets, and computed serializer fields.
- Examples
- Uses promoter list and detail responses, plus Venue output augmented with slug and URL fields.
- What you can do after
- Build API responses with Django Ninja schemas that serialize models, querysets, and computed fields into JSON.
Learn Go with Pocket-Sized Projects
Marshal is an operation that converts a structured program value into an encoded byte sequence.
- How it is used
- Uses Marshal to create structured JSON logs and to encode JSON or XML when no io.Writer is available.
- How deep it goes
- Explains Marshal versus Encoder through API guidance and examples, while deferring broader encoding concepts to later treatment.
- Examples
- Uses JSON log records, a tagged person structure, and XML exchange-rate responses as concrete encoding and decoding examples.
- What you can do after
- Apply it via encoding/json.Marshal or encoding/xml.Marshal when converting structured values without a writer.
Read how Learn Go with Pocket-Sized Projects explains serialization →
API Design Patterns
A serialization protocol is a defined mechanism for converting structured data into a transferable representation and reconstructing it later.
- How it is used
- Connects API resources across programming languages by defining transferable representations and reconstruction rules.
- How deep it goes
- Explains transfer, lossiness, numeric hazards, export formats, and post-processing, but does not detail protocol internals.
- Examples
- Uses API resources, JSON numeric comparisons, Decimal.js arithmetic, CSV messages, and JSON, CSV, ZIP, or BZ2 configurations.
- What you can do after
- Apply it via JSON or export formats while accounting for precision, defaults, compression, encryption, and client compatibility.
Akka in Action, Second Edition
Marshalling is the conversion of in-memory data or objects into a representation suitable for transmission in a communication protocol.
- How it is used
- Enables actor messages to cross JVM boundaries and HTTP values to cross client-server boundaries.
- How deep it goes
- Explains serializer binding, marker traits, JSON formatters, and schema-evolution concerns without implementing a custom serializer.
- Examples
- Uses distributed word-count messages, evolving AddCargo events, and a sharded cargo HTTP endpoint returning JSON.
- What you can do after
- Apply it via Akka Jackson and Spray JSON by binding marker traits and providing implicit formatters.
Read how Akka in Action, Second Edition explains serialization →
Kafka for Architects
Serialization is the process of converting structured data into a transferable representation such as bytes or text.
- How it is used
- Coordinates data exchange between Kafka producers and consumers while leaving message interpretation to client configuration.
- How deep it goes
- Explains client configuration and runtime consequences, then traces serialization through batching and delivery without implementing custom serializers.
- Examples
- Uses primitive serializer configurations, JSON in a Customer 360 project, and AsyncAPI message definitions.
- What you can do after
- Operate/configure Kafka clients by selecting compatible serializers and deserializers and documenting shared message formats.
Rust Servers, Services, and Apps
Serialization is the conversion of an in-memory data structure into a structured representation suitable for transmission or storage.
- How it is used
- Turns server-side response structs and application data into HTTP messages or JSON exchanged with web clients.
- How deep it goes
- Explains response fields, Rust conversion code, stream writing, JSON APIs, and exact-output tests without covering serialization formats beyond HTTP and JSON.
- Examples
- Uses serialized HTTP 200 and 404 responses, an order-status JSON API, and exact-output unit tests.
- What you can do after
- Build it from scratch by converting Rust HTTP response structs into wire messages and handling JSON data in web handlers.
Read how Rust Servers, Services, and Apps explains serialization →
Latency
Serialization is the conversion of in-memory data structures or objects into a representation suitable for storage or transmission.
- How it is used
- Identifies conversion work at network and storage boundaries as a potential application-latency bottleneck.
- How deep it goes
- Defines both conversion directions and illustrates byte representation, but does not provide a serialization implementation.
- Examples
- Traces an online-store order through JSON transport, server processing, storage, and a possible Protocol Buffers RPC.
- What you can do after
- Diagnose/debug with it by profiling conversion work and checking for redundant serialization, deserialization, or memory copies.
Building User-Friendly DSLs
Serialization is the conversion of structured in-memory data into a storable or transferable representation.
- How it is used
- Persists and transports frontend ASTs through a JSON-backed REST backend.
- How deep it goes
- Explains recursive transformation and reference replacement, while deferring the reverse reconstruction to deserialization.
- Examples
- Uses a rental AST, generated identifiers, nested settings, and ref-to-refId transformations.
- What you can do after
- Build it from scratch by assigning IDs and recursively converting AST references into JSON-compatible data.
Read how Building User-Friendly DSLs explains serialization →
Graph Neural Networks in Action
Serialization is the conversion of in-memory or structured data into a representation suitable for storage or transmission and later reconstruction.
- How it is used
- Uses serialization to store, export, and transfer raw graph data between systems and GNN libraries.
- How deep it goes
- Defines serialization and provides format-selection criteria, but stops short of format-specific implementation details.
- Examples
- Uses JSON recommendation logs, hashed candidate identifiers, edge lists, adjacency matrices, CSV, XML, Pickle, Avro, and matrix formats.
- What you can do after
- Apply it via selecting interoperable formats and transforming raw graph data for NetworkX or PyTorch Geometric workflows.
Read how Graph Neural Networks in Action explains serialization →
Troubleshooting Java, Second Edition
Serialization is the process of transforming structured in-memory data into a transferable or storable byte representation.
- How it is used
- Diagnoses data-contract failures across REST, gRPC, messaging, and other service communication boundaries.
- How deep it goes
- Explains byte conversion, mismatch symptoms, schema evolution, and compatibility, then applies them to a Protobuf schema.
- Examples
- Uses changed JSON fields, renamed Protobuf enums, Java serialVersionUID differences, and an Order Protobuf schema.
- What you can do after
- Diagnose silent data loss, default values, and deserialization errors while evaluating contract changes for compatibility.
Read how Troubleshooting Java, Second Edition explains serialization →
Go in Action, Second Edition
Marshaling is the process of converting an in-memory value into a serialized representation.
- How it is used
- Uses serialization to validate and convert structured input in a JSON/XML command-line pipeline.
- How deep it goes
- Explains struct-tag mapping, decoding into Go values, and custom JSON methods; it does not develop a new serialization format.
- Examples
- Uses server-configuration JSON, a tagged Config struct, URL validation, and host redaction.
- What you can do after
- Apply it via encoding/json and encoding/xml to convert structured data, with custom JSON methods when validation or redaction is needed.
Read how Go in Action, Second Edition explains serialization →
Go in Practice, Second Edition
Serialization is the conversion of in-memory data into a representation suitable for storage or transmission.
- How it is used
- Uses reflection to serialize structs into a custom INI-like format and restore them from encoded bytes.
- How deep it goes
- Implements field tagging, validation, formatting, scanning, parsing, and type conversion, while handling only structs.
- Examples
- Demonstrates tagged process statistics, key-value output, go run execution, and reconstruction into a second struct.
- What you can do after
- Build it from scratch by implementing reflection-based Marshal and Unmarshal functions for a tagged Go struct.
Read how Go in Practice, Second Edition explains serialization →
.NET in Action, Second Edition
Serialization is the conversion between structured in-memory objects and an external data representation such as JSON.
- How it is used
- Uses serialization as a shorter way to read and write JSON when its schema is known.
- How deep it goes
- Defines conversion and demonstrates deserialization, filtering, and projection; defers property-name correction to a later treatment.
- Examples
- Uses a jokes array, Joke records, category filtering, and a benchmark comparing Newtonsoft.Json with System.Text.Json.
- What you can do after
- Apply it via System.Text.Json to deserialize typed records, filter results with LINQ, and serialize a reduced projection.
Read how .NET in Action, Second Edition explains serialization →
Kotlin in Action, 2E
Serialization is the process of converting an object's state into a representation that can be stored or transmitted and later reconstructed.
- How it is used
- Uses serialization to preserve view state and to convert arbitrary Kotlin objects into customizable JSON representations.
- How deep it goes
- Explains nested-class failure mechanics and implements reflective property traversal, while deferring broader annotation customization details.
- Examples
- Demonstrates serializable view state, Kotlin ButtonState nesting, and a reflective JSON serializer that emits property-based objects.
- What you can do after
- Build a reflective JSON serializer and avoid accidental outer-instance references when defining serializable nested state classes.
The Quick Python Book, Fourth Edition
Serialization is the transformation of an in-memory data structure or object into a representation suitable for storage or transmission.
- How it is used
- Moves Python data between memory, files, and network responses through serializable representations.
- How deep it goes
- Explains JSON encoding, decoding, default type mappings, formatting, file handling, and pickle limitations without implementation internals.
- Examples
- Uses weather API responses, nested weather dictionaries, pretty-printed output, JSON files, and newline-delimited weather reports.
- What you can do after
- Apply JSON encoding and decoding with Python's json module and requests, while recognizing when pickle is unsafe or inefficient.
Read how The Quick Python Book, Fourth Edition explains serialization →
The Joy of JavaScript
The process of converting data or objects from one representation into another for storage, transmission, or reconstruction.
- How it is used
- Converts application objects to JSON, files, buffers, or network-ready data, then reconstructs and processes them incrementally.
- How deep it goes
- Explains custom symbol hooks, JSON fallback, composed buffer pipelines, streamed parsing, hydration, and validation.
- Examples
- Uses blockchain blocks, delimiter-separated ledger files, UTF-8 buffers, async file generators, and validation of reconstructed chains.
- What you can do after
- Build it from scratch by defining object-specific JSON hooks and composing serializers for complete or streamed file representations.
Learn PowerShell in a Month of Lunches: Fourth Edition, Covers Windows, Linux, and macOS
Serialization is the conversion of an in-memory object or data structure into a representation suitable for storage or transmission.
- How it is used
- Supports PowerShell remoting by converting command output into XML for network transmission and reconstruction.
- How deep it goes
- Defines the conversion process and explains snapshots, lost behavior, and remote-processing consequences.
- Examples
- Uses remote process and event-log filtering examples, including Invoke-Command pipelines and serialized process output.
- What you can do after
- Apply serialization knowledge via PowerShell remoting to filter remotely and avoid treating results as live remote objects.
Kafka Streams in Action, Second Edition
Serialization is the process of converting structured data into a representation suitable for storage or transmission.
- How it is used
- Moves structured application events across Kafka’s storage and network boundaries as byte arrays.
- How deep it goes
- Explains broker boundaries, schema contracts, and custom Java interfaces, but defers detailed schema-registry workflows.
- Examples
- Uses a JSON Person schema and Java Jackson-based custom serializer and deserializer implementations.
- What you can do after
- Builds custom Kafka serializers and deserializers or applies Schema Registry-provided implementations.
Read how Kafka Streams in Action, Second Edition explains serialization →
Functional Design and Architecture: Examples in Haskell
Serialization is the transformation of structured data into a representation suitable for storage or transmission and later reconstruction.
- How it is used
- Uses serialization to connect typed application data with logging services and key–value database representations.
- How deep it goes
- Descends to field parsing, type-class contracts, decoding failures, and domain reconstruction, but does not develop serialization algorithms internally.
- Examples
- Uses Sentry records, parsed timestamps, Meteor entities, database keys, encoded values, and generic loadEntity as concrete examples.
- What you can do after
- Apply it via conversion functions and type-class contracts to persist entities or populate service-specific records.
Read how Functional Design and Architecture: Examples in Haskell explains serialization →
Acing the CCNA Exam: Volume 2 Advanced Networking and Security
Data serialization is the process of converting data into a standardized representation suitable for storage or transmission and later reconstruction.
- How it is used
- Enables applications implemented in different languages to exchange data for storage or transmission.
- How deep it goes
- Defines byte conversion, reconstruction, formats, and JSON syntax, but stops short of detailed format implementations.
- Examples
- Uses Python and Ruby applications, an API exchange, and JSON objects, arrays, primitive values, and key-value pairs.
- What you can do after
- Apply JSON, XML, or YAML to represent data for interoperable storage and communication.
Read how Acing the CCNA Exam: Volume 2 Advanced Networking and Security explains serialization →
Python How-To
Serialization is the process of converting native program objects or values into a JSON representation.
- How it is used
- Supports outgoing data exchange by converting Python values and objects into JSON strings or files.
- How deep it goes
- Explains built-in conversions, encoder failures, fallback handling, formatting, and file methods, but defers broader custom encoding alternatives.
- Examples
- Uses built-in lists, Task objects, formatted dictionaries, sorted user information, and a named-tuple User object.
- What you can do after
- Apply serialization with Python's json module and provide fallback encoding instructions for custom class instances.
Server-Side WebAssembly
Serialization is the transformation of structured data into a representation suitable for storage or transmission.
- How it is used
- Simplifies communication between Wasm modules and host runtimes by standardizing richer data at interface boundaries.
- How deep it goes
- Explains interface types and Canonical ABI lifting and lowering, but does not detail their generated implementation.
- Examples
- Uses a greet function with string input and output, alongside lists, results, records, enums, variants, and flags.
- What you can do after
- Apply it via WIT and the Canonical ABI to describe and exchange structured values across Wasm boundaries.
Clojure: The Essential Reference
Serialization is the conversion of structured data or objects into a linear representation that can be persisted or transmitted and later reconstructed.
- How it is used
- Persists or transmits nested Clojure data and Java objects through textual representations that can later be reconstructed.
- How deep it goes
- Explains representations, output routing, custom printing, reconstruction, and code-injection risk without surveying binary formats.
- Examples
- Uses Clojure maps, sequences, Java maps, files, lazy ranges, and a custom Point type.
- What you can do after
- Build it from scratch by choosing printing functions, redirecting output, and extending custom-type serialization.
Read how Clojure: The Essential Reference explains serialization →
Related concepts
- JSONuses · JSON is a standardized, language-independent text format for representing structured data using objects, arrays, strings, numbers, Boolean values, and null.
- deserializationcontrasts with · Deserialization is the process of reconstructing structured data or in-memory values from a serialized representation.
- linearizabilitycontrasts with · Linearizability is a consistency property in which each operation appears to take effect atomically at a point between invocation and completion while preserving real-time order.
- xmluses · XML is a text-based markup language for encoding structured documents and data using elements, attributes, and nested relationships.
- bytesproduces · Bytes are an ordered sequence of values, each conventionally eight bits, used to represent binary data.
These guides are generated from the text of Manning books by Manning's knowledge graph and link to the sections they draw on. The full books are available on liveBook and at manning.com.