JAOO - Sydney and Brisbane

I was fortunate enough to speak at the JAOO conferences in Sydney and Brisbane recently, my talk is below (thanks to slideshare).

JAOO is an impressive conference, with a good (and no doubt expensive) list of international speakers. I highly recommend it, as a "bring the world to you" local conference (next year will be Brisbane and Melbourne I hear) - although the full price is quite an ask in this day and age....

Well my thoughts on interesting sessions I went to:


How to build an iPhone app in 45 Mins (Patrick Linksey):
Lots of fun - probably most popular session - a bit of an Objective C intro to those that didn't know it. I was quite enjoying the nuances of it until I realised the bits that were entertaining me was the manual management - I guess after almost 10 years of not worrying about it you forget the bad...
Speeding Ducks (Avi Bryant):
Great talk on VM performance - the sydney one turned into a bit of discussion/hand wringing on who would pay for the development of advanced VMs for Ruby... interesting...

Consistency, Storage, and Reliability in the Cloud (Jonas S Karlsson):
Jonas introduced Google's Megastore, which introduces some interesting bits from RDBMS into googles big table storage system - including transactions etc... (its not "ACID" but it does allow things to scale in the way that google needs them to).

Deception and Estimation: How We Fool Ourselves (Linda Rising):
This was more a shallow dive into psychology, why we willfully deceive ourselves, and why its probably a good thing... very interesting, and actually a lot of fun to listen to (I got the impression people felt relieved and uplifted by it).

Of course Josh Blocks puzzlers was fun: note to self, don't ever ever use inheritance again if you can at all help it (all the questions are secret as he is doing the presentation I think at JavaOne).

Writing Large Applications in JavaScript (Douglas Crockford):
Great talk on javascript in general, the the hilarious way it inserts semicolons (a dirty hack even by my low standards !).

A picture from the stunning conference centre in Sydney:






Jaoo Michael Neale 09

View more presentations from Michael Neale.

Single vendor hell - aka "one neck to choke"

A colleague lamented the other day about the uber consolidation that is going on with the largest of IT vendors (and has been for some time).

I can't help but think its the "IT consumers" who share part of the blame for this: For years, in the late 90's and early 2000's people wanted to have less vendors to deal with, less overlap and "one neck to choke", well, guess what:

It has kind of happened. But this is a terrible terrible thing for IT consumers: who on earth would think that it could work out well for "IT consumers" to have one vendor providing the full stack? Its a testament to the genius of the vendors that the convinced people that a single vendor providing all parts of "the stack" was a good idea and a worthy goal.

Choice is a tiring thing to have, but its also a good thing, like exercise.

Be careful what you wish for - it might just come true. So IT consumers will now need to be doubly diligent to have a few suppliers in the mix lest the obvious happen to them.

Back it up

Backing up personal data is like flossing, you know you should do it...

Personally I use time machine on the macs in the house, on other boxen (linux) I tend to copy/rsync home directories. But in many cases most data I care about is "in the cloud" (so I have washed my hands of responsibility of its safety - now is that a good thing ???).

What does interest me though is all the many ways that specific server apps demand they be backed up. Isn't that annoying for operations people? They need to have DBA/specialists for every single app to know how to back it up, each has their own process.

This is silly and not sustainable, thankfully modern filesystems can help. When you think about it, it is obvious. A backup really needs to help you out with 2 things: 1) allow you to recover in the event of a disaster of some sort - so you go back as recently as possible and continue processing. and 2) go back to a point in time.

File system snapshotting (via ZFS, or using virtual machines, whatever) seems good enough for most of this (#2 can be a bit of a problem - you need to keep sensible snapshots frozen in time, and be vigilant to watch out for data corruption inside an app - having versions of data inside an app can help this, but this is then not an IT infrastructure issue, no generic solution can help).

Certainly a whole lot less hassle for IT if they can just reset elements of infrastructure back to how they were at a single point in time. Everyone wins.

Poor mans lambdas

A lot of my recent work has been in scala (I try to do any "green fields" work now in scala) so closures/lambdas are very pretty and flow freely in scala.

I did however read with interest about "lambda4jdt" a way of making code in java "look like" it is using a real lambda, but only really as a UI trick in eclipse. Interestingly I recall Cedric Beust talking about this previously (that is, the idea that IDEs can change the appearance of code from the underlying character stream).

Lambda 4JDT:

So screw the dead JLS (Java Language Spec), just go an add it in as low cal eye candy ! I like it !
With some excitement I went to IntelliJ's bug tracker to put in a similar feature request (I always struggled to explain what sort of "code folding" I wanted). I found out in a matter of minutes the feature is coming in IDEA 9 ! Nice !

In early versions, they used an actual lambda character:


(apparently it won't be exactly like that in the final version).

In any case I prefer scala in almost all ways, but for existing/legacy code, nice to have smart IDEs to present things as they should be.

MySQL developers denied .au visas due to local competition

This is madness: http://blogs.mysql.com/kaj/2009/01/12/on-open-source-and-open-competition-in-a-not-so-open-world

Very disappointing.

Reading old code

I am mostly terrible at reading old code, ESPECIALLY my own. I sort of stare and curse at it for a while, eventually it makes sense. Normally having runnable unit tests make it much easier.

However, I found some old ruby code of mine (a pre-historic simple rule engine, using YAML as the syntax - called "ruby rules"), and strangely it made sense (and I swear I have no recollection of writing it):

- rule: Foo
 set: Driver, Vehicle
 if: driver.age < 21 and vehicle.high_performance
 then: reject application



And a programmatic rule:


#now lets  try it out
rule = Rule.new :declarations => ["a", "b"],
               :types => [String.class, String.class],
               :condition =>"a == '42' and b == '42'",
               :action => "puts 'PASSED RULE 1'"

So what does this mean? I guess people smarter then me are right - ruby is a really friendly language. At least following the popular conventions for it leads to code that you could read well into the future (even without the comfort of static type guarantees).

OSDC slides/presentation details

I just got back from OSDC and my slides are up on slideshare.