I attended YOW! Sydney 2014 and thought some people might get something useful out of my notes. These aren’t my complete reinterpretations of every slide, but just things I jotted down that I thought were interesting enough to remember or look into further.
Gojko Adzic (@gojkoadzic) spoke about the trouble of aligning strategy and the desired impacts of projects with the implementation of the software.
Palchinsky Principles
He spent some time discussing the Palchinsky principles, from Russian engineer Peter Palchinsky as documented in Tim Harford’s book ‘Adapt’.
The principles, intended to guide the development of innovations, are:
- Variation: We should seek out new ideas and try new things.
- Survivability: We should do things on a scale where failure is survivable. (This is why stories should be small. Not so that we can finish them in an iteration, but because they might be wrong.)
- Selection: We should seek out feedback and learn from mistakes.
Jez Humble (
Martin Thompson (
A couple of weeks ago, I went along with a couple of other Tyro software engineers to hear 
I didn’t think anyone would seriously ask this question. However, after yesterday’s post about 
A colleague and I were writing a test in Java today and I had one of those “I can’t believe it takes this much work to write this stupid function” moments. If you do any Scala programming but still do a lot of Java programming, you’ll know exactly what I mean. I’ll walk you through a mock of what we were doing and you can see why Scala just pummels Java when it comes to expressiveness. (Early warning: do not use the word “expressive” when trying to convince your manager to let you use Scala at work.) 
The funny thing is that lambdas don’t, by themselves, do anything new. They’re just a succinct form for turning a block of code into an object that can be passed around – syntactic sugar. Some of us have been doing this for a while without the succinctness and we call it… object-oriented programming! Yes, passing blocks of code (aka functions) around as objects (aka values) is also core to functional programming, but certainly not unique to it.
In order to achieve this, the plugin has to process a lot of data: it pulls all commits on the default branch for the last 2.5 years and analyses the content of every single one. I knew two things about this code in advance: first, there were going to be a lot of steps to go from a repository name to a leaderboard of the most influential committers, and second, I was pretty certain I’d need some multi-threading mojo in order to get it to perform in an acceptable time frame.