The Well-Grounded Java Developer

The Well-Grounded Java Developer, Second Edition
Praise for the First Edition
brief contents
contents
foreword
preface
acknowledgements
From Jason
From Martijn
From Ben
about this book
Who should read this book?
How to use this book
About the code
liveBook DIscussion Forum
Other online resources
about the authors
about the cover illustration
Part 1: From 8 to 11 and beyond!
Chapter 1: Introducing modern Java
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
1.4.1 Sprinkling some sugar
1.4.2 Changing the language
1.4.3 JSRs and JEPs
1.4.4 Incubating and preview features
1.5 Small changes in Java 11
1.5.1 Collections factories (JEP 213)
1.5.2 Remove enterprise modules (JEP 320)
1.5.3 HTTP/2 (Java 11)
1.5.4 Single-file source-code programs (JEP 330)
Chapter 2: Java modules
2.1 Setting the scene
2.1.1 Project Jigsaw
2.1.2 The module graph
2.1.3 Protecting the internals
2.1.4 New access control semantics
2.2 Basic modules syntax
2.2.1 Exporting and requiring
2.2.2 Transitivity
2.3 Loading modules
2.3.1 Platform modules
2.3.2 Application modules
2.3.3 Automatic modules
2.3.4 Unnamed module
2.4 Building a first modular app
2.4.1 Command-line switches for modules
2.4.2 Executing a modular app
2.4.3 Modules and reflection
2.5 Architecting for modules
2.5.1 Split packages
2.5.2 Java 8 Compact Profiles
2.5.3 Multi-release JARs
2.6 Beyond modules
Chapter 3: Java 17
3.1 Text Blocks
3.2 Switch Expressions
3.3 Records
3.3.1 Nominal typing
3.3.2 Compact record constructors
3.4 Sealed Types
3.5 New form of instanceof
3.6 Pattern Matching and preview features
Part 2: Under the hood
Chapter 4: Class files and bytecode
4.1 Class loading and class objects
4.1.1 Loading and linking
4.1.2 Class objects
4.2 Class loaders
4.2.1 Custom class loading
4.2.2 Modules and class loading
4.3 Examining class files
4.3.1 Introducing javap
4.3.2 Internal form for method signatures
4.3.3 The constant pool
4.4 Bytecode
4.4.1 Disassembling a class
4.4.2 The runtime environment
4.4.3 Introduction to opcodes
4.4.4 Load and store opcodes
4.4.5 Arithmetic opcodes
4.4.6 Execution flow control opcodes
4.4.7 Invocation opcodes
4.4.8 Platform operation opcodes
4.4.9 Shortcut opcode forms
4.5 Reflection
4.5.1 Introducing reflection
4.5.2 Combining class loading and reflection
4.5.3 Problems with reflection
Chapter 5: Java concurrency fundamentals
5.1 Concurrency theory primer
5.1.1 But I already know about Thread
5.1.2 Hardware
5.1.3 Amdahl’s law
5.1.4 Explaining Java’s threading model
5.1.5 Lessons learned
5.2 Design concepts
5.2.1 Safety and concurrent type safety
5.2.2 Liveness
5.2.3 Performance
5.2.4 Reusability
5.2.5 How and why do the forces conflict?
5.2.6 Sources of overhead
5.3 Block-structured concurrency (pre-Java 5)
5.3.1 Synchronization and locks
5.3.2 The state model for a thread
5.3.3 Fully synchronized objects
5.3.4 Deadlocks
5.3.5 Why synchronized?
5.3.6 The volatile keyword
5.3.7 Thread states and methods
5.3.8 Immutability
5.4 The Java Memory Model (JMM)
5.5 Understanding concurrency through bytecode
5.5.1 Lost Update
5.5.2 Synchronization in bytecode
5.5.3 Synchronized methods
5.5.4 Unsynchronized reads
5.5.5 Deadlock revisited
5.5.6 Deadlock resolved, revisited
5.5.7 Volatile access
Chapter 6: JDK concurrency libraries
6.1 Building blocks for modern concurrent applications
6.2 Atomic classes
6.3 Lock classes
6.3.1 Condition objects
6.4 CountDownLatch
6.5 ConcurrentHashMap
6.5.1 Understanding a simplified HashMap
6.5.2 Limitations of Dictionary
6.5.3 Approaches to a concurrent Dictionary
6.5.4 Using ConcurrentHashMap
6.6 CopyOnWriteArrayList
6.7 Blocking queues
6.7.1 Using BlockingQueue APIs
6.7.2 Using WorkUnit
6.8 Futures
6.8.1 CompletableFuture
6.9 Tasks and execution
6.9.1 Modeling tasks
6.9.2 Executors
6.9.3 Single-threaded executor
6.9.4 Fixed-thread pool
6.9.5 Cached thread pool
6.9.6 ScheduledThreadPoolExecutor
Chapter 7: Understanding Java performance
7.1 Performance terminology: Some basic definitions
7.1.1 Latency
7.1.2 Throughput
7.1.3 Utilization
7.1.4 Efficiency
7.1.5 Capacity
7.1.6 Scalability
7.1.7 Degradation
7.2 A pragmatic approach to performance analysis
7.2.1 Know what you’re measuring
7.2.2 Know how to take measurements
7.2.3 Know what your performance goals are
7.2.4 Know when to stop
7.2.5 Know the cost of achieving higher performance
7.2.6 Know the dangers of premature optimization
7.3 What went wrong? Why do we have to care?
7.3.1 Moore’s law
7.3.2 Understanding the memory latency hierarchy
7.4 Why is Java performance tuning hard?
7.4.1 The role of time in performance tuning
7.4.2 Understanding cache misses
7.5 Garbage collection
7.5.1 Basics
7.5.2 Mark and sweep
7.5.3 Areas of memory
7.5.4 Young collections
7.5.5 Full collections
7.5.6 Safepoints
7.5.7 G1: Java’s default collector
7.5.8 The Parallel collector
7.5.9 GC configuration parameters
7.6 JIT compilation with HotSpot
7.6.1 Why have dynamic compilation?
7.6.2 Introduction to HotSpot
7.6.3 Inlining methods
7.6.4 Dynamic compilation and monomorphic calls
7.6.5 Reading the compilation logs
7.6.6 Deoptimization
7.7 JDK Flight Recorder
7.7.1 Flight Recorder
7.7.2 Mission Control
Part 3: Non-Java languages on the JVM
Chapter 8: Alternative JVM languages
8.1 Language zoology
8.1.1 Interpreted vs. compiled languages
8.1.2 Dynamic vs. static typing
8.1.3 Imperative vs. functional languages
8.1.4 Reimplementation vs. original
8.2 Polyglot programming on the JVM
8.2.1 Why use a non-Java language?
8.2.2 Up-and-coming languages
8.2.3 Languages we could have picked but didn’t
8.3 How to choose a non-Java language for your project
8.3.1 Is the project area low-risk?
8.3.2 Does the language interoperate well with Java?
8.3.3 Is there good tooling and test support for the language?
8.3.4 How hard is the language to learn?
8.3.5 Are there lots of developers using this language?
8.4 How the JVM supports alternative languages
8.4.1 Performance
8.4.2 Runtime environments for non-Java languages
8.4.3 Compiler fictions
Chapter 9: Kotlin
9.1 Why use Kotlin?
9.1.1 Installing
9.2 Convenience and conciseness
9.2.1 Starting with less
9.2.2 Variables
9.2.3 Equality
9.2.4 Functions
9.2.5 Collections
9.2.6 Express yourself
9.3 A different view of classes and objects
9.3.1 Data classes
9.4 Safety
9.4.1 Null safety
9.4.2 Smart casting
9.5 Concurrency
9.6 Java interoperability
Chapter 10: Clojure: A different view of programming
10.1 Introducing Clojure
10.1.1 Hello World in Clojure
10.1.2 Getting started with the REPL
10.1.3 Making a mistake
10.1.4 Learning to love the brackets
10.2 Looking for Clojure: Syntax and semantics
10.2.1 Special forms bootcamp
10.2.2 Lists, vectors, maps, and sets
10.2.3 Arithmetic, equality, and other operations
10.2.4 Working with functions in Clojure
10.2.5 Loops in Clojure
10.2.6 Reader macros and dispatch
10.3 Functional programming and closures
10.4 Introducing Clojure sequences
10.4.1 Sequences and variable-arity functions
10.5 Interoperating between Clojure and Java
10.5.1 Calling Java from Clojure
10.5.2 The nature of Clojure calls
10.5.3 The Java type of Clojure values
10.5.4 Using Clojure proxies
10.5.5 Exploratory programming with the REPL
10.5.6 Using Clojure from Java
10.6 Macros
Part 4: Build and deployment
Chapter 11: Building with Gradle and Maven
11.1 Why build tools matter for a well-grounded developer
11.1.1 Automating tedious operations
11.1.2 Managing dependencies
11.1.3 Ensuring consistency between developers
11.2 Maven
11.2.1 The build lifecycle
11.2.2 Commands/POM intro
11.2.3 Building
11.2.4 Controlling the manifest
11.2.5 Adding another language
11.2.6 Testing
11.2.7 Dependency management
11.2.8 Reviewing
11.2.9 Moving beyond Java 8
11.2.10 Multirelease JARs in Maven
11.2.11 Maven and modules
11.2.12 Authoring Maven plugins
11.3 Gradle
11.3.1 Installing Gradle
11.3.2 Tasks
11.3.3 What’s in a script?
11.3.4 Using plugins
11.3.5 Building
11.3.6 Work avoidance
11.3.7 Dependencies in Gradle
11.3.8 Adding Kotlin
11.3.9 Testing
11.3.10 Automating static analysis
11.3.11 Moving beyond Java 8
11.3.12 Using Gradle with modules
11.3.13 Customizing
Chapter 12: Running Java in containers
12.1 Why containers matter for a well-grounded developer
12.1.1 Host operating systems vs. virtual machines vs. containers
12.1.2 Benefits of containers
12.1.3 Drawbacks of containers
12.2 Docker fundamentals
12.2.1 Building Docker images
12.2.2 Running Docker containers
12.3 Developing Java applications with Docker
12.3.1 Selecting your base image
12.3.2 Building an image with Gradle
12.3.3 Running the build in Docker
12.3.4 Ports and hosts
12.3.5 Local development with Docker Compose
12.3.6 Debugging in Docker
12.3.7 Logging with Docker
12.4 Kubernetes
12.5 Observability and performance
12.5.1 Observability
12.5.2 Performance in containers
Chapter 13: Testing fundamentals
13.1 Why we test
13.2 How we test
13.3 Test-driven development
13.3.1 TDD in a nutshell
13.3.2 A TDD example with a single use case
13.4 Test doubles
13.4.1 Dummy object
13.4.2 Stub object
13.4.3 Fake object
13.4.4 Mock object
13.4.5 Problems with mocking
13.5 From JUnit 4 to 5
Chapter 14: Testing beyond JUnit
14.1 Integration testing with Testcontainers
14.1.1 Installing testcontainers
14.1.2 An example with Redis
14.1.3 Gathering container logs
14.1.4 An example with Postgres
14.1.5 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
14.3.1 clojure.test
14.3.2 clojure.spec
14.3.3 test.check
14.3.4 clojure.spec and test.check
Part 5: Java frontiers
Chapter 15: Advanced functional programming
15.1 Introduction to functional programming concepts
15.1.1 Pure functions
15.1.2 Immutability
15.1.3 Higher-order functions
15.1.4 Recursion
15.1.5 Closures
15.1.6 Laziness
15.1.7 Currying and partial application
15.2 Limitations of Java as a FP language
15.2.1 Pure functions
15.2.2 Mutability
15.2.3 Higher-order functions
15.2.4 Recursion
15.2.5 Closures
15.2.6 Laziness
15.2.7 Currying and partial application
15.2.8 Java’s type system and collections
15.3 Kotlin FP
15.3.1 Pure and higher-order functions
15.3.2 Closures
15.3.3 Currying and partial application
15.3.4 Immutability
15.3.5 Tail recursion
15.3.6 Lazy evaluation
15.3.7 Sequences
15.4 Clojure FP
15.4.1 Comprehensions
15.4.2 Lazy sequences
15.4.3 Currying in Clojure
Chapter 16: Advanced concurrent programming
16.1 The Fork/Join framework
16.1.1 A simple F/J example
16.1.2 Parallelizing problems for F/J
16.1.3 Work-stealing algorithms
16.2 Concurrency and functional programming
16.2.1 CompletableFuture revisited
16.2.2 Parallel streams
16.3 Under the hood with Kotlin coroutines
16.3.1 How coroutines work
16.3.2 Coroutine scoping and dispatching
16.4 Concurrent Clojure
16.4.1 Persistent data structures
16.4.2 Futures and pcalls
16.4.3 Software transactional memory
16.4.4 Agents
Chapter 17: Modern internals
17.1 Introducing JVM internals: Method invocation
17.1.1 Invoking virtual methods
17.1.2 Invoking interface methods
17.1.3 Invoking “special” methods
17.1.4 Final methods
17.2 Reflection internals
17.3 Method handles
17.3.1 MethodHandle
17.3.2 MethodType
17.3.3 Looking up method handles
17.3.4 Reflection vs. proxies vs. method handles
17.4 Invokedynamic
17.4.1 Implementing lambda expressions
17.5 Small internal changes
17.5.1 String concatenation
17.5.2 Compact strings
17.5.3 Nestmates
17.6 Unsafe
17.7 Replacing Unsafe with supported APIs
17.7.1 VarHandles
17.7.2 Hidden classes
Chapter 18: Future Java
18.1 Project Amber
18.2 Project Panama
18.2.1 Foreign Function and Memory API
18.3 Project Loom
18.3.1 Virtual threads
18.3.2 Thread builders
18.3.3 Programming with virtual threads
18.3.4 When will Project Loom arrive?
18.4 Project Valhalla
18.4.1 Changing the language model
18.4.2 Consequences of value objects
18.4.3 Generics revisited
18.5 Java 18
appendix A: Selecting your Java
A.1 Java is still free
A.1.1 Java SE/OpenJDK/Oracle OpenJDK Builds/Oracle JDK
A.2 Staying with Java SE 8
A.2.1 $Free (as in beer) and free (as in use) Java SE 8
A.3 Getting Java SE 11
A.3.1 $Free (as in beer) and free (as in use) Java SE 11
A.4 Getting Java SE 17 (LTS)
A.4.1 $Free (as in beer) and free (as in use) Java SE 17
A.5 Paid support
appendix B: Recap of streams in Java 8
B.1 Backward compatibility
B.2 Default methods
B.3 Streams
B.3.1 Example
B.4 The limits of collections
B.5 Infinite streams
B.6 Handling primitives
B.7 Parallel operations?
index
Symbols
A
B
C
D
E
F
G
H
I
J
K
L
M
N
O
P
Q
R
S
T
U
V
W
X
Y
Z