book

Data-Oriented Programming

by Yehonathan Sharvit

August 2022

Beginner to intermediate

424 pages

10h 19m

English

Manning Publications

Read now

Unlock full access

forewordsprefaceacknowledgmentsabout this bookWho should read this book?How this book is organized: A road mapAbout the codeliveBook discussion forumabout the authorabout the cover illustrationdramatis personae
1.1 OOP design: Classic or classical?1.1.1 The design phase1.1.2 UML 1011.1.3 Explaining each piece of the class diagram1.1.4 The implementation phase1.2 Sources of complexity1.2.1 Many relations between classes1.2.2 Unpredictable code behavior1.2.3 Not trivial data serialization1.2.4 Complex class hierarchiesSummary
2.1 The two parts of a DOP system2.2 Data entities2.3 Code modules2.4 DOP systems are easy to understand2.5 DOP systems are flexibleSummary

3.1 Designing a data model3.2 Representing records as maps3.3 Manipulating data with generic functions3.4 Calculating search results3.5 Handling records of different typesSummary
4.1 Multiple versions of the system data4.2 Structural sharing4.3 Implementing structural sharing4.4 Data safety4.5 The commit phase of a mutation4.6 Ensuring system state integrity4.7 Restoring previous statesSummary
5.1 Optimistic concurrency control5.2 Reconciliation between concurrent mutations5.3 Reducing collections5.4 Structural difference5.5 Implementing the reconciliation algorithmSummary
6.1 The simplicity of data-oriented test cases6.2 Unit tests for data manipulation code6.2.1 The tree of function calls6.2.2 Unit tests for functions down the tree6.2.3 Unit tests for nodes in the tree6.3 Unit tests for queries6.4 Unit tests for mutationsMoving forwardSummary
7.1 Data validation in DOP7.2 JSON Schema in a nutshell7.3 Schema flexibility and strictness7.4 Schema composition7.5 Details about data validation failuresSummary
8.1 The complexity of locks8.2 Thread-safe counter with atoms8.3 Thread-safe cache with atoms8.4 State management with atomsSummary
9.1 The need for persistent data structures9.2 The efficiency of persistent data structures9.3 Persistent data structures libraries9.3.1 Persistent data structures in Java9.3.2 Persistent data structures in JavaScript9.4 Persistent data structures in action9.4.1 Writing queries with persistent data structures9.4.2 Writing mutations with persistent data structures9.4.3 Serialization and deserialization9.4.4 Structural diffSummary
10.1 Fetching data from the database10.2 Storing data in the database10.3 Simple data manipulation10.4 Advanced data manipulationSummary
11.1 Another feature request11.2 Building the insides like the outsides11.3 Representing a client request as a map11.4 Representing a server response as a map11.5 Passing information forward11.6 Search result enrichment in actionDelivering on timeSummary
12.1 Function arguments validation12.2 Return value validation12.3 Advanced data validation12.4 Automatic generation of data model diagrams12.5 Automatic generation of schema-based unit tests12.6 A new giftSummary
13.1 The essence of polymorphism13.2 Multimethods with single dispatch13.3 Multimethods with multiple dispatch13.4 Multimethods with dynamic dispatch13.5 Integrating multimethods in a production systemSummary
14.1 Updating a value in a map with eloquence14.2 Manipulating nested data14.3 Using the best tool for the job14.4 Unwinding at easeSummary
15.1 Determinism in programming15.2 Reproducibility with numbers and strings15.3 Reproducibility with any data15.4 Unit tests15.5 Dealing with external data sourcesFarewellSummary
A.1 Principle #1: Separate code from dataA.1.1 Illustration of Principle #1A.1.2 Benefits of Principle #1A.1.3 Cost for Principle #1A.1.4 Summary of Principle #1A.2 Principle #2: Represent data with generic data structuresA.2.1 Illustration of Principle #2A.2.2 Benefits of Principle #2A.2.3 Cost for Principle #2A.2.4 Summary of Principle #2A.3 Principle #3: Data is immutableA.3.1 Illustration of Principle #3A.3.2 Benefits of Principle #3A.3.3 Cost for Principle #3A.3.4 Summary of Principle #3A.4 Principle #4: Separate data schema from data representationA.4.1 Illustration of Principle #4A.4.2 Benefits of Principle #4A.4.3 Cost for Principle #4A.4.4 Summary of Principle #4Conclusion
B.1 Dynamic getters for string mapsB.1.1 Accessing non-nested map fields with dynamic gettersB.1.2 Accessing nested map fields with dynamic gettersB.2 Value getters for mapsB.2.1 Accessing non-nested map fields with value gettersB.2.2 Accessing nested map fields with value gettersB.3 Typed getters for mapsB.3.1 Accessing non-nested map fields with typed gettersB.3.2 Accessing nested map fields with typed gettersB.4 Generic access to class membersB.4.1 Generic access to non-nested class membersB.4.2 Generic access to nested class membersB.4.3 Automatic JSON serialization of objectsSummary
C.1 Time lineC.1.1 1958: LispC.1.2 1981: Values and objectsC.1.3 2000: Ideal hash treesC.1.4 2006: Out of the Tar PitC.1.5 2007: ClojureC.1.6 2009: Immutability for allC.2 DOP principles as best practicesC.2.1 Principle #1: Separate code from dataC.2.2 Principle #2: Represent data with generic data structuresC.2.3 Principle #3: Data is immutableC.2.4 Principle #4: Separate data schema from data representationC.3 DOP and other data-related paradigmsC.3.1 Data-oriented designC.3.2 Data-driven programmingC.3.3 Data-oriented programming (DOP)Summary

