by Neal Ford
Why should you learn Clojure now? It’s the coolest new language on the JVM. What makes it so cool? It’s a dynamically typed, functional Lisp that offers sophisticated capabilities like software transactional memory. Why should I learn it? Lisp is the most powerful style of programming language possible (don’t believe me? Come see - I’ll show you), so you get the best language (Lisp) on the best runtime (JVM). Isn’t Lisp the one with all the parenthesis? Yes. What’s so compelling about Clojure? It’s fast, expressive, powerful, and allows you to do all sorts of things that other languages won’t let you do. It’s an elegant language. Why is the entire talk done as question and answer? It’s an homage to a series of books, The Little Lisper and The Little Schemer. Because Lisps are simple and homoiconic: this style works nicely for them. Besides, it’s better than 1000 bullets, isn’t it?
by Gil Tene
Garbage Collection is an integral part of application behavior on Java platforms, yet it is often misunderstood. As such, it is important for Java developers to understand the actions you can take in selecting and tuning collector mechanisms, as well as in your application architecture choices. In this presentation, Gil Tene (CTO, Azul Systems) reviews and classifies the various garbage collectors and collection techniques available in JVMs today. Following a quick overview of common garbage collection techniques including generational, parallel, stop-the-world, incremental, concurrent and mostly-concurrent algorithms, he defines terms and metrics common to all collectors. He classifies each major JVM collector's mechanisms and characteristics and discusses the tradeoffs involved in balancing requirements for responsiveness, throughput, space, and available memory across varying scale levels. Gil concludes with some pitfalls, common misconceptions, and "myths" around garbage collection behavior, as well as examples of how some good choices can result in impressive application behavior.
You think you know all there is about building apps for the JVM. You've used all the cool tools. You've written your own persistence library or web frameworks. Maybe you've even implemented a JVM language. But do you really know what happens to your code after you hand it off to the JVM? This talk will explore the guts of the OpenJDK VM, Hotspot. We'll take a few simple examples from bytecode through optimization and compilation all the way down to assembly code, and learn how you can ensure your code runs as fast as possible.
9th–12th July 2012