Reduce system complexity in Java
with
Data-Oriented programming
Taming objects
April 2021
Yehonathan Sharvit viebel
👋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
🤔 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
