33rd Degree Conference - day 1

Thanks to my company, I was able to attend 33rd Degree conference in Kraków a few weeks ago. It was 3 days of great fun & enormous profit (my knowledge growth). Looking at the agenda I didn't suspect it will be such an awesome event.
Let me summarize the talks I attended to and maybe some insights I gained.

Twitter : From Ruby on Rails to the JVM by Raffi Krikorian

Opening keynote brought some impressive numbers about Twitter: each tweet causes emails being sent, Blackberry/iPhone/whatever pushes, resulting in 2.5E9 deliveries/day. After this introduction Raffi explained how Twitter, initially a RoR application ended up migrating some parts to the JVM. It turns out that at their scale Ruby's performance was definitely not sufficient. In their search for better performance they turned over to the JVM, but didn't pick its flagship, Java, as their language of choice. Instead, they picked Scala which felt more familiar to developers used to Ruby (they are also using Clojure in some parts!). Additionally, JVM's concurrency model was what they needed (seems that concurrency in Ruby really sucks).

However, it turns out that out-of-the-box JVM was still not perfect for the real-time, massive scale application that Twitter is. Twitter applications are running on custom JVM builds, having custom garbage collection. Ugh, that seems like challenges that would really scare an average developer. I'm glad I know how others are approaching those issues so I can keep calm if  I ever face such problems.

Next Raffi gave us a short introduction to Finagle, Twitter's framework for protocol-agnostic RPC, handling a lot of issues for developers: retries, connection management, transient error handling, load-balancing, distributed tracing, service discovery etc. Code samples looked really nice, with concise Scala syntax and all issues not directly related to the business logic hidden by the framework (which doesn't look invasive at all).

What I found interesting is that at the end Raffi stated that the fact they migrated from RoR to JVM doesn't mean that picking RoR in the first place was a mistake. With RoR you can get your application working really soon, and if you find out you need to scale to the point it's not enough you can look for alternatives. And that's the way he'd suggest startups to proceed.

I really enjoyed the talk, but felt a bit sad that I don't get to deal with such large scale problems in my work.

Complexity of Complexity by Ken Sipe

Next keynote was less technical, but interesting nonetheless. Some of the things discussed were already well known for me, such as the difference between essential and accidental complexity but Ken also offered a great number of advises really worth remembering. As he says, many things (idempotency for example) seem are hard for us to understand just because we're not familiar with them. Therefore it's hard to say that some programming language is easy and another one is hard. He stated (it was some quote IIRC) that you should pick up the most powerful language of those available and suitable for the problem at hand. Doing otherwise is a mistake. 

Ken also mentioned CAP theorem and shared some lessons learned by eBay developers such as embracing inconsistency and minimizing and controlling dependencies. He talked about the wise choices they've made - keeping the core business components highly available and the non-core only mostly available. Such trade-offs should be made to do the right thing and not waste resources on problems that you don't really have to care that much about. That's something people tend to forget or ignore and try to solve every tiny problem (ignoring the ROI).
I really liked one of the last sentences in the presentation: it's better/cheaper to develop product with good people than with cheap people.

Pointy haired bosses and pragmatic programmers: Facts and fallacies of software development by Venkat Subramaniam

I never before seen Venkat live. I have seen some of this talks online, but that was quite long ago and I didn't exactly remember what I should expect. The presentation was awesome. Venkat is a true rockstar and an awesome speaker, able to get your attention even if he doesn't say anything really new. He started with comparing software development to surfing - unpredictible, dynamic and really fun (but beware the sharks!). He offered a simple advice how to win software projects - with passionate, competent and responsible people because the thing that affects us most is the people (like Romans affecting the diameter of rocket boosters). Also we got warned of best practices (and advised to run whenever we hear those words).
Of course, as the title of the talk suggests, Venkat also went through a list of fallacies of software development:

• More money and time will solve our problems (In fact, it turns out that projects with far deadlines and huge budgets tend to fail). I have already experienced it.
• It gotta be good because it's from that large vendor.
• Dynamic languages aren't safe (yeah, and Java's static type system is - riiiiiight - about as safe as a monkey using a computer)

A few memorable, fun and/or inspiring quotes from Venkat:

• "Standardization before innovation is a bad idea"
• "One thing you should never do is arguing with Java compiler"
• "Don't fear to try new things, to make mistakes, to push the boundaries"
• "A professional who doesn't learn to fail, fails to learn"
• "Be unemotional in technical decisions, give things unbiased consideration"

Venkat finished his great show with a really good quote from Robert F. Kennedy, a quote every software professional should know (and agree with):

“Every time we turn our heads the other way when we see the law flouted, when we tolerate what we know to be wrong, when we close our eyes and ears to the corrupt because we are too busy or too frightened, when we fail to speak up and speak out, we strike a blow against freedom and decency and justice.” 

Howgh!

Build trust in your build to deployment flow by Frederic Simon

This talk was a bit disappointing for me. First, I arrived late because we wasted a lot of time waiting for our pizza in a nearby fast-food (for some unknown reasons we got reservation without lunch at the conference...). Then, the part of the presentation I've seen seemed to be an ad for Artifactory. The only thing I've learned from the talk is that Artifactory looks like a far more sophisticated tool than Nexus we're using at the company (which only seems to have a really slow search capability).

Non blocking, composable reactive web programming with Iteratees by Sadek Drobi

Being unsure what to do next I decided to take a look at Play framework. The presenter warned us at the very beginning that he was badly jetlagged - and that was clearly visible, but I enjoyed the presentation. Scala's (which is the language Play 2.0 is written in) syntax seemed nice again, and the way that the framework handles chunks of data looks interesting. A short demo of the Typesafe Console made me go really Wow! I guess the talk convinced me to take a look at the framework when I get some spare time (and take a look at many other, even more interesting things first).

Every rose has its thorn : Taming the automated tests beast by Wojtek Seliga

For this talk the room was overflowing with people. Wojtek is a leader in one of the Atlassian's Jira development teams and shared with us his experiences related to automated tests. Atlassian developers are serious about automated testing and Jira has an enormous tests suite, from unit tests to functional to integration tests using HtmlUnit to Selenium tests. The whole suite is about (if I'm not wrong) 13k tests that take an awful lot of time to run, slowing down development and causing fear of committing code (with distributed teams in different time zones, when a build broken by one team can prevent other teams from doing anything useful).

The presenter was very honest and clear about the mistakes they've made, such as putting all tests into a single project (actually a project per type of tests - unit/functional/etc) which makes the feedback loop extremally long. He shared a tip how to make their integration tests (going through the web UI) easier to maintain using what he called Page Objects (objects exposing actions you can take on given page but  hiding the ugly details of parsing HTML etc from the test itself).

The presentation was really awesome but it unfortunately ended with a sad accident involving a really ugly troll who came out shouting that Jira guys don't know how to write tests at all. When asked what would he do differently he yelled that we'd change the job if he were them and he left. Every time I saw him rising hand on different presentations later on I was expecting another flame but luckily it didn't happen. I regret I couldn't find traces of the troll online (though I remember his name well) - I would like to know where he works (if at all) just to be sure never to join such company ;)

Summary of day 1

If I had any doubts about coming to the conference before, they were all gone after the first day. It was a great experience and learning. I've spent the evening (up to late in the night) discussing what we've learned with my colleagues who were there with me.

(Oh, yeah, there was the beer party sponsored by ZeroTurnaround but as I don't drink beer it wasn't something I could get excited about.)