Entering the next phase of Project Valhalla

[Brian Goetz]

We had an in-person meeting last week in Burlington MA to thrash out 
where we are, and where we're going next.  It was a super-productive 
meeting with broad attendance -- thanks to everyone who made the trip in 
person, or dialed in.  This was a good time to take stock, since we've 
been doing Valhalla for a while -- over four years.  And, like all 
worthwhile projects, we hadn't realized quite how much we had bitten 
off.  (This is good, because if we had, we'd probably have given up.)

I think this marks the beginning of the Phase III of the project. Phase 
I focused mostly on language and libraries, trying to wrap our heads 
around exactly what a clean migration to value types and specialized 
generics would look like -- including how we'd migrate core APIs like 
Collections and Streams, and understanding the limitations of the VM we 
had, so we could envision the VM we needed.  This phase produced 3 
prototypes (Models 1-3), whose areas of exploration included 
specialization mechanics (M1), handling of wildcards (M2) and classfile 
representations for specialization and erasure (M3).  At which point we 
realized the list of VM requirements was implausibly long and we needed 
to come at this from the other direction for a while.

Phase II attacked the problem from the VM up, with two more rounds of 
prototypes -- MVT and LW1.  LW1 was a risky experiment; we hoped, but 
weren't sure we could get away with, sharing the L-carrier and a* 
bytecodes between references and values, without losing performance.  If 
we could do so, many of the problems we discovered in Phase I could go 
away.  And, all evidence seems to suggest that this was successful, and 
we have a much richer base to build on.

So, I think this demarcates the start of Phase III -- where we have a 
solid enough proof-of-concept that we can largely graduate from the 
"risky experiments and wild theories" portion of the program (at least 
for the VM).  Fantastic work from everyone involved to get us here!


Looking ahead, our next target is L2 -- which will capture the choices 
we've made so far, provide a useful testbed for doing library 
experiments, and set the stage for drilling into the remaining open 
questions between here and L10.  L10 is our target for a first preview, 
which should support value types and erased generics over values.

Stay tuned for a round of technical writeups capturing decisions and 
open issues....