Data-oriented programming
Data-oriented programming is an approach to structuring software around data representations and the operations, access patterns, and transformations applied to them.
High Performance Unity Game Development
An approach to structuring software around the flow and transformation of data rather than relationships between objects.
- How it is used
- Structures frequently updated gameplay systems around the data they read, transform, and write.
- How deep it goes
- Works through array-based enemy behavior and a five-part Unity game architecture, then discusses pooling and selective optimization.
- Examples
- Uses moving and teleporting enemies, an enemy-data array listing, and a Unity survival-game loop.
- What you can do after
- Build it from scratch: organize gameplay state in arrays, transform it with static functions, and drive a simple Unity game loop.
Read how High Performance Unity Game Development explains data-oriented programming →
Data-Oriented Programming in Java
Data-oriented programming is a programming approach that organizes software around explicit data representations and operations on those representations.
- How it is used
- Frames maintainable Java design by making domain meaning and business rules explicit in data representations.
- How deep it goes
- Works from simple identifier types through explicit state refactorings, transformations, architectural pipelines, and compile-time invariants.
- Examples
- Uses UUID identifiers, scheduled-task retry states, late-fee billing models, and JSON-to-CSV data pipelines.
- What you can do after
- Apply it by modeling domain states as explicit Java types and expressing behavior as named input-output transformations.
Read how Data-Oriented Programming in Java explains data-oriented programming →
Data-Oriented Programming: Reduce software complexity
A programming paradigm that organizes software around data and seeks to reduce system complexity by separating data from code and avoiding unnecessary mutation and encapsulation.
- How it is used
- Reduces system complexity and adapts behavior to changing requirements by separating data entities from stateless code modules.
- How deep it goes
- Works through architecture, data representation, permissions, database access, immutability, testing, and reproducible debugging.
- Examples
- Uses library permissions, map-based book records, relational database collections, and reproducible catalog-search debugging.
- What you can do after
- Apply it by designing stateless modules, generic records, explicit data flow, and reproducible data-driven debugging experiments.
Read how Data-Oriented Programming: Reduce software complexity explains data-oriented programming →
Systems Programming with Zig
Data-oriented design organizes software around data representation, layout, access patterns, and transformations.
- How it is used
- Uses representation-first design to simplify recipe-book state management and interpreter architecture.
- How deep it goes
- Develops concrete representations and operations, including JSON conversion and iteration, and weighs deletion cost against expected scale.
- Examples
- Uses a recipe-book library, ingredient iteration, JSON persistence, and a CHIP-8 interpreter as examples.
- What you can do after
- Apply representation-first design to model state, choose operations for expected scale, and simplify dataset-wide transformations.
Read how Systems Programming with Zig explains data-oriented programming →
The Art of Code
A programming paradigm that models data as simple immutable structures and expresses behavior through standalone functions operating on that data.
- How it is used
- Centers data in design so its structure communicates the problem and behavior follows the model.
- How deep it goes
- Distinguishes the programming paradigm from a pragmatic mindset and develops modeling principles with tradeoffs.
- Examples
- Contrasts an ambiguous user constructor with a physical profile using explicitly named weight and height units.
- What you can do after
- Evaluate data models for ambiguous values and apply explicit naming, nearby invariants, and immutability where they improve clarity.
Read how The Art of Code explains data-oriented programming →
Functional Programming in C#, Second Edition
A programming paradigm that reduces application complexity by separating logic from data and favoring generic data representations.
- How it is used
- Reduces application complexity by separating data entities from logic and favoring generic data representations.
- How deep it goes
- Defines three principles and illustrates their overlap with functional programming, while briefly noting generic-data trade-offs.
- Examples
- Uses account state and static account functions, and contrasts entity-specific types with dictionaries, lists, and primitives.
- What you can do after
- Understand how separating data and logic enables general data operations, while recognizing the loss of type safety.
Read how Functional Programming in C#, Second Edition explains data-oriented programming →
Also covered in
What to know first
- object-oriented programmingObject-oriented programming is a programming paradigm that organizes software around objects combining state and behavior, often using encapsulation, classes, inheritance, or polymorphism.
- encapsulationEncapsulation is a software design principle that contains data and implementation details behind a controlled interface, restricting direct access to internal state.
- functional programmingFunctional programming is a programming paradigm that expresses computation through the evaluation and composition of functions, typically favoring immutable data and minimizing mutable state and side effects.
- garbage collectionGarbage collection is an automated process that identifies and reclaims or removes memory, data, or other items no longer reachable or needed by a system.
Related concepts
- generic data structureuses · A generic data structure is a reusable organization of data whose representation is not tied to a particular domain-specific type or implementation.
- arrayuses · An array is an ordered collection of elements organized in one or more dimensions and accessible by position or index.
- complexity metricaddresses · A complexity metric is a quantitative measure of the structural intricacy or difficulty of understanding, modifying, or executing software code.
- data-operation separationuses · Data-operation separation is a design technique that keeps data representations distinct from the functions or logic that operate on them.
- database indexuses · A database index is an auxiliary data structure that organizes keys or references to records to support efficient lookup and retrieval.
- premature optimizationcontrasts with · Premature optimization is optimizing software before evidence establishes a meaningful performance need or bottleneck that justifies the change.
Questions about data-oriented programming
What is data-oriented programming?
Data-oriented programming is an approach to structuring software around data representations and the operations, access patterns, and transformations applied to them.
Which Manning books explain data-oriented programming?
High Performance Unity Game Development, Data-Oriented Programming in Java, Data-Oriented Programming: Reduce software complexity, Systems Programming with Zig, The Art of Code and Functional Programming in C#, Second Edition.
What should I know before learning data-oriented programming?
Manning books that teach data-oriented programming usually introduce object-oriented programming, encapsulation, functional programming and garbage collection first.
What is the difference between data-oriented programming and premature optimization?
Data-oriented programming is an approach to structuring software around data representations and the operations, access patterns, and transformations applied to them. Premature optimization is optimizing software before evidence establishes a meaningful performance need or bottleneck that justifies the change.
What is data-oriented programming also called?
Data-oriented programming is also called data orientation, data-oriented approach or DOP.
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.





