Section 1 : 1 Chapter 1 - Introduction

Lecture 1 INTRODUCTION TO BRAINMEASURES PROCTOR SYSTEM Pdf
Lecture 2 Example code provided with this course 1:1
Lecture 3 Using different JDK and JVM vendors 1:37
Lecture 4 The structure of this course 3:34

Section 2 : 2 Chapter 2 - Just In Time Compilation and the Code Cache

Lecture 6 What is bytecode 3:3
Lecture 7 The concept of Just In Time Compilation 5:51
Lecture 8 Introducing the first example project 3:35
Lecture 9 Finding out which methods are being compiled in our applications 5:23
Lecture 10 The C1 and C2 Compilers and logging the compilation activity 4:43
Lecture 11 Tuning the code cache size 6:18
Lecture 12 Remotely monitoring the code cache with JConsole 8:29

Section 3 : 3 Chapter 3 - Selecting the JVM

Lecture 13 The differences between the 32 bit and 64 bit JVM 4:32
Lecture 14 Specifying which compiler to use at runtime 6:34
Lecture 15 Turning off tiered compilation 2:4
Lecture 16 Tuning native compilation within the Virtual Machine 9:59

Section 4 : 4 Chapter 4 - How memory works - the stack and the heap

Lecture 17 Introduction - the structure of Javas memory 2:58
Lecture 18 How the stack works 5:56
Lecture 19 How the heap works 5:25
Lecture 20 The heap and the stack together - an example 7:47

Section 5 : 5 Chapter 5 - Passing objects between methods

Lecture 21 What does passing by value mean 4:55
Lecture 22 What does passing by reference mean 2:20
Lecture 23 Passing objects into methods
Lecture 24 The final keyword and why its not the same as a constant 3:9
Lecture 25 Why the final keyword doesnt stop an objects values from being changed 5:43

Section 6 : 6 Chapter 6 - Memory exercise 1

Lecture 26 Instructions for the exercise 1:35
Lecture 27 Walkthrough of the solution 8:46

Section 7 : 7 Chapter 7 - Escaping References

Lecture 28 Introduction - what is an escaping reference 5:33
Lecture 29 Strategy 1 - using an iterator 7:31
Lecture 30 Strategy 2 - duplicating collections 6:54
Lecture 31 Strategy 3 - using immutable collections 4:38
Lecture 32 Strategy 4 - duplicating objects 5:6
Lecture 33 Strategy 5 - using interfaces to create immutable objects 4:40
Lecture 34 Strategy 6 - using modules to hide the implementation 9:49

Section 8 : 8 Chapter 8 - Memory Exercise 2

Lecture 35 Instructions for the exercise 4:40
Lecture 36 Walkthrough of the solution 7:39

Section 9 : 9 Chapter 9 - The Metaspace and internal JVM memory optimisations

Lecture 37 The role of the Metaspace 5:9
Lecture 38 The PermGen 1:58
Lecture 39 Are objects always created on the heap 4:14
Lecture 40 The String Pool 6:8
Lecture 41 Interning Strings 3:4

Section 10 : 10 Chapter 10 - Tuning the JVMs Memory Settings

Lecture 42 How the string pool is implemented 4:11
Lecture 43 Understanding the size and density of the string pool 11:36
Lecture 44 Tuning the size of the string pool 3:28
Lecture 45 Tuning the size of the heap 7:45
Lecture 46 Shortcut syntax for heap tuning flags 3:6

Section 11 : 11 Chapter 11 - Introducing Garbage Collection

Lecture 47 What it means when we say Java is a managed language 4:57
Lecture 48 How Java knows which objects can be removed from the Heap 2:50
Lecture 49 The System 4:29
Lecture 50 Java 11s garbage collector can give unused memory back to the operating system 3:53
Lecture 51 Why its not a good idea to run the System 2:6
Lecture 52 The finalize() method 5:18
Lecture 53 The danger of using finalize() 3:28

Section 12 : 12 Chapter 12 - Monitoring the Heap

Lecture 54 What is a soft leak 8:52
Lecture 55 Introducing (J)VisualVM 6:59
Lecture 56 Monitoring the size of the heap over time 2:59
Lecture 57 Fixing the problem and checking the heap size 4:16

Section 13 : 13 Chapter 13 - Analysing a heap dump

Lecture 58 Generating a heap dump 3:13
Lecture 59 Viewing a heap dump

Section 14 : 14 Chapter 14 - Generational Garbage Collection

Lecture 60 How the garbage collector works out what is garbage 3:54
Lecture 61 Why the heap is divided into generations 4:6
Lecture 62 The Internals of the Young Generation 5:1
Lecture 63 Viewing the generations in VisualVM 6:11
Lecture 64 Viewing the heap when theres a soft leak 3:5

Section 15 : 15 Chapter 15 - Garbage Collector tuning selection

