The Well-Grounded Java Developer, Second Edition - MEAP Version 6

MEAP v06, 11 of 17 chapters availableUnderstanding Java from the JVM up gives you a solid foundation to grow your expertise and take on advanced techniques for performance, concurrency, containerization, and more.In The Well-Grounded Java Developer, Second Edition you will learn:• The new Java module system and why you should use it• Bytecode for the JVM, including operations and classloading• Performance tuning the JVM• Working with Java’s built-in concurrency and expanded options• Programming in Kotlin and Clojure on the JVM• Maximizing the benefits from your build/CI tooling with Maven and Gradle• Running the JVM in containers• Planning for future JVM releasesThe 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 distil their decades of experience as Java Champions, veteran developers, and key contributors to the Java ecosystem into this clear and practical guide.About the bookThe Well-Grounded Java Developer, Second Edition is a complete revision of the classic original with the latest innovations of the Java platform. It upgrades your existing Java skills with both JVM fundamentals like bytecode, and powerful new features such as modules and concurrency models. The Well-Grounded Java Developer, Second Edition MEAP V06 Copyright welcome brief contents 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) 1.6 Summary 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 2.7 Summary Chapter 4: Class files and bytecode 4.1 Classloading and class objects 4.1.1 Loading and linking 4.1.2 Class objects 4.2 Classloaders 4.2.1 Custom classloading 4.2.2 Modules and classloading 4.3 Reflection 4.3.1 Introducing reflection 4.3.2 Combining classloading and reflection 4.3.3 Problems with reflection 4.4 Examining class files 4.4.1 Introducing javap 4.4.2 Internal form for method signatures 4.4.3 The constant pool 4.5 Bytecode 4.5.1 Disassembling a class 4.5.2 The runtime environment 4.5.3 Introduction to opcodes 4.5.4 Load and store opcodes 4.5.5 Arithmetic opcodes 4.5.6 Execution flow control opcodes 4.5.7 Invocation opcodes 4.5.8 Platform operation opcodes 4.5.9 Shortcut opcode forms 4.6 Summary 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 5.6 Summary 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 6.10 Summary 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 8.5 Summary Chapter 9: Kotlin 9.1 Why 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 9.7 Summary 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 10.7 Summary Chapter 11: Building with Gradle & 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 Multi-release 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 Dependencies in Gradle 11.3.7 Adding Kotlin 11.3.8 Testing 11.3.9 Review and analysis 11.3.10 Moving beyond Java 8 11.3.11 Using Gradle with modules 11.3.12 Customizing 11.4 Summary Chapter 14: Advanced functional programming 14.1 Introduction to functional programming concepts 14.1.1 Pure functions 14.1.2 Immutability 14.1.3 Higher-order functions 14.1.4 Recursion 14.1.5 Closures 14.1.6 Laziness 14.1.7 Currying and partial application 14.2 Limitations of Java as a FP language 14.2.1 Pure functions 14.2.2 Mutability 14.2.3 Higher-order functions 14.2.4 Recursion 14.2.5 Closures 14.2.6 Laziness 14.2.7 Currying and partial application 14.2.8 Java’s type system and collections 14.3 Kotlin FP 14.3.1 Pure and higher-order functions 14.3.2 Closures 14.3.3 Currying and partial application 14.3.4 Immutability 14.3.5 Tail recursion 14.3.6 Lazy evaluation 14.3.7 Sequences 14.4 Clojure FP 14.4.1 Comprehensions 14.4.2 Lazy sequences 14.4.3 Currying in Clojure 14.5 Summary Notes Understanding Java from the JVM up gives you a solid foundation to grow your expertise and take on advanced techniques for performance, concurrency, containerization, and more.In The Well-Grounded Java Developer, Second Edition you will learn: The new Java module system and why you should use it Bytecode for the JVM, including operations and classloading Performance tuning the JVM Working with Java's built-in concurrency and expanded options Programming in Kotlin and Clojure on the JVM Maximizing the benefits from your build/CI tooling with Maven and Gradle Running the JVM in containers Planning for future JVM releases 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. Foreword by Heinz Kabutz. About the technology 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. About the book 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. What's inside The new Java module system Performance tuning the JVM Maximizing CI/CD with Maven and Gradle Running the JVM in containers Planning for future JVM releases About the reader For intermediate Java developers. About the author Benjamin J. Evans is a senior principal engineer at Red Hat. Martijn Verburg is the principal SWE manager for Microsoft's Java Engineering Group. Both Benjamin and Martijn are Java Champions. Jason Clark is a principal engineer and architect at New Relic. Table of Contents PART 1 - FROM 8 TO 11 AND BEYOND! 1 Introducing modern Java 2 Java modules 3 Java 17 PART 2 - UNDER THE HOOD 4 Class files and bytecode 5 Java concurrency fundamentals 6 JDK concurrency libraries 7 Understanding Java performance PART 3 - NON-JAVA LANGUAGES ON THE JVM 8 Alternative JVM languages 9 Kotlin 10 Clojure: A different view of programming PART 4 - BUILD AND DEPLOYMENT 11 Building with Gradle and Maven 12 Running Java in containers 13 Testing fundamentals 14 Testing beyond JUnit PART 5 - JAVA FRONTIERS 15 Advanced functional programming 16 Advanced concurrent programming 17 Modern internals 18 Future Java