book

The Well-Grounded Java Developer, Second Edition

Name: The Well-Grounded Java Developer, Second Edition
ISBN: 9781617298875

by Jason Clark, Martijn Verburg, Benjamin Evans

November 2022

Intermediate to advanced

704 pages

19h 58m

English

Manning Publications

Read now

Unlock full access

The Well-Grounded Java Developer
Copyright
Praise for the First Edition
brief contents
contents
front matter
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
Part 1. From 8 to 11 and beyond!
1 Introducing modern Java
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 Java modules
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 Java 17
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

Part 2. Under the hood
4 Class files and bytecode
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 Java concurrency fundamentals
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 JDK concurrency libraries
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 Understanding Java performance
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
Part 3. Non-Java languages on the JVM
8 Alternative JVM languages
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 Kotlin
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 Clojure: A different view of programming
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
Part 4. Build and deployment
11 Building with Gradle and Maven
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 Running Java in containers
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 Testing fundamentals
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 Testing beyond JUnit
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
Part 5. Java frontiers
15 Advanced functional programming
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 Advanced concurrent programming
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 Modern internals
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 Future Java
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
Appendix A. Selecting your Java
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
Appendix B. Recap of streams in Java 8
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

Part 4. Build and deployment

This part of the book is all about working effectively with the tooling to build, test, and deploy our Java applications. Although build tools have existed since long before Java entered the scene, the field continues advancing. In chapter 11, you’ll look at the two most popular Java build tools—Maven and Gradle—and learn about their similarities and differences. Beyond the basic commands, you’ll see how they model the world and where those models are open for the well-grounded developer to extend and customize.

Over the past years, containerization has taken the industry by storm. From its roots as a somewhat niche set of Linux primitives, Docker and Kubernetes have turned these techniques mainstream. You’ll take ...

Become an O’Reilly member and get unlimited access to this title plus top books and audiobooks from O’Reilly and nearly 200 top publishers, thousands of courses curated by job role, 150+ live events each month,
and much more.

Read now

Unlock full access

More than 5,000 organizations count on O’Reilly

O’Reilly covers everything we've got, with content to help us build a world-class technology community, upgrade the capabilities and competencies of our teams, and improve overall team performance as well as their engagement.

Julian F.

Head of Cybersecurity

I wanted to learn C and C++, but it didn't click for me until I picked up an O'Reilly book. When I went on the O’Reilly platform, I was astonished to find all the books there, plus live events and sandboxes so you could play around with the technology.

Addison B.

Field Engineer

I’ve been on the O’Reilly platform for more than eight years. I use a couple of learning platforms, but I'm on O'Reilly more than anybody else. When you're there, you start learning. I'm never disappointed.

Amir M.

Data Platform Tech Lead

I'm always learning. So when I got on to O'Reilly, I was like a kid in a candy store. There are playlists. There are answers. There's on-demand training. It's worth its weight in gold, in terms of what it allows me to do.

Mark W.

Embedded Software Engineer

Publisher Resources

ISBN: 9781617298875Publisher Support Publisher Website Errata Page

Cloud Computing

Data Engineering

Data Science

AI & ML

Programming Languages

Software Architecture

IT/Ops

Security

Design

Business

Soft Skills

The Well-Grounded Java Developer, Second Edition

by Jason Clark, Martijn Verburg, Benjamin Evans

Part 4. Build and deployment

Become an O’Reilly member and get unlimited access to this title plus top books and audiobooks from O’Reilly and nearly 200 top publishers, thousands of courses curated by job role, 150+ live events each month,
and much more.