in Personal

Post JavaOne Update

I’d like to say I attended dozens of JavaOne presentations, but I barely managed to attend two plus do my own three talks, plus interview 3 job candidates (we’re going to make all 3 offers), plus attend a Scala working dinner with Martin Odesky, catch up with some old friends, surf the pavilion, meet with 3 or 4 potential customers, visit the infamous Puzzle Pirate’s HQ and have dinner in the oldest continuously operating restaurant in SF.

I attended Bill Pugh’s “Defective Java Code: Turning WTF Code into a Learning Experience”.  As usual for Bill, the talk was very entertaining with plenty of OMyGod code examples from big well-known projects, all found with static analysis and pattern matching using his fabulous FindBugs.  I found a good writeup in this blog, but I can’t find a copy of the slides online.

I attended Brian Goetz’s “Let’s Resync: What’s New for Concurrency”.  Again, I found a good writeup here but no slides.  The Big News: Doug Lea’s Fork-Join is coming along well and will be in Java7.  It promises to be a very easy to use well-scaling divide-and-conquer style parallel framework.  I’d love to see how it works on one of our big 768-way boxes.

I gave 3 talks:

  1. Debugging Data Races.  I talk too fast, or at least I did during the memory-ordering portion of the talk.  Most folks liked the 2nd half (some fairly concrete examples and suggestions), but the 1st half needs some timing/pacing.
  2. Towards a Coding Style for Scalable Nonblocking Data Structures.  Sample blog entry here.  Biggest complaint from the talk: I went way to fast.  Sorry – it’s a talk I’ve given a few too many times and I’m getting lazy about presentation.  The code from SF high-scale-lib got a bump: 50 downloads this last week.  I’m always psyc’d when I hear feedback from this talk; it looks to me like a 1-hit-wonder (well 2.5 hits) but I’m always left with the notion that with better tools (ala what the hardware folks have built) that this approach should have some legs.
  3. JVM Challenges and Directions in the Multi-Core Era.  I split the last talk with Brian Goetz.  Two-speaker talks are always hard to pull off, but I think we managed a great job.  Sample blog writeup here.  Funniest question (to me): “How’s .Net doing here?” My answer: “I am not my brother’s keeper!”.  Seriously, I’ve had dinner talks with some of the .Net runtime group, and they are shockingly out of touch here.  I forsee a large multi-core train thundering down Microsoft’s self-induced tunnel vision.

Azul News: We’re hiring again!  We managed to survive the downturn in the banking industry.  We spent the last year widening our customer base, and it’s finally paying off.  Plus the banks are buying again!  I interviewed 3 candidates who were in town for JavaOne.  I think we’re making offers to all three.  Mentally exhausting, moreso for them than me I daresay.

I had dinner with the bay area Scala working group (sorry couldn’t find any official link), and Martin Odersky at Buca di Beppo’s.   It was a fun geeky talk/dinner.  I’m please to report that (unlike say JRuby) Scala “maps” well onto a JVM.  Code performance is probably very transparent (very sad, but no personal experience here) and very good.  Martin claims he made no real compromises in fitting the language to the JVM (but perhaps some minor warts with ‘null’ or a lack of unsigned types).  A harder issue is getting the Actor model to map well.  I personally am a fan of “no shared variables” and I hope he gets a good fit figured out.  Like most functional languages, Scala would like to see tail-recursion promised from the JVM vendors/spec (and rumors from John Rose that this might happen to HotSpot).  With tail-recursion, the cost-model of tail-calls is that they cost no more than a ‘goto’ (which after JIT’ing can be quite low indeed).  The moral equivalent for data-structures is linear logic.  The key here is allowing the JVM and/or JIT to figure out when a message cannot be referenced by the sender again and hence the “message passing” isn’t really a copy-cost – it’s no more than a pointer change.  I.e, similar to tail-recursion, the cost-model becomes “pointer copy” – such that you can look at the code and know “this operation is (almost) free”.  This is one of the major strong points of the C language – knowing a code’s “cost” at a glance.

I also got the guided tour of Puzzle Pirate’s headquarters.  All I can say is: Wow.  I’d love to work in that space.  From there I took a hike to have dinner at the Tadich Grill.  This is the most non-San Francisco restaurant I’ve ever eaten at in SF.  The both the staff and clientele were as about as white as you can get.  The food and service (and prices) were all great – but I definitely felt the lack of SF “color”!  No blue-dyed spiky hair, no leather&stud bracelets, no piercings (other than female ears), and exactly 2 customers not as pasty-white as myself (and I arrived with one of them).  It was so different, that it felt like a refreshing change from the usual SF polyglot… but I was glad to walk out the door and see somebody who didn’t look like a mirror image of myself.  Like programming languages, sameness is bland in the short term and a form of death in the long term.  Viva ‘la difference!