The Well-Grounded Java Developer, Second Edition, Video Edition

The Well-Grounded Java Developer, Second Edition, Video Edition

English | MP4 | AVC 1280×720 | AAC 44KHz 2ch | 137 Lessons (19h 20m) | 2.45 GB

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.

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.

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
Table of Contents

1 foreword
2 Part 1. From 8 to 11 and beyond!
3 Introducing modern Java
4 The new Java release model
5 Enhanced type inference (var keyword)
6 Changing the language and the platform
7 Small changes in Java 11
8 HTTP2 (Java 11)
9 Java modules
10 The module graph
11 Basic modules syntax
12 Loading modules
13 Building a first modular app
14 Architecting for modules
15 Multi-release JARs
16 Java 17
17 Records
18 Nominal typing
19 Sealed Types
20 New form of instanceof
21 Part 2. Under the hood
22 Class files and bytecode
23 Class objects
24 Custom class loading
25 Examining class files
26 Disassembling a class
27 Introduction to opcodes
28 Invocation opcodes
29 Reflection
30 Java concurrency fundamentals
31 Amdahl’s law
32 Design concepts
33 Block-structured concurrency (pre-Java 5)
34 Deadlocks
35 Thread states and methods
36 Immutability
37 Understanding concurrency through bytecode
38 Unsynchronized reads
39 JDK concurrency libraries
40 CountDownLatch
41 Approaches to a concurrent Dictionary
42 CopyOnWriteArrayList
43 Using BlockingQueue APIs
44 CompletableFuture
45 Single-threaded executor
46 Understanding Java performance
47 A pragmatic approach to performance analysis
48 Know what your performance goals are
49 What went wrong Why do we have to care
50 Why is Java performance tuning hard
51 Garbage collection
52 Young collections
53 The Parallel collector
54 JIT compilation with HotSpot
55 Inlining methods
56 JDK Flight Recorder
57 Part 3. Non-Java languages on the JVM
58 Alternative JVM languages
59 Imperative vs. functional languages
60 Polyglot programming on the JVM
61 Up-and-coming languages
62 How to choose a non-Java language for your project
63 How the JVM supports alternative languages
64 Kotlin
65 Functions
66 Collections
67 A different view of classes and objects
68 Safety
69 Concurrency
70 Clojure A different view of programming
71 Getting started with the REPL
72 Looking for Clojure Syntax and semantics
73 Arithmetic, equality, and other operations
74 Loops in Clojure
75 Functional programming and closures
76 Interoperating between Clojure and Java
77 Macros
78 Part 4. Build and deployment
79 Building with Gradle and Maven
80 Ensuring consistency between developers
81 Controlling the manifest
82 Dependency management
83 Maven and modules
84 Gradle
85 Dependencies in Gradle
86 Testing
87 Using Gradle with modules
88 Running Java in containers
89 Host operating systems vs. virtual machines vs. containers
90 Docker fundamentals
91 Developing Java applications with Docker
92 Ports and hosts
93 Debugging in Docker
94 Kubernetes
95 Observability and performance
96 Performance in containers
97 Testing fundamentals
98 Test-driven development
99 A TDD example with a single use case
100 Test doubles
101 Fake object
102 From JUnit 4 to 5
103 Testing beyond JUnit
104 Gathering container logs
105 Specification-style testing with Spek and Kotlin
106 Property-based testing with Clojure
107 test.check
108 Part 5. Java frontiers
109 Advanced functional programming
110 Recursion
111 Limitations of Java as a FP language
112 Recursion
113 Laziness
114 Kotlin FP
115 Tail recursion
116 Sequences
117 Lazy sequences
118 Advanced concurrent programming
119 Concurrency and functional programming
120 Under the hood with Kotlin coroutines
121 Concurrent Clojure
122 Software transactional memory
123 Modern internals
124 Final methods
125 MethodType
126 Invokedynamic
127 Small internal changes
128 Unsafe
129 Replacing Unsafe with supported APIs
130 Future Java
131 Project Panama
132 Project Loom
133 Thread builders
134 Project Valhalla
135 Consequences of value objects
136 Generics revisited
137 Appendix A. Selecting your Java