Raw Information

Talks

Jython — Jim Baker

(tbd)

Ioke - A folding language — Ola Bini

Ioke is a new language, an experiment to see how expressive a language can be. It's a language for the JVM influenced by Io, Self, Smalltalk, Lisp and Ruby. It supports a prototype based object oriented system, is homoiconic, supports high level methods and macros and makes it easy to build DSLs and new abstractions from scratch.

The presentation will introduce Ioke and the features of the language that differ from other languages.

A performance tale: the evolution of binding in JavaFX — Robert Field

JavaFX Script is a statically-typed, object-oriented language for building Rich Internet Applications on the Java Platform. JavaFX Script provides data binding as a first-class entity, allowing developers to do much more with less code.

As might be expected, the first version of the JavaFX compiler implemented features such as binding and dependency management in a runtime library. This enabled us to get to a working compiler quickly, but as often happens the performance of this approach is not ideal. Then comes the long slow process of making things faster by breaking abstractions and pulling intelligence from the runtime library into the compiler.

This talk will chronicle our ongoing work on making JavaFX not only powerful and fun but fast.

Deep dive into the backport — Rémi Forax

This talk will present the JSR 292 backport that implement JSR 292 specification on 1.5, 1.6 compatible Java Platforms.

After a short intro about the JSR292, the backport roadmap and bytecode weaving. I will talk about the first design of the backport and why it fails. Next, I will introduce the new design (the one currently implemented) how it works and how it optimizes method handle adapters that are some not so easy to optimize for a bytecode weaver.

I will finish by showing some benchmarks that will highlight how the optimizer works and some comparison graphs between the JSR292 Reference Implementation and the backport.

Dynamic types in a static type system — Neal Gafter

The static type system of C# has been extended in version 4.0 to support dynamic types. We describe the extended type system and show how it supports interoperability among static and dynamic languages on the .NET platform.

Are We There Yet? — Rich Hickey

Are we being well served by Java and its ilk? Have we reached consensus that this is the best way to build software? Is there any evidence that this is so? Is OO in the tradition of Java a known good, or just so widely adopted we no longer have the ability to see its attendant costs or limitations? Are we ready for an increasingly concurrent and heterogeneous world, or will we be facing an fundamental impedance mismatch? What pressures should drive the adoption of new (and often old) ideas not yet in the mainstream? This talk will advocate a reexamination of first principles including state, identity, value, time, types, genericity, complexity and information representation, and admit the possibility that not only are we not there, we may be driving the wrong car, on the wrong road. We'll take a look at some interesting ideas to consider as we determine 'what's next'.

The .NET Reactive Framework — Erik Meijer

The .NET Reactive Framework (Rx) is an abstraction of the well-known Subject/Observer pattern derived as the mathematical dual of the iterator pattern.

We show how Rx can be used to program against event streams and asynchronous computations using LINQ syntax as well as using good old imperative code.

JRuby, Duby, and Juby: Building a better Ruby — Charles Nutter

You know JRuby is an implementation of Ruby for the JVM. But have you heard about Duby or Juby? Duby is Ruby syntax with Java's type system and static typing. It utilizes local type inference to keep code as clean as Ruby, but runs as fast as Java. Juby is Duby's dynamic cousin, totally dynamically-typed and using invokedynamic for all dispatch. Both Duby and Juby have been research conduits for the next generation of JRuby work, which will incorporate techniques from both languages. We'll talk about all three.

Who should be doing these fancy optimizations anyway? — Fredrik Öhrström

JRuby, Jython, etc., transform a source language to bytecodes for the JVM. What kind of optimizations should they do (or not do) before handing the bytecode to the JVM? I will present a few anti-optimizations on bytecode to demonstrate what the JVM can handle and what it cannot handle. It will be visualized using JRockit with a peep hole into the JRockit optimizer.

Generating parsers and state machines in Java — Terence Parr

Implementing large and/or efficient state machines in Java is pretty tough. Because we're missing a few key items even at the Java bytecode level, some gymnastics are required. In this talk, I'll describe my experiences building parser generators (ANTLR) and interpreters in Java.

