Optimizing Java

Video Description

With any comprehensive, large-scale programming language, if you’re not careful during your development processes, you can end up with a bloated, poorly performing application. This course examines techniques and methods that you can employ to optimize your Java code and squeeze more efficiency out of your applications. You’ll look at JVM subsystems, modern processor technologies and how you can best utilize them, and how to diagnose an application to find trouble areas that might be affecting its performance. This course is designed for intermediate- to advanced-level programmers. Here are just some of the areas in which this course can benefit you:

  • Review the historical context of Moore’s Law and how Java has benefitted from it over the years
  • Examine the technical complexities of the JVM subsystems
  • See how to design and set up monitoring and logging systems to help you analyze and assess how your code is functioning
  • Learn both basic and advanced garbage collection techniques
  • Compile AOT and JIT, including tiered compilation and how it really works
  • Investigate concurrent techniques such as synchronization, OS-level locking, and non-availability to single-core processors

Your host, Ben Evans is an author, speaker, consultant and educator. He is a co-founder of jClarity, a startup which delivers performance tools and services to help development and ops teams. He helps to organize the London Java Community and serves on the Java Community Process Executive Committee, helping to define standards for the Java ecosystem. He is a Java Champion, JavaOne Rockstar Speaker and a Java Editor at InfoQ. Ben travels frequently and speaks regularly, all over the world.

Table of Contents

  1. Introduction
    1. Welcome to the Course 00:08:29
  2. Setting the Scene
    1. Theory: JVM Subsystems 00:24:07
    2. Theory: Moore's Law & Consequences 00:10:45
    3. Theory: Modern Processor Architecture 00:18:20
    4. Theory: Operating Systems and Code Execution 00:25:01
    5. Internals: JVM Objects at Runtime 00:38:29
    6. Internals: Bytecode Basics 00:54:14
    7. Internals: Execution of Bytecode 00:34:40
  3. Top Down Analysis
    1. Practical: Architecting Logging for Observability 00:17:08
    2. Theory: Simple System Model 00:13:31
    3. Practical: Basic Analysis Technique 00:16:24
  4. Understanding Garbage Collection
    1. Theory: Introduction to Mark and Sweep 00:10:20
    2. Theory: Generational Mark and Sweep 00:20:02
    3. Practical: HotSpot (v8) Heap - Parallel 00:18:40
    4. Theory: Allocation and Lifetime 00:20:53
  5. Advanced Garbage Collection
    1. Theory: Collector Tradeoffs 00:06:24
    2. Theory: Concurrent Marking 00:09:59
    3. Internals: Safepoints Reconsidered 00:07:46
    4. Practical: Concurrent Mark and Sweep (CMS) 00:12:00
    5. Practical: G1 00:10:06
  6. JTI Compilation
    1. Overview: JIT Compilation 00:23:06
    2. Practical: Tuning JIT Compilation with Code Cache 00:13:24
    3. Internals: Compilation Strategies in HotSpot 00:18:23
    4. Practical: JIT-friendly code 00:09:50
  7. Profiling & Statistics
    1. Practical: Introduction to Noisy Data 00:08:26
    2. Methodology: Review of Statistics for Performance 00:05:49
    3. Practical: Statistical Profiling 00:06:28
    4. Theory: Microbenchmarks 00:09:52
  8. Beyond Java 8
    1. Theory: Graal 00:08:16
    2. Practical: Hands-on With Graal and GraalVM 00:07:30
    3. Theory: Value Types 00:06:35
  9. Conclusion
    1. Wrap Up and Thank You 00:01:06

Product Information

  • Title: Optimizing Java
  • Author(s): Ben Evans
  • Release date: December 2018
  • Publisher(s): O'Reilly Media, Inc.
  • ISBN: 9781492044666