Douglas Hawkins
Lead Developer Java Performance Monitoring at Datadog
Douglas Hawkins has been passionately developing software for the past 20 years.Throughout Doug's career, he has focused on creating performance intensive applications
in Java ranging from bioinformatics to financial exchanges.
After 10 years as a Java developer, Doug transitioned to working on Azul's Java Virtual Machine.
Today, Doug continues his interest in building performance tools for developers working on Datadog's Java Application Performance Monitoring.
While Doug's passion for developing software remains, his true passion is in sharing his
interest in low-level details and JVM performance with others.
Presentations
Concurrency Concepts in Java
Unlike other languages, Java had a well-defined memory model from the very beginning, but over the years additional packages and low-level features have been added to make the most of today's hardware.
In this talk, we'll discuss concurrency in detail starting at the hardware up to Java's latest synchronization mechanisms and finally onto high-level concurrent collections.
This talk will cover hardware memory fences, Java's synchronized and volatile, Atomic classes, newer capabilities added by VarHandles, and some select high-level concurrent collections.
Understanding Java Garbage Collectors
Most of us don't want to go back to the days of malloc and free, but the magic of garbage collectors while convenient can be mysterious and hard to understand.
In this talk, you'll learn about the many different garbage collectors available in JVMs. The strength and weaknesses of the different allocation and collection strategies used by each collector. And how garbage collectors keep evolving to support today's hardware and cloud environments.
This talk will cover the core concepts in garbage collection: object reachability, concurrent collectors, parallel garbage collectors, and generational garbage collectors. These concepts will be covered by following the progression of garbage collectors in the HotSpot JVM.
Just-in-Time Compilation Isn't Magic
Fortunately for most Java developers the just-in-time compiler just works and appears to do so by magic. And yet sometimes, we find ourselves facing a performance problem, so what do we when the magic stops?
In this talk, we’ll learn a few key concepts behind the magic of modern optimizing compilers: intrinsics, basic blocks, static single assignment, and inlining. By learning these key concepts, you’ll learn to save time not trying to optimize the things that the compiler can already do for you and to focus on the things that matter most.
This talk will provide a high-level overview of just-in-time compilation.
The talk will cover when the JVM triggers just-in-time compilation, an overview of core compiler concepts, and speculative optimizations and deoptimization which make the JVM unique.