ØreDev 2009 Wednesday

This post is a summary of my impressions from the first conference day of ØreDev 2009.

If you’re looking for write-ups of the other two days, go here:

Marc Lesser, “Accomplishing More by Doing Less”

Marc Lesser is a speaker with an interesting background, having spent 10 years as a zen monk but also started and managed businesses. His talk started a little unusual, with 60 secs of meditation.

Lesser has expressed his thoughts in what he calls the Less Manifesto. The manifesto is basically saying that if we have less fear, assumptions, distractions, resistance, and busyness we can focus on doing more of the things that really matter to us.

I liked how Lesser expressed that he, as a boss, was responsible for all his employees – not the reverse, which is common in management echelons.

My personal reflection was that all in all the talk was maybe not as mind-blowing as one could have hoped, but a pleasant and interesting way to kick off the conference.

Joris Kuipers, “What’s New in Spring 3.0”

This talk was basically a run-down of features of the upcoming Spring framework 3.0. Since I am hardly a power user of Spring, my impressions are a little sketchy.

So, what’s new? Configuration annotations has been possible for a long time, but they have been extended with new annotations. Also, there is work on the JavaConfig project, where you may configure your system using code. Also, there is a new Spring EL, an expression language how to use values from other places, e.g. properties files.

Another big thing is improved support for integration tests, by making it easier to build the context for the tests. Spring already has its own test runner and tests can transactional tests.

Spring has added support for REST, or JAX-RS “Spring style”. For example, they have included a HTTP method conversion to enable the use of PUT and DELETE.

I should also mention better support for embedded databases like Derby.

Douglas Crockford, “JavaScript – the Good Parts”

Douglas Crockford is a famous programmer, one of the 15 selected programmers in the book “Coders at Work”. He is the founder of JSON and has written a great book himself about JavaScript.

This talk was basically a personal characterisation of JavaScript, both the good and the bad. JavaScript (JS) is a language of many contrasts. It has some catastrophic flaws as well as brilliant design ideas. It is programmed by everyone from non-programmers to experts. Everyone seems to think that they can use JS without learning, which is strange for a programming language. Another factor is that if you want to program in the browser environment you have no other choice. It may not be what we want but that’s just so. Often when people complaining about JS, the are really annoyed with the DOM. But it’s not all bad. JS succeeded where Java failed miserably.

Crockford described some of the really bad stuff in JS, e.g. global variables, semicolon insertion by the compiler, and fake arrays. From C it has inherited some awful stuff: blockless if statements and expression statements, for example. Crockford gave a wonderful explanation of why curly braces always must go on the right side in JS. If not, a series of unfortunate design decisions may conspire to totally change the meaning of some code without any visible error. Crockford has written a tool that checks for these things called JSLint.

So, what’s good about it? Most people don’t realise it implements lambdas, anonymous functions. The language supports dynamic objects that can change behaviour. Also, loose typing and object literals where mentioned on the good side.

Klaus Silberbauer, “User Experience – Because Nothing Else Really Matters”

Klaus Silberbauer is a “Concept Director” from Creuna, DK. In his talk, he described his model of UX and how they work with UX at Creuna.

One insightful comment he made was that UX is nothing that can stand on its own. It has no value until it is implemented. Another was: Users don’t think – they feel.

Towards the end, Silberbauer presented a contrasting model to Jesse James Garrett’s famous UX model, which included more than design.

Andres Almiray, “Java Testing in the Fast Lane”

This was a talk about testing Java from Groovy. Groovy is a dynamic language on the JVM and is “98% Java” (a few things are missing, like inner classes).

Groovy is excellent for testing Java code. For example, Groovy has assertions built in. You can mock nicely with closures and construct DbUnit tests with compile-time checked XML data set. BDD tools he recommended were Easyb and Spock. Almiray also recommended FEST for testing Swing UIs.

Petri Haapio, “Agile Adoption at Enterprise Level”

Petri Haapio told us some tales from the agile adoption at Nokia Networks (about 14 000 employees) with clarity and truthfulness. He was part of a task force called “Flexible R&D”. They constructed the so called “Nokia Test” for determining the agility of their teams. He noted that this was only to be used as a base for discussions, nothing else. Bas Vodde and then Craig Larman were brought in as external experts.

The adoption was based on volunteering, information sharing, and hands-on coaching. It very much seemed like a bottom-up approach. He said it took 18 months before anyone in the top-management team knew about the transition. Some severe impediments he mentioned were the needed change in management culture and the tool department, trying to enforce poor tools for the job.

Today, ca 60% of all product development efforts use agile methods at Nokia Networks. The biggest product group doing agile contains about 600 people and is developing embedded software. Haapio also presented a study showing that the more agile the more people were satisfied with their work life.

Stuart Halloway, “Clojure”

Clojure is one of the new language kids on the block. It is a Lisp derivative with great Java integration and some interesting concurrency solutions. Stuart Halloway has written the first book on Clojure. Stuart is an energetic and very witty guy. Just one funny idea from this slide: He had prepared and marked particular slides suitable for tweeting with a little bird in the corner.

His motivations for using Clojure were these:

  1. Java interoperability. In sugared form it contains less parenthesis than Java so don’t worry about that.
  2. Lisp. The language is homoiconic, which means that the language itself can be expressed as data structures of the language. Thereby, very powerful meta programming is available. Clojure also contains a very useful feature called “destructuring”, which means data structures can be taken apart directly by the function args.
  3. Functional language with higher order functions (functions that take functions as arguments or return values). Some common Lisp operations have been renamed. For example, “car” is called “first”, “cdr” is now “rest”. Heresy for true lispers, but very logical in my view.
  4. Concurrency/State. Data is immutable by default. Mutable data must be changed in STM, Software Transactional Memory. One interesting idea was that the data becomes the contract between parts of the system (not the operations). This may sound fragile but its not, since the data transformation operations in Clojure are so powerful and fast.

In perhaps the quote of the day Stuart called Design Patterns “essentially a turd that could not be abstracted away”.

4 thoughts on “ØreDev 2009 Wednesday

  1. Pingback: ØreDev 2009 Thursday « Den bloggande terriern

  2. Pingback: ØreDev 2009 Friday « Den bloggande terriern

Comments are closed.