17 things I learnt at QCon London

1: I used to be 4th order ignorant, but now I’m always 3rd or better

Putting the “re” into Architecture, Kevlin Henney

According to the five orders or ignorance, 4th order ‘meta-ignorance’ is to lack knowledge of the five orders of ignorance (broadly equivalent to the Rumsfeldian “[un]known [un]knowns”).

2: Elegant and simple EIP implementations are possible with Apache Camel

Take a ride on Camel, James Strachan

I was particularly impressed with the Scala DSL, where, for example, to read messages from a queue, and post them to three load-balanced RESTful services:

"apachemq:events" ==> {
    loadbalance roundrobin {
        to ("http://eventHandlerA")
        to ("http://eventHandlerB")
        to ("http://eventHandlerC")

3: I am both a software engineer, and a craftsman

Craft and Software Engineering, Glenn Vanderburg

This is because, unlike other engineers (structural, chemical etc..), I both design and build the product (working software). Although, this is increasingly true of other types of engineering (electrical, mechanical) because of increasingly advanced software and production techniques using CAD tools. So (my conclusion), according to this metaphor, either I’m still just an engineer, or all engineers are now craftsmen. Whether or not it affects this argument, I did like the quote:

Programs should be written for people to read, and only incidentally for machines to execute. – “Structure and Interpretation of Computer Programs” by Abelson and Sussman

4: Until recently, Twitter received, on average, more updates to the social graph than tweets

Data Architecture at Twitter Scale, Nick Kallen

That is, counter-intuitively, there were more ‘follow’, ‘unfollow’, ‘block’ etc.. events in total than tweets. As these social graph updates represent CRUD-like behaviour with strict consistency constraints, whereas tweets are mostly append-only with only eventual consistency required, handling these events makes a significant contribution to the complexity required to scale Twitter.

5: New Zealand is Facebook’s Guinea Pig

Scaling the Social Graph: Infrastructure at Facebook, Jason Sobel

Often when Facebook release a new product or service, they will release it to a restricted geographical area to verify it’s scalability, popularity, etc… using a system called GateKeeper. Presumably New Zealand serves as a good test bench as it is an affluent area with a relatively small population, and more accurate GeoIP because it’s an island. Interestingly, I once heard that chocolate bar manufacturers do the same thing (NZ only) to trial new bars on the international market.

6: Encapsulating your domain model in a API encourages simplicity

Why I Chose Mongo DB for guardian.co.uk, Matthew Wall

Using MongoDB encouraged the Guardian team to reduce the complexity of the domain model, such that it could be simply expressed in an extensible API (an API that can mutate over time without breaking compatibility). This was achieved by modelling the API at two levels:

  1. Property groups, which change infrequently and adhere to a contract
  2. Properties, which are not prescribed, allowing the simple addition of properties over time


"user": {
    "publicFields": {
        "username": "2346247"
    "privateFields": {
        "postCode" : "N11GU",
        "country": "United Kingdom"

7: Using more memory for Java applications increases performance, even if they don’t need the extra memory

Performance Tuning for Java Applications, George Barnett

George had compelling data showing up to 28% reduction in response time for average load to Jira from http://jira.atlassian.com when attempting to ‘drown’ the JVM with larger and larger heap sizes. The basic rules of thumb were:

  • Larger heap = better performance
  • Diminishing returns as more memory is provided. Most improvement comes from first doubling of the heap size above the required size

The explanation was that the GC uses different memory allocation strategies if more heap space is available. If there is plenty of space, these strategies are more efficient.

8: Functional languages are ideal for building elegant web frameworks

Clojure & the Web, Glenn Vanderburg

The functional paradigm complements the fundamental function of the web: read text in, write text out. Also, lazy evaluation allows for elegant solutions to building web frameworks in Clojure, as demonstrated by Compojure and Ring, where the flow of the application does not have to be controlled to ensure efficient operation.

9: You can wrap up a web-app so it looks like an app, with PhoneGap

HTML5 and the dawn of Rich Mobile Web Applications, James Pearce

James said we’re currently at 1995 on the mobile web (e.g. app stores = yahoo website index). We’re in the slightly bizarre position that in order to create a ‘app’ that’ll sit in the AppStore, Market etc.. it has to be wrapped up in a customised container so it can pretend to be an ‘app’. This is because we haven’t got sufficiently user-friendly solutions to discoverability on the web.

10: One-way package dependencies can be enforced with Maven and SonarJ

Where Did My Architecture Go? Preserving software architecture in its implementation, Eoin Woods

Enforcing dependency rules on a Java project such as ‘package A’ can access ‘package B’ but not vice versa is possible with a number of tools such as JDepend, Macker and SonarJ. SonarJ allows integration with Maven to enforce rules and indicate allowed exceptions to rules.

11: Fail fast: Always build pretotypes before prototypes

Innovation at Google, Patrick Copeland

Where ‘pretotype’ is a displeasingly poor shortening of another imaginary word: ‘pretend-o-type’. It’s a word for a prototype that is as simplistic as possible, such as a piece of cardboard instead of an iPhone, or a person-in-a-box responding to voice commands, instead of text-to-speech software.

12: Handle what you can, but let someone else handle the rest (in Erlang?)

Let It Crash… Except when you shouldn’t, Steve Vinoski

As a refinement of Joe Armstrong’s ‘Let it crash’ philosophy, as applied to Erlang, this should not be taken as an excuse to remove all guards or defensive programming techniques from your code. You should not be afraid to let the system crash when the error is outside of your control, but foreseeable problems should be accounted for (e.g. legitimate network failures). It seems to me that the presence of Erlang’s ‘heart’ process makes this approach more appropriate than with other languages or architectures.

13: Being in an environment where everything ‘just works’ liberates developers to write great software

Better is Better, Steve Freeman

In a environment where administrators lighten the work load, operations provide robust platforms and developers have ready access to the necessary technologies, developers can focus on producing quality software. However, to achieve this takes a constant effort; always working towards that which is ‘better’.

14: Not everything on Mars that looks like a winking bunny is always a winking bunny

Innovations and Integrations: Applying trendy technologies to NASA Mission Operations Planning, Mark Powell

Sometimes it’s a tiny fragment of air-bag material ripped from a lander module that, when highly pixelated and cycled through the three colour layers, looks like a winking rabbit.

15: NoXML Spring is ready (except JPA)

Spring 3.1 and Beyond – Themes & Trends, Juergen Hoeller

Following on from @Configuration in 3.0, with the addition of @Profile (environment-sensitive property profiles) and abstracted configurable caching support, NoXML Spring is increasingly viable.

16: The Earth is an ellipsoid

Unifying the Search Engine and NoSQL DBMS with a Universal Index, Jason Hunter

Unlike most things in MarkLogic, geo-location queries cannot be solved entirely through the use of indexed term-lists. XML structure, free-text search and range queries can.

17: An inverse relationship exists between use of IBM productivity tools and productivity

Scaling Lean & Agile, Craig Larman