Go to content

GOTO Amsterdam 2011 Conference — day 1

Published on

The GOTO Conference came to Amsterdam and its wide variety of subjects (Java, JavaScript, HTML5, Agile, even .Net) made me decide to spend a part of my training/conference budget I get from Hippo.


The day started with the usual registration and goodie bag, which is a goodie by itself because it’s a laptop bag. I arrived just in time for the keynote about the buzz of the month: Google’s Dart. Dart combines the advantage of loose typing and extensions of JavaScript with the readability of object oriented languages like Java. You can define a variable with

var x;

or with

Person x;

It’s a matter of what you prefer. In the end you can create JavaScript from your Dart code so they have to support JavaScript syntax anyway, but it’s not the only platform Google wants to support. Dart comes with its own VM and I can imagine they’re going to use it for native applications for Android or ChromeOS. Dart was a good starter to continue to the next session about the future of front-end development. It was a combination of extending CSS to support variables and reusable mixins, defining your own HTML elements and scripts. Yes it is extremely useful to support parameters for e.g. color codes which saves a few look-ups and makes it easier to replace your colour scheme. I have my doubts about creating new HTML elements. Not everyone will use the latest Chrome version, but I can understand Google wants to dominate the browser market (who doesn’t).

Lowering risks

Independent from each other, my colleagues, the scrum master at my customer and I went to go to Jez Humble’s talk about lowering risks. His main recommendations were that everything must be under version control (also the configuration), testable (TDD!), repeatable (how fast can you build up a server if the data centre burns down) and make your release cycle easy to roll back. This can either be done by rolling out the release on a limited amount of machines and let a part of your visitors go to the new version while the vast majority goes to the proven current version. I think this works indeed great for large scale sites like Google, Yahoo, Amazon, Twitter, but most sites here in NL don’t have 100+ machines running. Another recommendation is "if it hurts to release, do it more often". The idea is that you get more experienced and if the release process it hard, you start to make it easier e.g. by scripting or fixing the setup if you have to do it more frequently.

Spring 3.1

The configuration of Apache Rave is Spring based, so I was interested in what’s new in Spring 3.1 which will be released "soon". Spring 3.1 now supports profiles so you can define a certain set of configuration is for local development, while another set is meant for deployments on your (production) server. You may want to have a database setup that creates a schema and populates it with a predefined data set on your local machine, while you don’t want any automated changes in the database schema or data on production. Some of the code behind the WebMVC framework has completely been rewritten, but it’s configurable to use the old code. Very useful @Consumes and @Produces annotations are added to define for which content types the handlers were meant. Now you can easily create separate handlers which are specificly meant for JSON or XML.

Modular JavaScript

Despite the slides in Comic Sans, Karl Krukow came with a good demo of how to develop your JavaScript in a modular setup, but to have an optimized, single output in the end. If I find time in the recent future, I definitely want to try Closure. I too have seen projects grow to a mess where you end up calling 10+ different script files and you have no clue if you still use them.

Java 7

In 2008 I went to the "what’s new in Java7" talk at Devoxx. It took Sun & Oracle another 3 years to actually ship Java7 so I was curious to see Java7 in action. The multiple catch was planned, dropped and eventually made it to Java7. You can now catch multiple exceptions in 1 statement or catch their common ancestor to have a single block of logic, but throw only the caught (checked!) exceptions. If you get a nested exception, because the code in the catch or finally throws another exception, you can add it as suppressed exception to the exception so it will appear in the log. A very useful addition I hope I don’t have to use 🙂 We also got to see some advantages of the java.nio package, such as self closing streams and simplified IO copy functionality if you weren’t using Commons-IO for that.

Testing Android apps

The last session I attended before the closing talk of the day was about testing Android applications. The rendering of the application can be different among the Android versions or vendors. They showed how they were testing by using real Android devices that were actually being rotated to reliably test the orientation. My conclusion that dealing with different IE is easier than native Android apps.

Closing talk

The day was closed by a very experienced developer who talked about why companies failed (or succeeded). The main conclusion is that you have to keep innovating, because your current cash cow will be obsolete sooner or later. He came with some good examples of companies that had a successful product but refused to innovate and went broke in the end. Competitors that initially targeted a slightly different market with a comparable, but cheaper and inferior product, did innovate and eventually took over the high end customers. So keep innovating!