The Well-Grounded Java Developer Version 6

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