Scala Basics — David Pollak

Learn basic constructs in Scala and see how those constructs are translated into byte code. See how Scala implements tail calls, generics, boxing, @specialized, and structural types.

Exploring Dynamism — Allison Randal

Early R&D in modern dynamic languages was often marked by a conservative approach, taking dynamic features in tightly controlled doses to make them fit existing models developed for static languages. That attitude has changed in recent years, and the major commercial virtual machines are now actively pursuing support for dynamic features.

This renewed interest in dynamic languages leads to some questions. What are the defining characteristics of a dynamic language? Is it enough to support dynamic types? Is it enough to support dynamic dispatch? Is it enough to support the runtime generation of executable code entities (subroutines, methods, etc)? Is it enough to support introspection and meta-programming? This talk explores these questions and more, approaching the categorization of languages as static or dynamic as a graduated scale, rather than a hard binary divider.

Da Vinci Machine Project Update — John Rose

We will survey the present state of the Da Vinci Machine Project, with special emphasis on the implementation and use of method handles and invokedynamic.

Scala support in Java tools - Experiences from the Scala IDE for Eclipse — Miles Sabin

Seamless interoperability with Java code at the source and binary level is critical to the widespread adoption of most alternative JVM languages. Similarly seamless interoperability at the tooling level is just as vital.

This presentation reports on challenges faced and experiences gained during the developement of the Scala IDE for Eclipse, in particular its integration with the Eclipse JDT and support for mixed Scala/Java development.

Blame Tracking for Gradual Types — Jeremy Siek

Have you ever called a library function in a dynamic language only to have an exception thrown from deep inside the function? Is the error your fault (good heavens no!) or the fault of of the library writer? With the addition of gradual typing, it becomes possible to address this problem using a technology called blame tracking. The idea behind blame tracking is to enclose objects in a wrapper that represents the type that the object is suppose to have and that includes source information (line number, etc.) for where the object was cast to that type. If the object ever disobeys it's type, or is misused as if it had a different type, then the run-time system flags an error and tells the programmer who is to blame. In this presentation I will give an in-depth description of blame tracking and discuss recent research on how to reduce the run-time overhead of blame tracking to a constant factor.

Continuations for the Hotspot JVM — Lukas Stadler

Continuation support is part of the MLVM effort. They are a powerful concept that allows implementation of many advanced language features like coroutines, green threads, etc. This presentation covers the basic concepts of the lazy continuation mechanism and the details of the actual implementation in the JVM.

Metaobject Protocol Meets Invokedynamic — Attila Szegedi

Having a largely stabilized specification and working implementation of JSR-292 opened the way for a rethinking of the JVM Dynamic Languages Metaobject Protocol as a framework for runtime linking of invokedynamic calls between language runtimes. In this talk, I present the architecture of the framework in its current state: the pluggable linker mechanism, the type conversion subsystem, and the set of conventions that build on top of these two to implement a subset of well-known call identifiers that serve as the metaobject protocol nomenclature commonly understood by dynamic languages.

Performance comparisions of Java and Groovy — Jochen Theodorou

This presentation will focus on comparing Groovy and Java performance as well as for the reasons for the differences and possible ways to overcome the problem.

Jython and InvokeDynamic — Frank Wierzbicki

I will discuss the opportunities and difficulties inherent in implementing function dispatch in Jython using InvokeDynamic (JSR 292), which is coming in JDK 7. Jython's dispatch rules are quite dynamic. It is possible to redefine functions at runtime, use descriptors and other techniques to put arbitrary logic into the lookup rules. InvokeDynamic creates hooks into the JVM that will allow us to bind a call site to a function that can have almost the same performance charateristics as calls into static Java with the ability to add in guards that can signal the need to rebind to another function as needed. I am currently working on a proof of concept Jython with InvokeDynamic, so I will be able to talk about some implementation specifics.

Trace-Based Just-in-Time Compilation — Christian Wimmer

