The well-grounded Java developer / Benjamin J. Evans, Jason Clark, and Martijn Verburg.

Format:

Book

Author/Creator:

Evans, Benjamin J., author.

Verburg, Martijn, author.

Clark, Jason D., author.

Series:

ITpro collection

Language:

English

Subjects (All):

Java (Computer program language).

Application software--Development.

Application software.

Java virtual machine.

Physical Description:

1 online resource (682 pages)

Edition:

Second edition.

Place of Publication:

Shelter Island, New York : Manning Publications Co., [2022]

Summary:

The Well-Grounded Java Developer, Second Edition introduces both the modern innovations and timeless fundamentals you need to know to become a Java master. Authors Ben Evans, Martijn Verburg, and Jason Clark distill their decades of experience as Java Champions, veteran developers, and key contributors to the Java ecosystem into this clear and practical guide. You'll discover how Java works under the hood and learn design secrets from Java's long history. Each concept is illustrated with hands-on examples, including a fully modularized application/library and creating your own multithreaded application. Java is the beating heart of enterprise software engineering. Developers who really know Java can expect easy job hunting and interesting work. Written by experts with years of boots-on-the-ground experience, this book upgrades your Java skills. It dives into powerful features like modules and concurrency models and even reveals some of Java's deep secrets. With The Well-Grounded Java Developer, Second Edition you will go beyond feature descriptions and learn how Java operates at the bytecode level. Master high-value techniques for concurrency and performance optimization, along with must-know practices for build, test, and deployment. You'll even look at alternate JVM languages like Kotlin and Clojure. Digest this book and stand out from the pack.

Contents:

Intro

The Well-Grounded Java Developer

Copyright

Praise for the First Edition

brief contents

contents

front matter

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!

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)

Summary

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

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.

Summary

Part 2. Under the hood

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

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

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

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

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

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

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

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

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.

Notes:

Includes index.

Description based on print version record.

Includes bibliographical references and index.

ISBN:

9781638355281

1638355282

9781617298875

1617298875

OCLC:

1351747300

Publisher Number:

9781617298875AU