The Hidden Dynamic Life of Java

We are used to thinking that the Java compiler knows well beforehand what is going to happen at runtime... Is it so?
Actually, Java is introducing more and more dynamic behaviour recently, which is facilitated by the `invokedynamic` instruction. Let's take a look at several use-cases when this is happening and see why we should care in the first place!

I built my own JVM language. Here's why and how

Have you ever wondered, what your compiled code looks like? What do these bytecode instructions do? What are all these JVM languages about?
I was really curious about all this myself. That's why I ended up building my own JVM programming language. I wrote the compiler in Java, using ANTLR for building the parse tree and ASM for generating the bytecode.
Building this project was a lot of fun and also a lot of learning. So in this talk I will share the journey and my learnings with you.
We will talk about designing a language and building grammar with ANTLR. This knowledge can be reused to build any other DSL.
Afterwards, we will dive straight into the JVM architecture and generating the bytecode using ASM framework. This will give a decent understanding of how the bytecode operations work and how the compilers work. You will see what all these JVM programming languages are doing internally.
And of course, we will run some programs written in our little language to see it in action!

This session has been presented at J-Fall 2022, where it got into top 5 best rated sessions.

Internal Life of Your Debugger

Every developer is familiar with debugging: we all debug applications quite often.
In this talk I invite you to take a look deeper and see how it works inside.
To understand that better, we will first discuss the JVM architecture and the bytecode execution process.
Then, let’s talk about Java Platform Debugger Architecture. We will see how debuggers talk to JVM via the JDWP protocol, and if there is any real-life danger in it.
There are different ways to implement a custom debugger, so let’s see what it takes!
I will also demonstrate a homemade debugger that is not bound to any source code.
Curious? See you there!

This session has been previously presented at Utrecht JUG Meetup.