Java’s new paradigm | Ties van de Ven

Summary

This talk delves into the concept of data-oriented programming, emphasizing its distinction from object-oriented and functional programming paradigms. The speaker explores the 'why' behind data-oriented programming, its impact on software architecture, and how it can enhance scalability. The discussion also highlights Java's new language features like records, sealed classes, and pattern matching, which support this programming style. The speaker advocates for a pragmatic approach, using the best tools for each situation rather than adhering strictly to one paradigm.

Takeaways

• 😀 The speaker is passionate about software engineering fundamentals and was intrigued by the concept of data-oriented programming in Java after reading an article by Brian Goetz.
• 🔍 The speaker embarked on a journey to understand data-oriented programming, finding it to be a different, rather than a superior, approach to software development compared to object-oriented and functional programming.
• 📚 Brian Goetz's talk on functional and object-oriented programming emphasizes the idea of not being dogmatic and being a better programmer by using the right tools for the situation.
• 🤔 The main question the speaker sought to answer in their talk is the definition and essence of data-oriented programming, as they couldn't find a clear answer online.
• 🛠️ Data-oriented programming focuses on the data itself rather than the types or classes that hold the data, which can lead to more scalable and performance-optimized applications.
• 🔄 The speaker discusses the concept of data streams and how most applications can be viewed as a series of data transformations involving map, filter, and branch operations.
• 🧱 The use of types in Java and their downsides, such as not naturally mapping to other types, is contrasted with the efficiency of using data structures like hashmaps that are designed for operations like map and filter.
• 📈 Data-oriented programming can offer performance benefits, especially in gaming and other real-time applications where frame rate is critical.
• 🏗️ The talk also covers how data-oriented programming affects software architecture, advocating for separating use cases from data to create a cleaner object graph and easier scalability.
• 🆕 The introduction of new Java language features like records, sealed classes, and pattern matching are discussed as tools that enable data-oriented programming, but not as the central focus.
• ⚠️ The speaker advises against being dogmatic about any programming paradigm, suggesting that the best approach often involves a combination of object-oriented, functional, and data-oriented programming.

Q & A

What is the main focus of the talk on data-oriented programming in Java?

The talk focuses on explaining what data-oriented programming is, its mindset, and how it differs from object-oriented and functional programming. It also discusses the implications of data-oriented programming on software architecture and the benefits of new language features like records, sealed classes, and pattern matching in Java.

Why was the author initially excited about data-oriented programming coming to Java?

The author was excited because they had no prior understanding of what data-oriented programming entailed and were interested in exploring this new concept after reading an article by Brian Goetz.

What is the fundamental difference between object-oriented programming and data-oriented programming?

Object-oriented programming focuses on using encapsulation to create boundaries within an application and relies on the 'tell-don't-ask' principle, whereas data-oriented programming is centered around the data itself and how it is transformed, often using data structures that are optimized for operations like map, filter, and branch.

What are the three basic operations that can be performed on data streams according to the data-oriented mindset?

The three basic operations are filter (removing data), map (transforming data), and branch (splitting data into different paths).

How does data-oriented programming affect software architecture?

Data-oriented programming can lead to a cleaner object graph by separating use cases from data, allowing for the creation of components for each use case and passing data as arguments to these components. This can result in better scalability and maintainability.

What is the 'tell-don't-ask' principle in object-oriented programming?

The 'tell-don't-ask' principle means that instead of asking an object for its data and then acting on it, you should tell the object what to do, providing it with the necessary information to perform the action itself.

How does the use of records and sealed classes in Java support data-oriented programming?

Records and sealed classes provide a way to encapsulate data and define restricted sets of classes that can extend an interface, respectively. This allows for more compile-time safety and cleaner pattern matching, which are beneficial for data-oriented programming.

What is the advantage of using pattern matching with sealed interfaces in Java?

Pattern matching with sealed interfaces allows for compile-time safe branching operations, enabling developers to handle different cases based on the type of data without the need for a default case, thus reducing the risk of runtime errors.

What is the relationship between data-oriented programming and the gaming industry?

Data-oriented programming is popular in the gaming industry due to its focus on performance optimization. By using data structures that are optimized for certain operations, games can achieve higher frame rates and better performance.

What does the author suggest about being a 'better programmer'?

The author suggests that instead of strictly adhering to one programming paradigm, programmers should be pragmatic and use a combination of tools and approaches that best fit the situation, including both object-oriented and data-oriented programming where appropriate.

How does the new pattern matching feature in Java 21 impact the use of polymorphism?

The new pattern matching feature in Java 21 allows for a more expressive and safe use of polymorphism by enabling developers to branch logic based on the type of an object without needing a default case, thus enhancing compile-time safety and code readability.

What is the speaker's opinion on using mutable state in programming?

The speaker prefers immutability because it reduces cognitive load and makes the code more predictable. However, they acknowledge that mutable state can be used for performance reasons, but it should be contained within function scope to minimize its impact on the rest of the program.

What is the speaker's view on the adoption of data-oriented programming features in Java?

The speaker believes that it will take time for the community to adapt to these new ways of thinking, as Java has a legacy of a different mindset. They also mention that while Java is slowly adding features that are present in languages like Scala, it may not be as powerful or as easy to use for functional programming as Scala is.

What does the speaker suggest about the use of builders in Java?

The speaker is not a fan of builders because they can lead to a loss of compile-time safety. They prefer immutable objects by default and suggest that Java's newer versions may provide better ways to handle immutability.

How does the speaker compare the use of sealed interfaces in Java to similar features in other languages like Scala?

The speaker notes that Java's approach to sealed interfaces is a step towards features that have been available in Scala for a long time. They also mention that Java allows for more flexibility in terms of file organization for sealed interfaces and records.

What is the speaker's advice for developers who are considering whether to stick with Scala or explore Java further?

The speaker suggests that developers can do functional programming in any language, including Java, but acknowledges that Scala provides more powerful features for this paradigm. They encourage sharing knowledge and learning from those who have experience with these features, regardless of the language.