contents
Part 1. From 8 to 11 and beyond!
1.1 The language and the platform
1.2 The new Java release model
1.3 Enhanced type inference (var keyword)
1.4 Changing the language and the platform
Incubating and preview features
Collections factories (JEP 213)
Remove enterprise modules (JEP 320)
Single-file source-code programs (JEP 330)
2.3 Loading modules
2.4 Building a first modular app
Command-line switches for modules
2.6 Beyond modules
3 Java 17
3.1 Text Blocks
3.3 Records
3.4 Sealed Types
3.6 Pattern Matching and preview features
Part 2. Under the hood
4.1 Class loading and class objects
4.2 Class loaders
Internal form for method signatures
4.4 Bytecode
Execution flow control opcodes
4.5 Reflection
Combining class loading and reflection
5 Java concurrency fundamentals
But I already know about Thread
Explaining Java’s threading model
5.2 Design concepts
Safety and concurrent type safety
How and why do the forces conflict?
5.3 Block-structured concurrency (pre-Java 5)
5.4 The Java Memory Model (JMM)
5.5 Understanding concurrency through bytecode
6.1 Building blocks for modern concurrent applications
6.2 Atomic classes
6.3 Lock classes
6.4 CountDownLatch
Understanding a simplified HashMap
Approaches to a concurrent Dictionary
6.7 Blocking queues
6.8 Futures
7 Understanding Java performance
7.1 Performance terminology: Some basic definitions
7.2 A pragmatic approach to performance analysis
Know what your performance goals are
Know the cost of achieving higher performance
Know the dangers of premature optimization
7.3 What went wrong? Why do we have to care?
Understanding the memory latency hierarchy
7.4 Why is Java performance tuning hard?
The role of time in performance tuning
7.6 JIT compilation with HotSpot
Dynamic compilation and monomorphic calls
Part 3. Non-Java languages on the JVM
8.1 Language zoology
Interpreted vs. compiled languages
Imperative vs. functional languages
8.2 Polyglot programming on the JVM
Languages we could have picked but didn’t
8.3 How to choose a non-Java language for your project
Does the language interoperate well with Java?
Is there good tooling and test support for the language?
How hard is the language to learn?
Are there lots of developers using this language?
8.4 How the JVM supports alternative languages
Runtime environments for non-Java languages
9 Kotlin
9.1 Why use Kotlin?
9.2 Convenience and conciseness
9.3 A different view of classes and objects
9.4 Safety
9.5 Concurrency
10 Clojure: A different view of programming
10.1 Introducing Clojure
10.2 Looking for Clojure: Syntax and semantics
Lists, vectors, maps, and sets
Arithmetic, equality, and other operations
Working with functions in Clojure
10.3 Functional programming and closures
10.4 Introducing Clojure sequences
Sequences and variable-arity functions
10.5 Interoperating between Clojure and Java
The Java type of Clojure values
Exploratory programming with the REPL
10.6 Macros
Part 4. Build and deployment
11 Building with Gradle and Maven
11.1 Why build tools matter for a well-grounded developer
Ensuring consistency between developers
11.2 Maven
11.3 Gradle
12.1 Why containers matter for a well-grounded developer
Host operating systems vs. virtual machines vs. containers
12.2 Docker fundamentals
12.3 Developing Java applications with Docker
Local development with Docker Compose
12.4 Kubernetes
12.5 Observability and performance
13.1 Why we test
13.2 How we test
A TDD example with a single use case
13.4 Test doubles
13.5 From JUnit 4 to 5
14.1 Integration testing with Testcontainers
An example for end-to-end testing with Selenium
14.2 Specification-style testing with Spek and Kotlin
14.3 Property-based testing with Clojure
Part 5. Java frontiers
15 Advanced functional programming
15.1 Introduction to functional programming concepts
Currying and partial application
15.2 Limitations of Java as a FP language
Currying and partial application
Java’s type system and collections
15.3 Kotlin FP
Pure and higher-order functions
Currying and partial application
15.4 Clojure FP
16 Advanced concurrent programming
Parallelizing problems for F/J
16.2 Concurrency and functional programming
16.3 Under the hood with Kotlin coroutines
Coroutine scoping and dispatching
16.4 Concurrent Clojure
17.1 Introducing JVM internals: Method invocation
17.2 Reflection internals
17.3 Method handles
Reflection vs. proxies vs. method handles
17.4 Invokedynamic
Implementing lambda expressions
17.6 Unsafe
17.7 Replacing Unsafe with supported APIs
18 Future Java
18.1 Project Amber
18.2 Project Panama
Foreign Function and Memory API
18.3 Project Loom
Programming with virtual threads
When will Project Loom arrive?
18.4 Project Valhalla
18.5 Java 18
Appendix A. Selecting your Java
Appendix B. Recap of streams in Java 8