Data-Oriented programming in Java

👋Who am I?

💻 Developer since 2001 (C++, Java, JavaScript, Ruby, Clojure)
📖 Author of Data-Oriented programming
📝 Blogger at blog.klipse.tech

🤔 What is Data-Oriented Programming?

Set of best practices that reduce complexity of information systems by treating data as a first-class citizen

📓 What is complexity?

⚙️Computational complexity

The amount of machine resources (e.g. CPU, memory) required to run a program.

😰 System Complexity

The amount of brain resources required to understand a system.

📊 Information systems

Systems that manipulate information in various ways.

Examples of information systems:

Web services that fetch data from the database and serves it as JSON
Web workers that listen to events and enrich event data from multiple data sources
Front end applications that store application state

🤔 What makes an information system complex?

🕸️Sources of complexity

Nodes with many edges
Many kind of arrows
- Association
- Composition
- Inheritance
- Usage

💡 Separate Code from Data

☕What makes this system less complex?

Separation of concerns
Code diagram constraints
- Stateless (static)
- Only usage relation
Data diagram constraints
- Only association and composition

👩🏻‍💻 Separate Code from Data in Java

class AuthorData {
    private String firstName;
    private String lastName;
    // setters
    // getters
}

class AuthorCode {
    static String fullName(AuthorData author) {
        return author.firstName() +
            " " + author.lastName();
    }
}

var asimov = new AuthorData("Isaac", "Asimov");
AuthorCode.fullName(asimov); // "Isaac Asimov"

🤔 What makes code hard to understand?

By reference or by value?

In Java, object references are passed by value

var asimov = new AuthorData("Isaac", "Asimov");
var asimov2 = AuthorCode.toUpperLastName(asimov);
asimov2.lastName() // "ASIMOV"
asimov.lastName() // ??

⚠️We could trust the implementation
🔒 We protect ourselves by copying the object
😱 It makes the code hard to understand

🤔 What makes code hard to understand?

Thread-safety

class MemberData {
    private boolean blocked;
    private String firstName;
    private String lastName;
   // getters and setters
}

class MemberCode {
    static borrow(MemberData member, String bookId) {
        if(!member.isBlocked()) {
            System.out.println("The book is yours!");
        }
    }
}

⚠️This code is not thread safe!
🔒 We add lock mechanisms.
😱 It makes the code hard to understand.

💡 Do not mutate data

Treat data as a value. Values never change.

Main benefits of immutable data

Inherently Thread-safe
No side-effects

👩🏻‍💻 Immutable data in Java

We can solve any problem in Java with Java annotations (anonymous)

@value annotation by Project Lombok

@value class AuthorData {
    String firstName;
    String lastName;
}

Auto generation of:

constructor, immutable private fields
getters, setters
toString(), hashCode(), equals()

👩🏻‍💻 Immutable data in Java

Java records (Only since Java 14!)

public record AuthorData (String firstName,
                          String lastName) {}

Native implementation of:

constructor, immutable private fields
getters, setters
toString(), hashCode(), equals()

🏅 Benefits of Immutable data in Java

var asimov = new AuthorData("Isaac", "Asimov");
var asimov2 = AuthorCode.toUpperLastName(asimov);
asimov.lastName() // "asimov"

No mutations!
No unpleasant surprises
No need to do a defensive copy!

class MemberCode {
    static borrow(MemberData member, String bookId) {
        if(!member.isBlocked()) {
            System.out.println("The book is yours!");
        }
    }
}

Thread-safe!
No race conditions!
No need to protect with a lock!

🎉 Java libraries that embrace Data-Oriented programming

gson: Convert Objects into JSON and back
cqengine: Ultra-fast SQL-like queries on collections
Paguro: Immutable Collections and Functional Transformations
bifurcan: Functional, durable data structures

🤔 What else in the book?

Efficient immutable collections
Represent record with immutable maps
Polymorphism without inheritance
Manage the application state
Highly-scalable concurrent systems
Flexible access to the database

⏳Summary

https://tinyurl.com/dop-sou