Overview

Eliminate the unavoidable complexity of object-oriented designs. The innovative data-oriented programming paradigm makes your systems less complex by making it simpler to access and manipulate data.

In Data-Oriented Programming you will learn how to:

Separate code from data
Represent data with generic data structures
Manipulate data with general-purpose functions
Manage state without mutating data
Control concurrency in highly scalable systems
Write data-oriented unit tests
Specify the shape of your data
Benefit from polymorphism without objects
Debug programs without a debugger

Data-Oriented Programming is a one-of-a-kind guide that introduces the data-oriented paradigm. This groundbreaking approach represents data with generic immutable data structures. It simplifies state management, eases concurrency, and does away with the common problems you’ll find in object-oriented code. The book presents powerful new ideas through conversations, code snippets, and diagrams that help you quickly grok what’s great about DOP. Best of all, the paradigm is language-agnostic—you’ll learn to write DOP code that can be implemented in JavaScript, Ruby, Python, Clojure, and also in traditional OO languages like Java or C#.

About the Technology
Code that combines behavior and data, as is common in object-oriented designs, can introduce almost unmanageable complexity for state management. The Data-oriented programming (DOP) paradigm simplifies state management by holding application data in immutable generic data structures and then performing calculations using non-mutating general-purpose functions. Your applications are free of state-related bugs and your code is easier to understand and maintain.

About the Book
Data-Oriented Programming teaches you to design software using the groundbreaking data-oriented paradigm. You’ll put DOP into action to design data models for business entities and implement a library management system that manages state without data mutation. The numerous diagrams, intuitive mind maps, and a unique conversational approach all help you get your head around these exciting new ideas. Every chapter has a lightbulb moment that will change the way you think about programming.

What's Inside

Separate code from data
Represent data with generic data structures
Manage state without mutating data
Control concurrency in highly scalable systems
Write data-oriented unit tests
Specify the shape of your data

About the Reader
For programmers who have experience with a high-level programming language like JavaScript, Java, Python, C#, Clojure, or Ruby.

About the Author
Yehonathan Sharvit has over twenty years of experience as a software engineer. He blogs, speaks at conferences, and leads Data-oriented programming workshops around the world.

Quotes
Reach the next level of enlightenment…Reduce accidental complexity and raise the level of abstraction.
- From the Foreword by Michael T. Nygard, author of Release It!: Design and Deploy Production-Ready Software

After I saw the examples, I couldn’t unsee it. I didn’t need a new language; I needed to approach programming differently!
- From the Foreword by Ryan Singer, author of Shape Up: Stop Running in Circles and Ship Work that Matters

If you have to deal with data in your code, you should know about DOP!
- Michael Aydinbas, Exxeta

The principles are straightforward and universally applicable.
- Seth MacPherson, QuoteFactory