book

The Well-Grounded Java Developer, Second Edition

by Benjamin Evans, Martijn Verburg, Jason Clark

November 2022

Intermediate to advanced

704 pages

19h 58m

English

Manning Publications

Read now

Unlock full access

forewordprefaceacknowledgementsFrom JasonFrom MartijnFrom Benabout this bookWho should read this book?How to use this bookAbout the codeliveBook Discussion ForumOther online resourcesabout the authorsabout the cover illustration
1.1 The language and the platform1.2 The new Java release model1.3 Enhanced type inference (var keyword)1.4 Changing the language and the platform1.4.1 Sprinkling some sugar1.4.2 Changing the language1.4.3 JSRs and JEPs1.4.4 Incubating and preview features1.5 Small changes in Java 111.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)Summary
2.1 Setting the scene2.1.1 Project Jigsaw2.1.2 The module graph2.1.3 Protecting the internals2.1.4 New access control semantics2.2 Basic modules syntax2.2.1 Exporting and requiring2.2.2 Transitivity2.3 Loading modules2.3.1 Platform modules2.3.2 Application modules2.3.3 Automatic modules2.3.4 Unnamed module2.4 Building a first modular app2.4.1 Command-line switches for modules2.4.2 Executing a modular app2.4.3 Modules and reflection2.5 Architecting for modules2.5.1 Split packages2.5.2 Java 8 Compact Profiles2.5.3 Multi-release JARs2.6 Beyond modulesSummary
3.1 Text Blocks3.2 Switch Expressions3.3 Records3.3.1 Nominal typing3.3.2 Compact record constructors3.4 Sealed Types3.5 New form of instanceof3.6 Pattern Matching and preview featuresSummary

