The Well Grounded Java Developer MEAP Version 6 2nd Edition by Martijn Verburg, Jason Clark, Benjamin Evans ISBN 9781617298875 1617298875

The Well Grounded Java Developer MEAP Version 6 2nd Edition by Martijn Verburg, Jason Clark, Benjamin Evans – Ebook PDF Instant Download/Delivery: 9781617298875 ,1617298875
Full download The Well Grounded Java Developer MEAP Version 6 2nd Edition after payment

Product details:
ISBN 10: 1617298875
ISBN 13: 9781617298875
Author: Martijn Verburg, Jason Clark, Benjamin Evans

The Well Grounded Java Developer MEAP Version 6 2nd Edition Table of contents:

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

Summary

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

Summary

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

Summary

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

Summary

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

Summary

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

Summary

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

Summary

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

Summary

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

Summary

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

12.3 Developing Java applications with Docker

12.3.1 Selecting your base image

12.3.2 Building an image with Gradle

12.3.3 Running the build in Docker

12.3.4 Ports and hosts

12.3.5 Local development with Docker Compose

12.3.6 Debugging in Docker

12.3.7 Logging with Docker

12.4 Kubernetes

12.5 Observability and performance

12.5.1 Observability

12.5.2 Performance in containers

Summary

13 Testing fundamentals

13.1 Why we test

13.2 How we test

13.3 Test-driven development

13.3.1 TDD in a nutshell

13.3.2 A TDD example with a single use case

13.4 Test doubles

13.4.1 Dummy object

13.4.2 Stub object

13.4.3 Fake object

13.4.4 Mock object

13.4.5 Problems with mocking

13.5 From JUnit 4 to 5

Summary

14 Testing beyond JUnit

14.1 Integration testing with Testcontainers

14.1.1 Installing testcontainers

14.1.2 An example with Redis

14.1.3 Gathering container logs

14.1.4 An example with Postgres

14.1.5 An example for end-to-end testing with Selenium

14.2 Specification-style testing with Spek and Kotlin

14.3 Property-based testing with Clojure

14.3.1 clojure.test

14.3.2 clojure.spec

14.3.3 test.check

14.3.4 clojure.spec and test.check

Summary

Part 5. Java frontiers

15 Advanced functional programming

15.1 Introduction to functional programming concepts

15.1.1 Pure functions

15.1.2 Immutability

15.1.3 Higher-order functions

15.1.4 Recursion

15.1.5 Closures

15.1.6 Laziness

15.1.7 Currying and partial application

15.2 Limitations of Java as a FP language

15.2.1 Pure functions

15.2.2 Mutability

15.2.3 Higher-order functions

15.2.4 Recursion

15.2.5 Closures

15.2.6 Laziness

15.2.7 Currying and partial application

15.2.8 Java’s type system and collections

15.3 Kotlin FP

15.3.1 Pure and higher-order functions

15.3.2 Closures

15.3.3 Currying and partial application

15.3.4 Immutability

15.3.5 Tail recursion

15.3.6 Lazy evaluation

15.3.7 Sequences

15.4 Clojure FP

15.4.1 Comprehensions

15.4.2 Lazy sequences

15.4.3 Currying in Clojure

Summary

16 Advanced concurrent programming

16.1 The Fork/Join framework

16.1.1 A simple F/J example

16.1.2 Parallelizing problems for F/J

16.1.3 Work-stealing algorithms

16.2 Concurrency and functional programming

16.2.1 CompletableFuture revisited

16.2.2 Parallel streams

16.3 Under the hood with Kotlin coroutines

16.3.1 How coroutines work

16.3.2 Coroutine scoping and dispatching

16.4 Concurrent Clojure

16.4.1 Persistent data structures

16.4.2 Futures and pcalls

16.4.3 Software transactional memory

16.4.4 Agents

Summary

17 Modern internals

17.1 Introducing JVM internals: Method invocation

17.1.1 Invoking virtual methods

17.1.2 Invoking interface methods

17.1.3 Invoking “special” methods

17.1.4 Final methods

17.2 Reflection internals

17.3 Method handles

17.3.1 MethodHandle

17.3.2 MethodType

17.3.3 Looking up method handles

17.3.4 Reflection vs. proxies vs. method handles

17.4 Invokedynamic

17.4.1 Implementing lambda expressions

17.5 Small internal changes

17.5.1 String concatenation

17.5.2 Compact strings

17.5.3 Nestmates

17.6 Unsafe

17.7 Replacing Unsafe with supported APIs

17.7.1 VarHandles

17.7.2 Hidden classes

Summary

18 Future Java

18.1 Project Amber

18.2 Project Panama

18.2.1 Foreign Function and Memory API

18.3 Project Loom

18.3.1 Virtual threads

18.3.2 Thread builders

18.3.3 Programming with virtual threads

18.3.4 When will Project Loom arrive?

18.4 Project Valhalla

18.4.1 Changing the language model

18.4.2 Consequences of value objects

18.4.3 Generics revisited

18.5 Java 18

Summary

Appendix A. Selecting your Java

A.1 Java is still free

A.1.1 Java SE/OpenJDK/Oracle OpenJDK Builds/Oracle JDK

A.2 Staying with Java SE 8

A.2.1 $Free (as in beer) and free (as in use) Java SE 8

A.3 Getting Java SE 11

A.3.1 $Free (as in beer) and free (as in use) Java SE 11

A.4 Getting Java SE 17 (LTS)

A.4.1 $Free (as in beer) and free (as in use) Java SE 17

A.5 Paid support

Appendix B. Recap of streams in Java 8

B.1 Backward compatibility

B.2 Default methods

B.3 Streams

B.3.1 Example

B.4 The limits of collections

B.5 Infinite streams

B.6 Handling primitives

B.7 Parallel operations?

People also search for The Well Grounded Java Developer MEAP Version 6 2nd Edition:

    
the well grounded java developer github
    
the well grounded java developer second edition на русском
    
the well-grounded java developer second edition
    
shameless plug – the well grounded java developer
    
the well-grounded java developer

Tags: Martijn Verburg, Jason Clark, Benjamin Evans, Well Grounded, Java Developer