Serialization
Serialization is the conversion of structured data or in-memory values into a representation suitable for storage or transmission and possible 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 data conversion as application work to examine when reducing latency.
- How deep it goes
- Explains conversion and its CPU and copy costs, illustrating the in-memory representation down to byte order.
- Examples
- Traces an online-store order through JSON and illustrates a Rust order struct with a little-endian order ID.
- What you can do after
- Diagnose serialization-related latency by tracing conversion points and profiling application work.
Designing AI Systems
Serialization is the conversion of in-memory data structures into a transferable or storable representation.
- How it is used
- Moves data across SDK, gRPC, database, and workflow boundaries while keeping application code Python-native.
- How deep it goes
- Traces conversion, transport, deserialization, flexible JSON values, and checkpoint persistence, but stops short of serialization internals.
- Examples
- Uses gRPC request objects, model chat messages, flexible memory dictionaries, and workflow checkpoint dictionaries.
- What you can do after
- Apply it via SDK client methods that transport typed requests, persist flexible values, and restore checkpointed workflow state.
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 convert and validate structured data in a JSON/XML command-line tool.
- How deep it goes
- Explains JSON field mapping and custom marshaling methods through configuration examples, without detailing encoding internals.
- Examples
- Uses a server configuration and a JSON/XML validation and conversion CLI as practical examples.
- What you can do after
- Apply it via encoding/json to map configuration data to Go values and customize JSON serialization.
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 →
High Performance Unity Game Development
Serialization is the encoding of in-memory data into a storable or transferable representation.
- How it is used
- Stores game data in a binary save file for later reading.
- How deep it goes
- Defines byte-stream encoding and ordering, then demonstrates reading and writing; it does not develop a complete save system.
- Examples
- Uses a game-data save with an enemy count and enemy positions as binary values.
- What you can do after
- Apply serialization with BinaryWriter and deserialization with BinaryReader to store and retrieve typed game data.
Read how High Performance Unity Game Development 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 →
Microservices Patterns, Second Edition
Serialization is the conversion of in-memory data into a format suitable for transmission or storage.
- How it is used
- Converts API-client data into service payloads and incoming payloads into application-usable domain objects.
- How deep it goes
- Defines outbound and inbound conversions, compares DTO implementation options, and identifies selection factors without detailing their trade-offs.
- Examples
- Uses requests, commands, events, responses, replies, and consumed events as message payloads.
- What you can do after
- Apply it by serializing outbound DTOs and deserializing inbound payloads in an API client.
Read how Microservices Patterns, Second 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 →
Also covered in
- Grokking Software ArchitectureIn early access (MEAP)
- Pro ASP.NET Core 7, Tenth Edition
- Python Concurrency with asyncio
- F# in Action: A Revised Edition of Get Programming with F#
- Real-World Cryptography
- Data Pipelines with Apache Airflow, Second Edition
- Pro Angular 16
- Grokking Web Application Security
- 100 Go Mistakes and How to Avoid Them
- Learn Haskell by Example
- Systems Programming with ZigIn early access (MEAP)
- Build an AI Agent (From Scratch)
What to know first
- JSONJSON is a language-independent text-based data-interchange format that represents structured values using objects, arrays, strings, numbers, booleans, and null.
- xmlXML (Extensible Markup Language) is a text-based markup language for representing structured information using elements, attributes, and nested relationships.
- protobufProtocol Buffers is a language- and platform-neutral system for defining structured data schemas and serializing messages in a compact binary format, with support for generated code.
- MapA map is an associative data structure that stores key-value associations and supports retrieving values by key.
Related concepts
- JSONuses · JSON is a language-independent text-based data-interchange format that represents structured values using objects, arrays, strings, numbers, booleans, 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.
- bytesproduces · Bytes are an ordered sequence of byte values, typically eight-bit units, used to represent binary data.
Questions about serialization
What is serialization?
Serialization is the conversion of structured data or in-memory values into a representation suitable for storage or transmission and possible later reconstruction.
Which Manning books explain serialization?
Data-Oriented Programming: Reduce software complexity, Django in Action, Learn Go with Pocket-Sized Projects, API Design Patterns, Akka in Action, Second Edition, Kafka for Architects, Rust Servers, Services, and Apps, Latency and 19 more.
What should I know before learning serialization?
Manning books that teach serialization usually introduce JSON, xml, protobuf and Map first.
What is the difference between serialization and deserialization?
Serialization is the conversion of structured data or in-memory values into a representation suitable for storage or transmission and possible later reconstruction. Deserialization is the process of reconstructing structured data or in-memory values from a serialized representation.
What kinds of serialization are there?
Kinds of serialization include lazy serialization.
What is serialization also called?
Serialization is also called serialize, serializing, marshalling, marshaling or marshal.
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.


