4.1 Class loading and class objects4.1.1 Loading and linking4.1.2 Class objects4.2 Class loaders4.2.1 Custom class loading4.2.2 Modules and class loading4.3 Examining class files4.3.1 Introducing javap4.3.2 Internal form for method signatures4.3.3 The constant pool4.4 Bytecode4.4.1 Disassembling a class4.4.2 The runtime environment4.4.3 Introduction to opcodes4.4.4 Load and store opcodes4.4.5 Arithmetic opcodes4.4.6 Execution flow control opcodes4.4.7 Invocation opcodes4.4.8 Platform operation opcodes4.4.9 Shortcut opcode forms4.5 Reflection4.5.1 Introducing reflection4.5.2 Combining class loading and reflection4.5.3 Problems with reflectionSummary
5.1 Concurrency theory primer5.1.1 But I already know about Thread5.1.2 Hardware5.1.3 Amdahl’s law5.1.4 Explaining Java’s threading model5.1.5 Lessons learned5.2 Design concepts5.2.1 Safety and concurrent type safety5.2.2 Liveness5.2.3 Performance5.2.4 Reusability5.2.5 How and why do the forces conflict?5.2.6 Sources of overhead5.3 Block-structured concurrency (pre-Java 5)5.3.1 Synchronization and locks5.3.2 The state model for a thread5.3.3 Fully synchronized objects5.3.4 Deadlocks5.3.5 Why synchronized?5.3.6 The volatile keyword5.3.7 Thread states and methods5.3.8 Immutability5.4 The Java Memory Model (JMM)5.5 Understanding concurrency through bytecode5.5.1 Lost Update5.5.2 Synchronization in bytecode5.5.3 Synchronized methods5.5.4 Unsynchronized reads5.5.5 Deadlock revisited5.5.6 Deadlock resolved, revisited5.5.7 Volatile accessSummary
6.1 Building blocks for modern concurrent applications6.2 Atomic classes6.3 Lock classes6.3.1 Condition objects6.4 CountDownLatch6.5 ConcurrentHashMap6.5.1 Understanding a simplified HashMap6.5.2 Limitations of Dictionary6.5.3 Approaches to a concurrent Dictionary6.5.4 Using ConcurrentHashMap6.6 CopyOnWriteArrayList6.7 Blocking queues6.7.1 Using BlockingQueue APIs6.7.2 Using WorkUnit6.8 Futures6.8.1 CompletableFuture6.9 Tasks and execution6.9.1 Modeling tasks6.9.2 Executors6.9.3 Single-threaded executor6.9.4 Fixed-thread pool6.9.5 Cached thread pool6.9.6 ScheduledThreadPoolExecutorSummary
7.1 Performance terminology: Some basic definitions7.1.1 Latency7.1.2 Throughput7.1.3 Utilization7.1.4 Efficiency7.1.5 Capacity7.1.6 Scalability7.1.7 Degradation7.2 A pragmatic approach to performance analysis7.2.1 Know what you’re measuring7.2.2 Know how to take measurements7.2.3 Know what your performance goals are7.2.4 Know when to stop7.2.5 Know the cost of achieving higher performance7.2.6 Know the dangers of premature optimization7.3 What went wrong? Why do we have to care?7.3.1 Moore’s law7.3.2 Understanding the memory latency hierarchy7.4 Why is Java performance tuning hard?7.4.1 The role of time in performance tuning7.4.2 Understanding cache misses7.5 Garbage collection7.5.1 Basics7.5.2 Mark and sweep7.5.3 Areas of memory7.5.4 Young collections7.5.5 Full collections7.5.6 Safepoints7.5.7 G1: Java’s default collector7.5.8 The Parallel collector7.5.9 GC configuration parameters7.6 JIT compilation with HotSpot7.6.1 Why have dynamic compilation?7.6.2 Introduction to HotSpot7.6.3 Inlining methods7.6.4 Dynamic compilation and monomorphic calls7.6.5 Reading the compilation logs7.6.6 Deoptimization7.7 JDK Flight Recorder7.7.1 Flight Recorder7.7.2 Mission ControlSummary
8.1 Language zoology8.1.1 Interpreted vs. compiled languages8.1.2 Dynamic vs. static typing8.1.3 Imperative vs. functional languages8.1.4 Reimplementation vs. original8.2 Polyglot programming on the JVM8.2.1 Why use a non-Java language?8.2.2 Up-and-coming languages8.2.3 Languages we could have picked but didn’t8.3 How to choose a non-Java language for your project8.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 languages8.4.1 Performance8.4.2 Runtime environments for non-Java languages8.4.3 Compiler fictionsSummary
9.1 Why use Kotlin?9.1.1 Installing9.2 Convenience and conciseness9.2.1 Starting with less9.2.2 Variables9.2.3 Equality9.2.4 Functions9.2.5 Collections9.2.6 Express yourself9.3 A different view of classes and objects9.3.1 Data classes9.4 Safety9.4.1 Null safety9.4.2 Smart casting9.5 Concurrency9.6 Java interoperabilitySummary
10.1 Introducing Clojure10.1.1 Hello World in Clojure10.1.2 Getting started with the REPL10.1.3 Making a mistake10.1.4 Learning to love the brackets10.2 Looking for Clojure: Syntax and semantics10.2.1 Special forms bootcamp10.2.2 Lists, vectors, maps, and sets10.2.3 Arithmetic, equality, and other operations10.2.4 Working with functions in Clojure10.2.5 Loops in Clojure10.2.6 Reader macros and dispatch10.3 Functional programming and closures10.4 Introducing Clojure sequences10.4.1 Sequences and variable-arity functions10.5 Interoperating between Clojure and Java10.5.1 Calling Java from Clojure10.5.2 The nature of Clojure calls10.5.3 The Java type of Clojure values10.5.4 Using Clojure proxies10.5.5 Exploratory programming with the REPL10.5.6 Using Clojure from Java10.6 MacrosSummary
11.1 Why build tools matter for a well-grounded developer11.1.1 Automating tedious operations11.1.2 Managing dependencies11.1.3 Ensuring consistency between developers11.2 Maven11.2.1 The build lifecycle11.2.2 Commands/POM intro11.2.3 Building11.2.4 Controlling the manifest11.2.5 Adding another language11.2.6 Testing11.2.7 Dependency management11.2.8 Reviewing11.2.9 Moving beyond Java 811.2.10 Multirelease JARs in Maven11.2.11 Maven and modules11.2.12 Authoring Maven plugins11.3 Gradle11.3.1 Installing Gradle11.3.2 Tasks11.3.3 What’s in a script?11.3.4 Using plugins11.3.5 Building11.3.6 Work avoidance11.3.7 Dependencies in Gradle11.3.8 Adding Kotlin11.3.9 Testing11.3.10 Automating static analysis11.3.11 Moving beyond Java 811.3.12 Using Gradle with modules11.3.13 CustomizingSummary
12.1 Why containers matter for a well-grounded developer12.1.1 Host operating systems vs. virtual machines vs. containers12.1.2 Benefits of containers12.1.3 Drawbacks of containers12.2 Docker fundamentals12.2.1 Building Docker images12.2.2 Running Docker containers12.3 Developing Java applications with Docker12.3.1 Selecting your base image12.3.2 Building an image with Gradle12.3.3 Running the build in Docker12.3.4 Ports and hosts12.3.5 Local development with Docker Compose12.3.6 Debugging in Docker12.3.7 Logging with Docker12.4 Kubernetes12.5 Observability and performance12.5.1 Observability12.5.2 Performance in containersSummary
13.1 Why we test13.2 How we test13.3 Test-driven development13.3.1 TDD in a nutshell13.3.2 A TDD example with a single use case13.4 Test doubles13.4.1 Dummy object13.4.2 Stub object13.4.3 Fake object13.4.4 Mock object13.4.5 Problems with mocking13.5 From JUnit 4 to 5Summary
14.1 Integration testing with Testcontainers14.1.1 Installing testcontainers14.1.2 An example with Redis14.1.3 Gathering container logs14.1.4 An example with Postgres14.1.5 An example for end-to-end testing with Selenium14.2 Specification-style testing with Spek and Kotlin14.3 Property-based testing with Clojure14.3.1 clojure.test14.3.2 clojure.spec14.3.3 test.check14.3.4 clojure.spec and test.checkSummary
15.1 Introduction to functional programming concepts15.1.1 Pure functions15.1.2 Immutability15.1.3 Higher-order functions15.1.4 Recursion15.1.5 Closures15.1.6 Laziness15.1.7 Currying and partial application15.2 Limitations of Java as a FP language15.2.1 Pure functions15.2.2 Mutability15.2.3 Higher-order functions15.2.4 Recursion15.2.5 Closures15.2.6 Laziness15.2.7 Currying and partial application15.2.8 Java’s type system and collections15.3 Kotlin FP15.3.1 Pure and higher-order functions15.3.2 Closures15.3.3 Currying and partial application15.3.4 Immutability15.3.5 Tail recursion15.3.6 Lazy evaluation15.3.7 Sequences15.4 Clojure FP15.4.1 Comprehensions15.4.2 Lazy sequences15.4.3 Currying in ClojureSummary
16.1 The Fork/Join framework16.1.1 A simple F/J example16.1.2 Parallelizing problems for F/J16.1.3 Work-stealing algorithms16.2 Concurrency and functional programming16.2.1 CompletableFuture revisited16.2.2 Parallel streams16.3 Under the hood with Kotlin coroutines16.3.1 How coroutines work16.3.2 Coroutine scoping and dispatching16.4 Concurrent Clojure16.4.1 Persistent data structures16.4.2 Futures and pcalls16.4.3 Software transactional memory16.4.4 AgentsSummary
17.1 Introducing JVM internals: Method invocation17.1.1 Invoking virtual methods17.1.2 Invoking interface methods17.1.3 Invoking “special” methods17.1.4 Final methods17.2 Reflection internals17.3 Method handles17.3.1 MethodHandle17.3.2 MethodType17.3.3 Looking up method handles17.3.4 Reflection vs. proxies vs. method handles17.4 Invokedynamic17.4.1 Implementing lambda expressions17.5 Small internal changes17.5.1 String concatenation17.5.2 Compact strings17.5.3 Nestmates17.6 Unsafe17.7 Replacing Unsafe with supported APIs17.7.1 VarHandles17.7.2 Hidden classesSummary
18.1 Project Amber18.2 Project Panama18.2.1 Foreign Function and Memory API18.3 Project Loom18.3.1 Virtual threads18.3.2 Thread builders18.3.3 Programming with virtual threads18.3.4 When will Project Loom arrive?18.4 Project Valhalla18.4.1 Changing the language model18.4.2 Consequences of value objects18.4.3 Generics revisited18.5 Java 18Summary
A.1 Java is still freeA.1.1 Java SE/OpenJDK/Oracle OpenJDK Builds/Oracle JDKA.2 Staying with Java SE 8A.2.1 $Free (as in beer) and free (as in use) Java SE 8A.3 Getting Java SE 11A.3.1 $Free (as in beer) and free (as in use) Java SE 11A.4 Getting Java SE 17 (LTS)A.4.1 $Free (as in beer) and free (as in use) Java SE 17A.5 Paid support
B.1 Backward compatibilityB.2 Default methodsB.3 StreamsB.3.1 ExampleB.4 The limits of collectionsB.5 Infinite streamsB.6 Handling primitivesB.7 Parallel operations?

Content preview from The Well-Grounded Java Developer, Second Edition

Appendix B. Recap of streams in Java 8

This appendix is a refresher on Java 8 streams and the aspects of basic functional programming that are associated with them. If you are not familiar with the basic syntax of Java 8 lambda expressions, or the philosophy that underlies their design, you should read a basic text first to familiarize yourself with those concepts, such as Modern Java in Action: Lambdas, Streams, Functional and Reactive Programming, 2nd ed., by Raoul-Gabriel Urma, Mario Fusco, and Alan Mycroft (Manning, 2018). Java 8 introduced lambda expressions as part of Project Lambda, the overall goals of which can be summarized as follows: