Erik Dörnenburg, ThoughtWorks

Erik Dörnenburg is an application architect and developer at ThoughtWorks Inc., where he is helping clients with the design and implementation of large-scale enterprise solutions. Building on his experience with J2EE, Microsoft .NET and other environments, Erik is continually exploring new patterns of enterprise software.

Before joining ThoughtWorks Erik was Technical Director at Pixelpark UK, a new media company, where he integrated enterprise systems with web-based solutions and a variety of digital delivery channels. His career in enterprise software began in the early nineties on the NeXTSTEP platform and Erik has been an advocate of agile, test-driven, object-oriented development and Open Source software for many years. He holds a degree in Informatics from the University of Dortmund and has studied Computer Science and Linguistics at the University College Dublin.

Presentation: "Software Visualization and Model Generation"

Session: Lean and Agile Software Development

Time: Thursday 16:30 - 17:15

Location: Ballroom Le Grand 1

Abstract: Models are often viewed as something you create during design time and use to generate code. What if we turn the approach up-side-down and generate models from code? Humans are very good at recognizing patterns in images, making visualizations a valuable tool, for example to recognize dependencies or data flow. This is particularly true for dynamic, loosely coupled systems that are often less explicit and evolve over time. Once you have generated a model you can take things a step further and run checks and validations against it. Visualizations can also be used to plot out source code metrics over various dimensions to detect potential ?hot spots? in the application that may require special attention. This talk applies the concepts of visualization and model generation to a broad range of usage scenarios, such as asynchronous messaging, software components and object-oriented applications.

Presentation: "Keynote - Simplicity in Design"

Time: Thursday 17:30 - 18:30

Location: Ballroom Le Grand 3

Abstract: The problems we are looking to solve with software are becoming increasingly harder and more complex, but how do we best deal with this complexity? Martin and Erik will argue that the answer is simplicity. More than twenty years ago Fred Brooks identified accidential complexity, that is complexity that is not inherent in the problem but is caused by the approach we have chosen, as the only area left where significant gains in productivity could be made. So, if we manage to achieve simplicty in design and approach we can successfully tackle the real complexity of the problem we are solving. What we have seen, though, is that it is anything but easy to achieve simplicity. All too often we end up with designs that are either too simplistic or too complicated. The real skill in designing software lies in finding a good middle ground.

Presentation: "New Frontiers Panel Discussion"

Session: New Frontiers 2

Time: Friday 11:15 - 12:00

Location: Ballroom Le Grand 2

Presentation: "Software quality - you know it when you see it"

Session: Professional Practices

Time: Friday 15:30 - 16:15

Location: Ballroom Le Grand 3

Abstract: Software quality has an obvious external aspect, the software should be of value to its users, but there is also a more elusive internal aspect to quality, to do with the clarity of the design, the ease with which we as technologists can understand, extend, and maintain the software. When pressed for a definition, this is where we usually end up saying "I know it when I see it." But how can we see quality? This session explains how visualisation concepts can be applied at the right level to present meaningful information about quality. Different visualizations allow us to spot patterns, trends, and outliers. In short, they allow us to see the quality of our software. The tools and techniques shown are easy to apply on software projects and will guide the development team towards producing higher quality software.

Workshop: "Test Driven Development"

Time: Wednesday 09:00 - 16:00

Location: Concorde

Abstract:

This tutorial demonstrates the development of a small example application using test-driven development and related technologies. The system will comprise a handful of Java classes that exemplify typical components found in enterprise applications, including domain objects and a service layer. The tutorial is structured into three ‘iterations’ which cover

state-based testing with JUnit
interaction-based testing with JUnit and jMock
deployment in lightweight containers such as PicoContainer and Spring.

The iterations not only introduce the concepts but also provide room for the discussion of trade-offs and edge cases, e.g. how to deal with testing private methods and when not to use dynamic mocks but fake objects. The implementation will make use of the Dependency Injection pattern and the last iteration examines how this is supported by lightweight containers.

Attendees gain an understanding of how proper use of test-driven development fosters good design; through decoupling and interface discovery for example. Attendees will also gather a nice catalogue of the most commonly used patterns used in conjunction with test-driven development.