There are those moments when everything just falls into place.
Before Xmas and before I got the notification from the CAB at cf.Objective(), one of my submitted sessions was accepted for Scotch On The Rocks 2014. I’m still extremely happy about that as the amount of submissions they got was massive (around ~160, iirc) and given that it’s a quite small event, it must have been a tremendously hard choice for them to select sessions. And I’m very, very glad that I made the cut.
It’ll be about 6 years ago that I’ve been to Edinburgh the last time and I’m very keen on going back for both the city and the conference. SOTR used to be very much a CFML conference back then. That’s changed quite a bit over the last few years and the conference is now much more of a (web) development conference open for both topics on the frontend development side of things as well as for backend topics. I’ll also get to see my friend Kay again, yay! Co-incidentally she wrote a very interesting piece about SOTR’s “incentive ticketing”.
However, I was actually a bit surprised when my talk: “Digging in the dirt or digging for Gold? The Internals of the Java Virtual Machine!” was selected.
My initial thoughts were along the lines of:
“Yay, they accepted my talk!!!! Awesome, I’m going to Scotland again!!!”
“Oh, hang on. They want… THAT ONE? Really? WTF!”
Please note that this session is a different talk from what I’m going to present on at cf.Objective() – which is about JVM and memory tuning for CFML developers. My session at Scotch On The Rocks will be quite fundamental in a way that I will endeavour to explain the JVM. Well, maybe not all of it in ~50 minutes, but the Essentials; The parts that people really should understand to then being able to understand what happens right below the language/server of their choice and why JVM tuning might even become necessary. It’s actually kind of geeky – read for yourself, below is my talk’s abstract:
Digging in the dirt or digging for Gold? The Internals of the Java Virtual Machine!
The JVM is a funny odd little thing. Loved and hated by just a few, ignored and misunderstood by many. People talk about Memory Management, Garbage Collection and all sorts of stuff, but what IS the JVM and how does it work?
This talk will discuss the common architecture features of Java Virtual Machines. What does it take to compile one’s Java, CFML, Clojure, Scala (or whatever JVM-based language you might prefer) source code into byte code and execute that? What are life cycle and memory constraints of a Virtual Machine running on actual hardware? And yes – how does it manage memory and how does Garbage Collection work?
The session will – as indicated in the title – focus on the Java Virtual Machine. But a lot of concepts that apply to the JVM are generic problems of Computer Science and this talk might bring back some memories from the past: stacks, types, threads, pointers and much more. Along the way we’re also having a discussion about the (sometimes subtle) differences between the Sun/Oracle JVM, JRockit or the SAP JVM (did you even know SAP was in this business?)
You might ask: Why is this important anyway? The answer is astonishingly simple: Without having at least a fundamental understanding of how the JVM works, you will not be able to write effective and efficient code in any language on top of the JVM.
Comments on this entry are closed.