The execution model of Java is ideally suited for dynamic optimizations at run time. This allows novel feedback-directed optimizations that are not possible in traditional static compilers. However, current just-in-time compilers still inherit their basic structure from static compilers: the granularity of compilation are methods. Switching between the interpreter and compiled code is still mostly done when methods are called. In contrast, trace-based compilation focuses only on code that has shown to be frequently executed. The compiler operates on execution traces recorded at run time. It not only allows more aggressive optimizations of Java code, but is also well suited for dynamic languages because it simplifies the integration of type information gathered at run time. This talk introduces trace compilation, presents our recent advances, and presents optimizations that are based on this compilation approach.

Workshops

Jython — Jim Baker

(tbd)

Ioke - A hard language to optimize — Ola Bini

Ioke is a simple language in principle, but many of the features combine in highly complicated ways. The language also have several language features that make it very hard to compile to Java bytecode. This workshop aims to take a closer look at these Ioke features and also discuss how the language might be implemented in a performant way on the JVM. This would involve discussions about how invoke-dynamic could be used, but also other possible techniques.

JVM Performance and Concurrency — Cliff Click

(Further discussion of topics from presentation.)

The noop Programming Language — Alex Eagle

http://code.google.com/p/noop/

Clojure Deep Dive — Rich Hickey

Open-ended technical discussion on anything related to Clojure, moderated by the language's author.

Asynchronicus Anonymous — Erik Meijer

One of the most greatest pain points for programmers (at least in the .NET world) is dealing with asynchronous APIs. The standard .NET BeginXXX/EndXXX or event-based asynchronous programming model are low level and hard to use. Using callbacks as is common practice in many asynchronous frameworks is equally awkward.

Programmers in other ecosystems such as Java, JavaScript, Ruby, Python, Smalltalk, .... all face similar challenges.

It would be great to get together to discuss our common problem and learn from each others mistakes and working solutions.

JRuby, Duby, and Juby: Under the covers — Charles Nutter

We'll take a deeper dive into the internals of JRuby, Duby, and Juby, and how they relate. If you're interested in compilers, invokedynamic, and new languages, stop on by.

Factor: optimizing dynamic language compiler — Slava Pestov

Factor is a new multi-paradigm programming language with rich support for meta-programming. It borrows ideas from Lisp, Forth, and many other languages. Factor is a high-level language, with runtime dispatch, integers which automatically promote to bignums, and other features which are hard to implement efficiently. Nevertheless, we manage to achieve good performance with a highly optimizing ahead-of-time compiler written in Factor itself. The compiler is a modern design making extensive use of SSA (static single assignment) form optimizations. Optimizations include an extensible type inference and inlining pass which generalizes SCCP (sparse conditional constant propagation), escape analysis and tuple unboxing, integer overflow check elimination, alias analysis, value numbering, SSA coalescing, and linear scan register allocation. We also make use of high-level language abstractions and meta-programming in the compiler itself, to build a general dataflow analysis framework, among other things.

Dynamic Features and Implementations — Allison Randal

An open discussion on the fundamental concepts of dynamic languages, and the implementations that support them. What is a dynamic language? With more and more dynamic features used in static languages (JIT, PIC, etc) does the distinction even matter? What challenges do researchers and developers face as they move from static concepts to dynamic concepts? Are there aspects of established wisdom in computer science that don't apply well to dynamic languages?

Invokedynamic Deep Dive — John Rose

Extending on the JavaOne talk JSR 292 Cookbook, we will discuss code idioms that work well with invokedynamic, and discuss code shape and performance of dynamic calls.

Support for alternative languages in Java tools — Miles Sabin

Open ended discussion around alternative languages and Java tools starting from the content on the presentation but opened out to cover languages other than Scala and tools other than IDEs.

Using The Metaobject Protocol With Your Language Runtime — Attila Szegedi

In the workshop, we build on the talk and expect people interested in building language runtimes to provide their thoughts and comments on the architecture and the implementation of the linker framework and MOP nomenclature with the goal to recognize the needs of their specific language runtime and discuss how to implement these needs with the existing framework, or adjust the framework to support them.