Lecture 65 Monitoring garbage collections 6:28
Lecture 66 Turning off automated heap allocation sizing 5:47
Lecture 67 Tuning garbage collection - old and young allocation 4:55
Lecture 68 Tuning garbage collection - survivor space allocation 2:24
Lecture 69 Tuning garbage collection - generations needed to become old 2:7
Lecture 70 Selecting a garbage collector 5:38
Lecture 71 The G1 garbage collector 4:11
Lecture 72 Tuning the G1 garbage collector
Lecture 73 String de-duplication 2:53

Section 16 : 16 Chapter 16 - Using a profiler to analyse application performance

Lecture 74 Introducing Java Mission Control (JMC) 3:45
Lecture 75 Building the JMC binaries 5:17
Lecture 76 Running JMC and connecting to a VM 3:31
Lecture 77 Customising the overview tab
Lecture 78 The MBean Browser tab 1:40
Lecture 79 The System Memory and Diagnostic Commands tabs 2:24
Lecture 80 Introducing our problem project 7:59
Lecture 81 Using the flight recorder 9:2
Lecture 82 Analyzing a flight recording 4:23
Lecture 83 Improving our application 4:39

Section 17 : 17 Chapter 17 - Assessing Performance

Lecture 84 Why benchmarking isnt straight forward 6:10
Lecture 85 Setting up the code for benchmarking 5:52
Lecture 86 A simple approach to micro-benchmarking 1:53
Lecture 87 Adding in a warm-up period 4:37
Lecture 88 Comparing two code alternatives 2:30
Lecture 89 Using Macro-bencharmking 5:10

Section 18 : 18 Chapter 18 - Benchmarking with JMH

Lecture 90 Installing the JMH benchmarking tool 4:19
Lecture 91 Creating and running benchmarks 5:56
Lecture 92 Using different benchmark modes 3:10

Section 19 : 19 Chapter 19 - Performance and Benchmarking Exercise

Lecture 93 Instructions for exercise 1 (creating a flight recording) 1:41
Lecture 94 Walkthrough of the solution setting up ready for the next challenge 5:12
Lecture 95 Instructions for exercise 2 (use JMH to macrobenchmark the project) 1:55
Lecture 96 Walkthrough of the solution - part 1 setting up the code 5:18
Lecture 97 Walkthrough of the solution - part 2 - integrating into JMH 7:10

Section 20 : 20 Chapter 20 - How Lists Work

Lecture 98 Why its important to understand how the different List implementations work 1:39
Lecture 99 The 8 different list implementations 1:40
Lecture 100 The CopyOnWriteArrayList 2:37
Lecture 101 The ArrayList 6:2
Lecture 102 Specifying the initial size of an ArrayList 5:33
Lecture 103 The Vector 2:55
Lecture 104 The Stack 1:19
Lecture 105 The LinkedList 3:8
Lecture 106 Choosing the optimal list type 6:58
Lecture 107 Sorting lists 2:38

Section 21 : 21 Chapter 21 - How Maps Work

Lecture 108 How Hashmaps Work - part 1 3:17
Lecture 109 The role of the Hashcode
Lecture 110 How Hashmaps Work - part 2 3:46
Lecture 111 Specifying the initial size and factor of a HashMap 4:30
Lecture 112 HashMap Performance 2:31
Lecture 113 The rules for Hashcodes 4:15
Lecture 114 Generating and optimising the Hashcode method 6:29
Lecture 115 Optimising Hashmap Performance 0:49
Lecture 116 How The LinkedHashMap Works 4:52
Lecture 117 The HashTable and TreeMap 1:51

Section 22 : 22 Chapter 22 - Other Coding Choices

Lecture 118 Introduction to how well compare coding options 1:42
Lecture 119 Comparing primatives with objects 2:55
Lecture 120 Comparing BigDecimals with Doubles 3:47
Lecture 121 Using the StringBuilder 4:46
Lecture 122 Comparing loops and streams 6:42
Lecture 123 A note on logging 3:57

Section 23 : 23 Chapter 23 - GraalVM

Lecture 124 What is GraalVM 6:45
Lecture 125 Installing GraalVM 2:59
Lecture 126 Using the Graal Virtual Machine 6:35
Lecture 127 Using the Graal Compiler 2:25
Lecture 128 Native image building with Graal 4:14
Lecture 129 Using the Graal experimental features within OpenJDK 3:34

Section 24 : 24 Chapter 24 - Using Other JVM Languages

Lecture 130 The principles of using other JVM Languages 7:5
Lecture 131 Looking at bytecode with javap 10:50
Lecture 132 Disassembling bytecode back to Java 7:23

Section 25 : 25 Chapter 25 - Course Summary

Lecture 133 The OpenJ9 Virtual Machine and whats coming up in future versions of Java 3:2