Conference Chair: Giovanni Asproni

Conference Committee: Event Manager: Astrid Byro Francis Glassborow Archer Yates Associates Ltd Paul Grenyer Threshers Yard, West Street Alan Lenton Kingham, Oxon. OX7 6YF Ewan Milne Phone: +44 (0) 1608 659900 Roger Orr Fax: +44 (0) 1608 659911 James Slaughter Email: julie at archer‐yates.co.uk

Keynote speakers announced In 2010 we'll have yet another exceptional line‐up of keynote speakers:

• Jeff Sutherland, co‐inventor of Scrum • James Bach, well known tester and author of "Lessons Learned in Software Testing" • Dan North, Agile coach, software developer and the inventor of Behaviour Driven Development • Russel Winder, consultant, author, and expert in parallel and distributed systems.

As usual, there will be a set of pre‐conference tutorials which will include:

• A Certified Scrum Master Course taught by Jeff Sutherland and Gabrielle Benefield (two days 12 and 13 of April) • A one day tutorial on the D programming language by Andrei Alexandrescu and Walter Bright • A one day tutorial on testing by James Bach

Sessions

5 Steps to Kanban (Karl Scotland)

90 mins A Kanban System for Software Development provides an alternative means of creating an Agile Development process using Lean Thinking. Creating a Kanban System is not as simple as adopting a previously defined process as a starting point. Instead, a team needs to come up a model of its own process which will form the basis for further continuous improvement. This talk will introduce 5 steps that a team can use to create their own Agile process using a Kanban System for Software Development.

A Simple Matter of Configuration" - how can we tame the complex world of configuration? (Roger Orr)

90 mins Configuration is a vital element of many programs. However it is often hard to get configuration right, leading to people wasting time and programs that do not work correctly. In my experience explicit discussion of design options for the configuration of a program is rare and, all too often, the choice is made arbitrarily. I believe that looking at the usage patterns of the program early on helps to pick the best method(s) for configuring it and hence reduce the cost of problems caused by configuration issues. Configuration is a complex subject and there doesn't seem to be an obvious single solution that works in every case, but we can try to fight against the common 'anti‐pattern' of using multiple, unrelated, configuration techniques at the same time. I will look at some of the issues surrounding configuration; firstly by trying to answer the "six key questions" (who, why, what, where, when and how) for this subject to help understand the size of the problem and the forces at work.

ACCU Conference 2010 April 14‐17, 2010. Barcelo Oxford Hotel, Oxford, UK 1 of 30 I'll then sketch out some possible design patterns and look at their trade‐offs and interaction with the intention that I (and you) can reduce the pain of getting programs working in different environments by making more informed and deliberate decisions. I am looking at the problem in the general case, using examples from various problem domains, and expert knowledge of a particular language or API is not assumed.

A Year of Misbehaving - A Retrospective on using BDD in a commercial enterprise (Mauro Talevi)

90 mins So you've heard about Behaviour‐Driven Development (BDD) and you're intrigued. You think it might just work but only in a very Agile environment. You ask yourself if it could work in a realistic commercial enterprise. We've done just that for the past year: we'll present a retrospective on using BDD on a high‐profile project in a global corporate bank. We'll share the lessons learnt, including what worked well and what could be improved. We'll also introduce BDD and JBehave for Java‐based development environments. Outline:

• Introducting BDD • Introducting JBehave for Java‐based development o Using with IDE o Using with CI o Using with Web Runner • Introducing the Case Study o A Java enterprise project in a global corporate bank o Greenfield project in a non‐Agile environment o Extremely volatile market conditions • What worked well o Communication with business and specification of acceptance criteria o Adapting to rapidly changing priorities o Use of web runner for setting up and driving demos o Integration with development tools • What can be improved o Dealing with large datasets whose formats do not refactor easily o Finding the best form of outcome verification o Ensuring scenarios are written earlier in the iteration cycle o Avoiding unnecessary duplication of scenarios and steps • Lessons learnt

Abusive C++ (Jonathan Wakely, Richard Harris)

90 mins Time and time again we programmers have discovered that the clever tricks of yesterday are the maintenance nightmares of tomorrow, and yet still we are drawn, moth‐like, to the leet. In this session we shall describe a selection of our own clever C++ tricks, some of which we have learned to avoid, some of which have yet to burn us and some of which we have yet to use...

Adventures in QA (Dirk Haun)

90 mins In this session, we follow the adventures of a software developer who unexpectedly finds himself in the role of head of quality assurance. Hilarity ensues as worlds collide and our protagonist realizes he doesn?t even speak the same language as his new colleagues. This session will be exposing some of the gruesome details of real‐life software testing. Courses for testers and shiny testing tools are readily available, but how widely are they actually used, useful, or even usable? Is there a need for a "professionalism in testing" initiative?

ACCU Conference 2010 April 14‐17, 2010. Barcelo Oxford Hotel, Oxford, UK 2 of 30 Also, while testing is widely accepted as a necessity, it isn't always seen as an integral part of the development process yet. So we will be looking into this and related (ongoing) struggles with management and development. Lessons learned and a chance to exchange stories from the trenches will round off the session.

Analysing Large Data Sets - an introduction to MapReduce with Apache Hadoop (Gavin Heavyside)

45 mins Apache Hadoop (http://hadoop.apache.org) is an open‐source implementation of MapReduce, the algorithm famously used by Google to process large data sets. The Hadoop framework provides a reliable, scalable distributed environment for anlalysing massive amounts of data, and is used by companies from startups with a single server to Yahoo! whose largest cluster has 4000 nodes. I will introduce Hadoop and the MapReduce programming model, with a discussion of how the Hadoop framework helps you process massive amounts of data in parallel across many machines. The session will cover subprojects of Hadoop, including the distributed file system HDFS and the distributed database HBase. Hadoop is written in Java, but I will show how the Streaming library enables developers to access the power of MapReduce from any language. I will also introduce Pig and Hive, two subprojects of Hadoop that enable you to run complex queries using a high‐level query language (Pig) or an SQL‐like syntax (Hive). These tools enable ad‐hoc querying and analysis of large datasets, generating the appropriate MapReduce jobs for you.

Architecture Refactoring - Motivation, Approach and Patterns (Michael Stal)

90 mins For software engineers creating new code is one side of the coin ,while checking its conformance, sustainability and quality represents the other side. Adding new features is considered a creative act, whereas improving quality is rarely respected but often neglected. If problems are built into a software architecture, it will be the more complicated and expensive to get rid of them the more we postpone appropriate activities. One way to avoid such design erosion is to regularly apply architecture refactoring. Architecture refactoring extends code refactoring to also cover architecture artifacts. The tutorial will introduce the core concepts of architecture refactoring, introduce refactoring patterns, and differentiate it with re‐engineering.

Atomics for C++ (Detlef Vollmann)

90 mins C++0x will (quite probably) define "components for fine‐grained atomic access". This is one more mechanism to deal with concurrency in C++ programs, and it's considered a mechanism "for experts only". Of course every decent C++ programmer considers himself an expert in concurrent programming, so they might consider to use these atomic objects and their operations. But there's a reason why these components are considered "expert‐level". Their use can have some pitfalls, they might not be as atomic as a naive user might expect, and they might generally not do what a user expects from them. This talk will present the C++ atomics and what niche in programming for concurrency they actually fill. Some examples on how to use them will be explained, and the talk discusses what programmers can expect from atomics and what not. Intended audience: This talk is for programmers and designers of projects that have to deal with concurrency and who consider using atomics. A good working knowledge of ISO C++ is helpful, but not required.

Automated Testing of a Medical Imaging Application (Jeff Kotula)

90 mins Virtual Radiologic Corporation (http://www.virtualrad.com) is a provider of 24/7/365 teleradiology service for thousands of clients throughout the United States, associated with numerous radiologists in the US and overseas. Several years ago we began a project to write our own radiology PACS (Picture Archiving and Communications System) application to

ACCU Conference 2010 April 14‐17, 2010. Barcelo Oxford Hotel, Oxford, UK 3 of 30 support and grow our core business. A key component of this system is an application used by radiologists to review medical images (e.g. CT, MRI, xray) for diagnosis. Given the mission‐critical nature of the software as well as the fact that it is under government regulatory control, we designed in a testing system and methodology that allows us to automate test executions and reporting through nightly builds. The automation system is built around a command‐dispatching mechanism rather than the typical event‐ simulation mechanism which provides a variety of advantages even above and beyond the testing uses. Our experience demonstrates that designing for testability yields huge dividends in practice. The case study will cover, briefly, the background of the application with a short demonstration of the types of functionality it supports, as well as an overview of the testing framework. This will be followed by an examination of the mechanisms (and code) that supports the command‐dispatching system. Examples of how specific test cases are constructed will be demonstrated, as well as an exploration of the test execution framework. Finally, we will look at the support for an automatically generated Requirements Tracability Matrix which is used in our FDA regulatory processes. Technologies employed: C#, .Net, Windows Forms, FIT, and NUnit.

Building the Testing Pipeline (Patrick Kua)

90 mins Automated testing is one of the corner stone practices for teams practising XP yet there are multiple levels of automated testing to understand. Combined with effective Continuous Integration, automated testing offers rich level of feedback, assuming you structure them in the right way. During this workshop, participants will better understand the tradeoffs you need to consider when looking at different levels of automated tests. Having learned these tradeoffs, participants will attempt to structure them in a way to maximise the speed and quality of feedback. We will then compare these with different examples from the real world to identify opportunities for improvement. Participants will plan out their logical testing pipeline using lightweight modelling techniques (i.e. index cards and sticky notes!) to keep everything language and tool agnostic. We will then run a second iteration over the plan, layering a variety of tools and libraries on top to understand what it would look like in the real world.

Change, change, change - the 5 year evolution of an Agile team (Paul Field)

90 mins Agile software development methods promise rapid delivery of valuable, high‐quality software to the business. Do the aspirations of the Agile Manifesto stand‐up in the day‐to‐day realities of an investment bank? How can you get the benefit of Agile techniques for your projects? In this presentation, Paul Field introduces the concepts of Agile software development and shows how a variety of Agile techniques have been applied over the last five years on his projects at Deutsche Bank. In those five years the demands on the team and the types of projects have changed dramatically. Learn how the process evolved ‐ what worked, what didn't and why.

Code Archelogy - stories from a real codebase (Olve Maudal, Jon Jagger)

90 mins Nothing beats a large codebase that have been worked on and cared for by hundreds of developers over many years, and that is still in good shape, and that can still be used to churn out one successful product after the other. We have studied such a codebase; we have analysed and commented on actual changes done by professional programmers over the years. In particular we have paid interest to the small refactoring tasks and code cleaning activities that seems to be needed to keep the codebase in good shape ‐ the small and "insignificant" changes that professionals do to avoid rot in the codebase. There will be a lot of C and C++ code in this talk. We will focus on the small details of code cleaning. Be prepared for tough discussions about what really adds value or not to a codebase.

Compiler Construction (Walter Bright)

90 mins

ACCU Conference 2010 April 14‐17, 2010. Barcelo Oxford Hotel, Oxford, UK 4 of 30 Compilers are fundamental to computer programming. Not only are fundamental programming techniques center stage in compiler design, but understanding how compilers are built will enable much more effective use of them. The Compiler Construction seminar is an intensive two day event in how compilers are built from front to back, by Walter Bright who has been building extraordinary compilers for 25 years. Registration is strictly limited to 50 attendees. With a single‐track, group‐oriented structure, and with meals planned for the group, you are assured plenty of intensive one‐on‐one interaction with the experts. Combined with your aims and experience, the deep and expansive expertise of our seminar leaders offers a unique opportunity for insight into compilers and software design.

CouchDB: can we be comfortable without SQL? (Guy Bolton King)

90 mins When building an application that has persistent storage requirements, many of us reach for a relational database. However, that's not what everyone has been doing: there are now a handful of alternative database architectures that have been loosely gathered together under the NoSQL banner. They are all intended to handle large amounts of data in a scalable way, both in terms of the amount of hardware needed, and in terms of reducing the the difficulty of adding new types of data to the existing data corpus. CouchDB is one of these: an open‐source document‐oriented database written in Erlang, it offers replication, scalability, fault‐tolerance, and queries written as map/reduce functions in more‐or‐less the language of your choice (although JavaScript is the main one). In this session, we'll run through the architecture of CouchDB, work through some simple examples of what can be done with it, talk about performance and finally, and most importantly, look at whether it's more fun to work with than SQL...

Coupling as resistance to change, understanding and fixing it (Tony Barrett-Powell)

90 mins Coupling, the number of things a unit of code depends on, is an important consideration when designing and maintaining software. Without due care a slow increase in coupling between units over a few releases of a software product, or even over a number of iterations within a release, can lead to software that is difficult to change, or worse results in a ripple effect throughout seemingly unrelated units. We cannot write software without some coupling, how else would the code achieve anything? Thus, coupling is not a bad thing in itself, it is the degree to which a unit is coupled to other units that can be undesirable, yet is not an absolute measure. Understanding of what coupling is, its many forms and how to recognise them is useful if we want to avoid unnecessary coupling in the software we create. It is important to control coupling in software if it is to be improved over a number of releases, as high coupling slows development, increases time to market and inevitably lost revenue. This session attempts to explore coupling in all its manifestations, examine the difference between good and bad coupling and to consider its bedfellow cohesion. The session will also explore the techniques used before, during and after the act of design which can be used to reduce unnecessary coupling and as an aside looks at those which can lead to increased coupling. The intent of the session is to arm those designing and writing software with the understanding and techniques to create loosely coupled and maintainable software.

Creating Proximity over a Distance (Jutta Eckstein)

90 mins Agility asks for face‐to‐face communication, trust and collaboration. Proximity can be created by travelling ‐ at least sometimes. Virtual communication channels provide another possibility overcoming the distance. But we should take the trust threshold into account which, once hit, will break an existing relationship. In this session I'll reveal, avoiding this threshold, how to know if you're approaching it and explain the options once reaching it. Moreover I'll cover the advantages and disadvantages of synchronous and asynchronous tools. And finally I'll clarify who is travelling, where to, and for how long.

Data warehouse, OLAP, Data Cubes, Business Intelligence - Buzzwords explained (Sven Rosvall)

45 mins

ACCU Conference 2010 April 14‐17, 2010. Barcelo Oxford Hotel, Oxford, UK 5 of 30 In the database world there are many buzzwords that most software engineers only hear about but never get experience with. This talk aims to clarify what lies behind some of these buzzwords and describe key differences from the more common transactional database. The talk will also provide enough insight for engineers to decide if any of these technologies are useful in their current or future projects. The presenter has work for many years on the periphery of the databases, wondering about these buzzwords. He eventually got involved with data warehouses and now wants to share his experiences with fellow engineers.

Database Testing Demystified (Sven Rosvall)

45 mins Testing databases is not as easy as unit testing of classes and functions. Databases are full of state and internal logics which must be set up before testing can start. There are also lots of dependencies that are difficult to isolate or stub out. This presentation will look at some techniques to create automated tests for databases and how to debug SQL code including single stepping stored procedures. We will automate database testing with the use of popular unit testing frameworks. We will test simple CRUD statements, calls to stored procedures and verify triggers. Test suites in Java and .Net will be demonstrated. We will also see how a database can be developed with agile methods. Databases are traditionally developed up front as the database schema is difficult to change later.

Defining Domain-Specific Modelling Language - Hands-on (Juha-Pekka Tolvanen)

90 mins Domain‐specific languages offer an opportunity to raise the level of abstraction to specify the solution directly using domain concepts. In many cases the final products are generated from these high‐level specifications. In this session we develop jointly a modeling language for a specific domain (such as medical device or interactive). We seek in collaborative group work for good design abstractions, capture them to a metamodel and define the language including constrains and concrete syntax. At the end of the experiential session we try the language to model some applications.

Developing Unit Tests for Multicore programs (Stephen Blair-Chappell, Will Stott)

90 mins Tools like JUnit and CPPUnitLite have helped automated unit testing become a popular practice in many modern software development projects. However, when developing multicore programs it is much more difficult to introduce such testing and related practices like Test Driven Development into a project. This is because adding parallelism into a program introduces new classes of errors which simply don't exist in the sort of single‐core programs that these practices traditionally target. We start our presentation with a short explanation of "What is Automated Unit Testing and Test driven development" and then try to answer the fundamental question "Where is the best place in the development cycle to test parallel code?". We also discuss different methods of detecting, tracking and testing for errors which are unique to mulitcore programs. Although, much of the work described here is implemented in C++ native code, many of the findings will also be of interest to programmers of managed code. The presentation is primarily aimed at people who want to know how automated unit testing might be introduced into their multicore development environment. Keywords: Unit Testing, Multi‐threading; Multicore; Multicore bugs; Parallelism; Test Driven Development; Agile Development

Encodings: Decoded & Demystified (Stewart Brodie)

90 mins This is an (much!) extended version of my lightning talk from the ACCU 2009 conference. What is a character? What is Unicode? Why should my program care? How can I make my program handle it? In this session, we will look for the answers to these questions and more. We will look at a few of the hundreds of available encodings: the ways of representing character data for processing, transmission and storage. We will examine the pros and cons of some of the encodings and look at the process of converting between different encodings, including UTF‐8, UCS‐4 and ASCII.

ACCU Conference 2010 April 14‐17, 2010. Barcelo Oxford Hotel, Oxford, UK 6 of 30 We'll look at some of the issues that arise when applying various types of processing to character data. How do we know that a given character is upper case? If it is, then how do we convert it to lower case? How do we know that a character is a numeric digit? We'll take a look at case conversion and string comparison. Once we know how to process the character data inside the program, how do we go about ensuring that we can display the character appropriately? We will look briefly at the terminology surrounding fonts, including typefaces and glyphs as well as covering the mechanisms by which a character is mapped to a glyph or to multiple glyphs and even how a sequence of characters may be mapped to a single glyph!

Enterprise Web Application Development in Java with AJAX and ORMs (Paul Grenyer)

90 mins Recently Java enterprise web application programming has been leaning towards a more classical J2EE approach. Traditional Java Server Page (JSP) programming, and even libraries such as Struts, are being replaced by new AJAX libraries that make GUI programming more straight forward, robust and easier to unit test. In this session I will look at what an enterprise web application is and why you should choose an AJAX based library for GUI development over traditional JSP libraries and an Object Relational Mapper (ORM) over traditional JDBC for the Data Access Layer (DAL). I will look at an AJAX library and an ORM Library and present simple examples of how and where they should be used. I will then look at how to integrate the AJAX library into traditional Spring MVC and how to use Spring Security to authenticate users of the application and secure individual Remote Procedure (RPC) calls made from the client application, running in a browser, to the server. In the final part of the session I will take a more in‐depth look at the ORM library and explain how to use a registry to abstract away Data Access Objects (DAOs) so that the real DAOs can be used in production and integration testing while seamlessly substituting mock objects for unit testing. I will also explain how the tools provided by Spring make integration testing of DAO objects very simple.

FindBugs: Testing (Java-) Code Against Bugs And Defects (Bernhard Merkle)

90 mins This session should be really fun. We will make a deep dive into findbugs, a very useful tool which every programmer should use to test Java code against potential bugs, defects and antipatterns. After a first overview of the problem domain (static analysis), we will take some of Joshua Bloch's "Effective Java" Rules from his book (a ACCU mentored developer mailing lists currently runs...) and see how / if they can be implemented in a tool like findbugs. I will show how findbugs works internally and we will implement a new bug detector (findbugs rule) to find specific defects we are interested in. Additionally we cover different levels of static analysis like code‐, design‐ and architecture‐level. Interestingly findbugs checks code and design level, but fails itself (!) on the architecture level; which means the tool itself suffered major architecture erosion from version 0.7 to the current 1.3.8. I am participating now in the findbugs project and contributed several architectural refactorings on the findbugs 2.0 branch (see the sourceforge/googlecode SVN repository) which is currently under development and should hopefully be finished during the time of the ACCU 2010 conference. We will see, how far an automated and tool supported approach can lead to better results and how tools like findbugs can discover areas of code‐ and design‐erosion and suggest improvements. Additionally we will look at the next generation of analysis which is architecture analysis.

Genemodulabstraxibilicity (Steve Love)

90 mins The title says it all! If it's hard to write unit tests, or they take too long to run, if your plugins need the whole application for their distribution, if you can't (re)use a bit of your colleague's code without importing the entire team's work, if your multi‐threaded code performs better when you run it sequentially, or you've got 5 versions of the same 3rd party library littering your source repository, then you're suffering from this. Or perhaps just part of it... Modern languages provide us with many tools for creating beautiful, modular, general, flexible and simple abstractions, yet it seems they give us even /more/ tools for writing ugly, monolithic, specific, rigid and complicated, er, /concretions/.

ACCU Conference 2010 April 14‐17, 2010. Barcelo Oxford Hotel, Oxford, UK 7 of 30 With examples of both kinds in C#, Python, C++ and maybe even C++0x (if it stays still long enough to get the syntax right :‐)), this is a talk about our (code's) propensity for wearing too many hats.

Generic Programming (Dietmar Kuehl)

90 mins The standard C++ library introduced generic algoritms on homogeneous sequences. C++0x introduces the tuple class template for inhomogenous sequences but neither provides generic algorithms nor use‐cases for this powerful class template. This presentation explores some of the power yielded by tuples and shows tools easing the use of tuples like algorithms on tuples and enable_if. In addition it goes over some of the extensions voted into C++0x which relate to generic programming like variadic template and the enhanced functional support, notably bind(). The goal of this presentation is to demonstrate how to create a library component operating on a variety of structures: The details are exposed to the library using tuples. The library automatically adapts its behavior to the exposed structure at compile time. This is demonstrated with some simple example employing the various techniques. The implementation of such a library is heavily using templates with the goal of exposing a simple and type‐safe interface to the user.

Get Clojure! (Mark Dalgarno)

45 mins Clojure is a new dynamic language for the Java Virtual Machine. Its particularly interesting as it is a functional language drawing inspiration from the Lisp family of languages. In fact, its been described as Lisp reloaded. This short talk will outline the languages key features with several short programming examples:

• Functional Programming • Concurrency Approaches • Macros

Participants will benefit by gaining insight into functional programming as it is realised in the Clojure language. The talk will give an overview of the language aiming to encourage participants to explore further.

Googletest and Googlemock C++ libraries (Seb Rose)

90 mins Google released the Googletest library for C++ in mid 2008 and it joined a long list of Unit Test frameworks. The developers had concentrated on making the framework powerful and highly portable and released it under a very relaxed open source license. The library is well thought out, and easy to pick up by anyone familiar with other popular unit testing frameworks. In early 2009 they followed this by releasing the Googlemock mocking library, which is the icing on the cake. C++ developers now have access to a library that provides many of the mocking features that users of languages that provide reflection have had for years. This session will give you an in depth tour of these libraries, pointing out their strengths and shortcomings. Familiarity with C++ is a precondition, but no knowledge of Unit Testing frameworks or TDD is necessary.

GPU Computing Supercomputing for the Masses (Albrecht Fritzsche)

90 mins The history of recent computing has seen many attempts to overcome the free lunch is over problem, i.e. how existing software can benefit from the upcoming hardware performance improvements. Especially graphic card designers have pushed this to one extreme ‐ the programmable Graphic Processor Unit or GPU has evolved into a highly parallel, multithreaded, manycore processor with tremendous computational horsepower and a very high memory bandwidth, which is probably todays most powerful computational hardware for the dollar. Such consumer hardware turns nowadays every home computer into a supercomputer with a performance currently reaching 2.7 Tflops, i.e. 177 times the performance of the Deep Blue. In addition to that is the field of GPGPU computing maturing. Two standards are currently emerging: one of them, OpenCL, is already integrated into Apple's Snow Leopard OS, the second, Direct Compute, on the other hand will follow in Windows 7.

ACCU Conference 2010 April 14‐17, 2010. Barcelo Oxford Hotel, Oxford, UK 8 of 30 But how do you program these processors? How does programming it differ from normal programming? What problems are suited for the GPU? Which are not? This talk will give an introduction into the field of GPU computing. After giving an overview of its inherent special programming model some typical techniques and solutions will be presented. It will be shown how these techniques lead to a program that can run on any number of processor cores and will scale with future hardware automatically. Furthermore current trends in creating higher‐level constructs (like the STL‐mimicking Thrust library) and a short on‐look of the two vendor‐independent standardization solutions will be given. Last but not least a demonstration will show the potential of these highly parallel manycore processors. The talk will be based on the currently most popular and most widely used free SDK, CUDA (an acronym for Compute Unified Device Architecture). But the given techniques and solutions apply to all available SDKs and upcoming standards.

Importance of Early Bug Detection for Improving Program Reliability and Reducing Development Costs (Sergey Ignatchenko)

45 mins

• The longer the bug is allowed to exist within software development lifecycle, the more expensive it becomes, and the dependency is exponential. It includes both much longer times to detect rarely occurring bugs, and potential need to rewrite much bigger portion of code to fix it. • Three special cases of the most difficult to find bugs: multithreaded bugs, security bugs and 3rd‐party library bugs. Some of these can be found only by code review. • Existing methods of early bug detection: compiler support, LINT, programming by contract/asserts. • Importance of incorporating early bug detection/prevention at design/architectural level (including guidelines, multithreaded design, minimizing dependencies). • Ways to improve early bug detection. • Conclusion: while no means of bug detection should be neglected, way too often improving program reliability is understood only as testing, while there are lots of ways to improve it and to reduce number of bugs at much earlier stages in software development lifecycle, at much lower cost both for developers and for end‐users. iPhone development (Pete Goodliffe, Phil Nash)

90 mins An introduction to iPhone development for beginners or those who are casually interested and want a leg up the learning curce. This talk is an overview of how to get started as an iPhone developer, and an introduction to the core technologies, including:

• Objective C/C++ • Common iPhone/Mac OS design patterns, idioms, and practices • Becoming a native: how to "think in iPhone" • Overview of the libraries and facilities that exist • Limitations of the development environment

Just In Time: Last Minute Testing (Astrid Byro)

45 mins What happens when a project has a hard deadline looking and requirements set in concrete? Testing gets cut of course. This case study examines the unorthodox approach that this Project Manager took to minimise risk while cutting test time to a minimum. Will her project go live on time? Will her software work? Will the client be satisfied? Will the Project Manager get paid? What lessons can we learn about managing expectations?

Lean Architecture and Agile Software Development (James Coplien)

90 mins

ACCU Conference 2010 April 14‐17, 2010. Barcelo Oxford Hotel, Oxford, UK 9 of 30 Agile has long shunned up‐front design. When Agilists force themselves to do up‐front work, it usually is limited to a symbolic use of User Stories for requirements and metaphor for architecture, with much of the rest left to refactoring. Experience and formal studies have shown that incremental approaches to architecture can possibly lead to poor structure in the long term. This tutorial shows how to use domain analysis in a Lean way to build an architecture of form that avoids the mass of structure that usually accompanies big up‐front design, using only judicious documentation. It will also show how architecture can accommodate incremental addition of features using Trygve Reenskaug's new DCI (Data, Context and Interaction) approach, and how it maps elegantly onto C++ implementations. The tutorial is based on the forthcoming Wiley book of the same title.

Message-passing Concurrency in Erlang (Ulf Wiger)

90 mins In this talk, I will describe the principles behind Erlang‐style Concurrency ‐ what problems it was designed to solve, and how it fundamentally changes the way you go about structuring your programs. I will illustrate how to achieve great scalability on multicore and in compute clouds, without sacrificing clarity or your own sanity.

Mocking On The Edge Isolation at the system level (Roy Osherove)

90 mins In this talk well explore a different concept of isolation: Isolating a full system under test instead of a unit. Also explored: Always on fakes, transparent stubs, and system boundary simulators. Well also use the open source project CThru to show how these concepts can come to life.

Objects of Value (Kevlin Henney)

90 mins Objects do not live in a free society: they exist for a purpose; they are not created with equal rights; they should not aspire to equality. What this means in practice is that objects live in a class‐ridden society where each class serves a different role in the program as a whole. One category of object in need of attention and liberation is for representing domain values. Values are fine grained and informational. They are inherent in the problem domain, but are often flattened into little more than plain integers and strings in the implementation, weakening the correspondence of the code to the situation it addresses. The Value Object is often cited as the pattern to employ, but when it comes to identifying and implementing the Value Object pattern, there is a great deal more to be taken into consideration than can reasonably fitted into a single pattern. This talk looks at the practices and concepts that surround values and their implementation in object form across different languages.

Parallelism: The JVM Rocks (Russel Winder)

90 mins Intended Audience: Programmers Java has had multithreading since its inception: it was developed towards the end of a strong period of research into parallelism 1986‐‐1994, and chose to integrally incorporate threads into the language. Initially the threads were just concurrency tools for programs running on a single processor. As systems became multiprocessor ones, and indeed multicore ones, and threads were used as a tool by operating systems to harness multiple processors and cores, Java fell into being a parallel processing language without really trying ‐‐ the JVM naturally harnesses all processors and cores available using native kernel threads. Over time though, it has become patently apparent (but there is no patent on it) that shared memory multithreading is the problem and not the solution to the parallelism that is now the norm due to the Multicore Revolution. JSR166 came and was agreed, leading to java.util.concurrent. JSR166x and JSR166y augmented this with lots of new goodies for Java programmers: this introduced Futures and Parallel Arrays which are great tools for harnessing parallelism without all the hassles of synchronization issues with threads. There are however other things happening that could be really important. Enter: Scala, Groovy and Clojure. Instead of threads, programmers use actors, dataflows, CSP, software transactional memory, agents. Scala introduced the Actor Model as its main vehicle for parallelism. GParallelizer brings not only the power of Groovy as a coordination

ACCU Conference 2010 April 14‐17, 2010. Barcelo Oxford Hotel, Oxford, UK 10 of 30 language to the JVM, it allows for a raising of the level at which applications programmers work with java.util.concurrent ‐‐ Actor Model, Dataflow, and soon CSP are supported. Clojure is showing software transactional memory as well as agents and other techniques based on JSR166. All these ideas have been around for years, but now that parallel programming is the norm and not the province of high performance computing (HPC), they are becoming Very Important. Using these message based models of computation, synchronization problems are more or less non‐existent. Deadlock and livelock are not impossible, but they are nearly so. This session will be a tour through all these, showing why the JVM is the platform of choice for all discerning applications programmers.

Patterns for performance tuning (Klaus Marquardt)

90 mins Performance tuning is a virtue needed in many projects, yet it appears to be so different from other design activities. Well, is it? This workshop builds on many tuning techniques that have been identified at EuroPLoP and ACCU sessions before. Revisiting them, we will strive for an overview and order the practices so that paths of subsequent usages can be identified. This is the high art of patterns: building sequences through large pattern languages, that actually give guidance and make the patterns accessible.

Programming in a Mixed Environment (Alan Lenton)

90 mins As the IT environment beomes more hetrogenous, many C++ programmers who previously just programmed in Windows are also expected to be able to program Unix machines, particularly servers, and be able to turn their talents in either direction. The talk will look at some of the differences programmers are likely to encounter programming under Linux, the flavour of Unix most likely to be encountered. Issues covered will include philosophical differences and how the impinge on writing applications, job handling, network I/O, threading, exception handling among other things. We will also take a look at some of the more important tools available to C++ programmers under Linux. Finally, the talk will look at one of the leading of the C++ cross platform frameworks ‐ Nokia/Trolltech's Qt, which has recently become fully open source. We will look at some of its strengths and weaknesses, and see what lessons for general purpose cross platform coding can be drawn from it, and whether it represents a viable solution.

Real QA - the argument for smarter quality assurance than mere testing (Tom Gilb)

90 mins Traditional testing, as a means towards quality assurance, is far too costly and far too ineffective. There are much smarter ways to approach software quality. This session will argue with facts for a half dozen more‐cost‐effective ways to get reliability and all other qualities, like usability, security, adaptability, into your systems, than conventional testing.

Renovating a legacy C++ project (Alan Griffiths)

90 mins The world is full of functionally rich, slow to build, hard to maintain, C++ systems. Some of these have been developed over time by many and varied hands. They continue to exist because they provide valuable functionality to the organisations that own them. To maximise their value it is necessary to provide interfaces to today's popular application development languages, and make it possible to continue to develop them in a responsive and effective manner. This is the story of one such system, the problems it presented and the approach taken to addressing these problems. While I'll have slides to guide discussion and tell this particular story, I will also encourage the audience to share their experiences during the session.

Requirements 10 step (Allan Kelly)

90 mins

ACCU Conference 2010 April 14‐17, 2010. Barcelo Oxford Hotel, Oxford, UK 11 of 30 Whatever method of development is being used someone needs to decide what is needed before the code gets written. For Agile teams this more important than ever because requirements constantly change and time is limited. Indeed the next challenge for Agile methods is to improve the quality, and reduce the quantity, of what is being asked for. In this presentation Allan Kelly will present a 10 step model and supporting tools for teams to improve the "what" of software development.

Scrum Shock Therapy (Jeff Sutherland)

90 mins TBD

Simple Software - Regain Control through Decremental Development (Peter Sommerlad)

45 mins Developing Software using the latest complex technology is cool. Software evolution by adding features and fixing bugs can be a burden. Both lead to brittle, buggy, overly complex and poorly performing software solutions. The value of Simplicity of a software solution is often neglected by many software people today. Making software simpler increases its value, because of lower maintenance burden and easier extendability. This talk explains what "simple" software means and how to approach it with "Decremental Development" even for existing (unnecessarily) complicated software. Software has a problem: It is much easier to create complex solutions than to create simple elegant solutions. Thus most software is much more complicated and larger than it needs to be. This unnecessary complexity leads to lower quality and hinders further evolution. Space is no longer a problem in the computer, but the human brain capacity hasn't grown like computer memory capacity. Brains create software; therefore we need to understand software. Time has come for a change: programmers must consciously reduce complexity and size of solutions to keep up with the growing problems to be solved. There is need for a dramatic reduction in program complexity: "Decremental Development" aims for reducing a system's size TO 10 % (a tenth) while improving quality and maintaining required functionality. Less code means more software! To progress in the direction of this goal requires change in several areas. One area is the underlying culture of our industry. A project approach to software development almost automatically leads to short‐term solutions just barely working until the project is delivered, because a project manager is not payed for establishing long term success, but to deliver a product with as little resources spent as possible and on time. So‐called software maintenance is often viewed as a low‐profile job, close to being a janitor cleaning up the worst dirt. Another area is the qualification of developers. It is extremely hard for an outsider (=manager) to evaluate existing differences in talent and skill or at least to judge a really bad programmer from a better one. Sometimes the skill‐level is just too low or too outdated. And I don't speak of mastering latest technology, but of understanding what one is doing. Dirty code starts in the very small, like a dirty city starts with the first dog dropping on the sidewalk. So you can start today cleaning our code by just caring for cleanness, like the Swiss dog owners do with Robidog. It is also OK to throw away useless or bad code. You can always recycle it from your version control system, if really needed. The fastest code is the one not there. Inexistent code also never has errors. Have courage to delete and change. The current economic crisis might help us with a culture change, increasing the valuation of sustainable software and thus Simplicity in software design and code. Also software maintenance should not be viewed as it is. Valuable software is handed to a thousand code monkeys for maintenance with the hope it stays intact, but who would you hand a valuable painting for restoration? We do not yet know all means or tools one can imagine to make software simpler and smaller with Decremental Development, but nevertheless you can start today by caring more about software quality.

Solid C++ Code by Example (Olve Maudal)

90 mins Sometimes you see code that is perfectly OK according to the definition of the language but which is flawed because it breaks to many established idioms and conventions of the language. This will be an interactive session with discussions about good vs bad C++ code. We will discuss simple C++ idioms and coding conventions, but we will also touch upon best practices when working with C++ in large codebases with lots of developers with mixed skills.

ACCU Conference 2010 April 14‐17, 2010. Barcelo Oxford Hotel, Oxford, UK 12 of 30 Stood at the bottom of the mountain looking up (Pete Goodliffe)

90 mins How to get up to speed with new technology, fast. The fun thing about software development is that there's always something new to learn, something new to do, and a new way to stretch your capabilities. A software developer should never stand still. If you stand still, you stagnate. The more senior you get, the more pressure there is to be able to pick up new technologies and hit the ground running. However, its hard work to move onto new pastures and be immediately effective. Starting with any new technology is like standing at the bottom or a huge mountain, and looking up at the summit. You're not sure how far away it is, let alone how to get up there. In this talk, we'll explore how to start climbing, and how to make sure your ascent is as fast and effective as possible. And we'll see how to ensure you don't fall off on the way up. We'll consider how to quickly get up to speed with new technologies, new languages, new environments. And we'll investigate the winning approaches and attitudes that'll help you reach the summit.

Styling your Architecture in an Evolving Concurrent World (Francesco Cesarini)

90 mins This talk will look at the most common architecture patterns in Erlang‐based products, describing how each of them solves a particular problem while guaranteeing no single points of failure. It will start with the early versions of the AXD301 switch and end with examples of the use of Erlang in cloud computing architectures.

Super Size Me (Andrei Alexandrescu)

90 mins Working with very large data sets, only a few years ago the monopoly of a few companies (such as Google, Walmart, Yahoo, or Morgan Stanley), is becoming increasingly commonplace. Dealing with massive quantities of data on parallel computational networks shifts usual design tradeoffs substantially: operations that are traditionally considered cheap become prohibitive, and algorithms that seem ungainly become life savers. Andrei shares from his experience on working on large data sets with his doctoral work and six months of doing Natural Language Processing research for Faceboook.

TDD at the System Scale (Steve Freeman, Nat Pryce)

90 mins TBA

Testing software in adverse memory conditions (Charles Bailey)

90 mins This presentation is a strongly C++ based look at the challenges and techniques for tackling problems with memory usage, including address space shortage and fragmentation. When an application works with the small, easy to run test data set that the development team likes to use but goes very bad in production it presents a testing dilemma. How can we verify that our application will cope with large volumes of data without incurring the expense of very long running production tests? We need to assess whether the production data is a reasonable size and shape for our application to handle. If our application should be able to cope but isnt, what is going wrong? Is it crashing? Is it stuck in an infinite loop? Does it just look like its stuck and is actually just being painfully slow? First we explore some techniques for assessing memory usage patterns, both using features available in C++ and also using basic tools available on popular operating systems. Then we investigate some of the ways in which different memory allocation and usage patterns can have profound effects on the overall performance of an application.

ACCU Conference 2010 April 14‐17, 2010. Barcelo Oxford Hotel, Oxford, UK 13 of 30 Finally we look at some tricks for simulating bad memory situations cheaply and easily so that we have a good chance of quickly detecting when parts of our application have bloated and will fail to provide the performance that will be required for them to cope in a constrained memory environment.

TestXNG Testing XML Schemas and XSL Transformations (Filip van Laenen)

45 mins Although Test‐Driven Development (TDD) has become the standard practice to develop software, there aren't so many tools available to write unit or integration tests for XSL Transformations, and none for the development of XML Schemas. TestXNG is an effort to fill the gap, and in contrast to the few tools that are available for writing unit tests for XSL Transformations, it is not based on JUnit but inspired by TestNG. TestXNG tests are specified in XML documents, and each such document can contain one or more assertions. For XML Schemas, TestXNG can be used to assert the validation or non‐validation of some XML source code against a given schema. For XSL Transformations, it can assert the correct transformation, but later versions will also be able to include parameters and modes, test direct calls to templates or the presence of keys. One effect of using TestXNG, and completely in accordance with other TDD experiences, is that the resulting code is much more modularized and thus also more comprehensible as a consequence of making it testable. TestXNG is implemented using Java and Maven, available as an Open Source project at https://sourceforge.net/projects/testxng/, and work in progress.

The C++0x Standard Library (Nicolai Josuttis)

90 mins My book about the C++ Standard Library is 10 years old now. But a new version of the Standard is coming, C++0x, so I am preparing a new edition of the book. Unfortunately, I have no clue yet, what was added, because in recent years was was dealing with SOA rather than with C++. I only know, while finally concepts were removed, a lot of other stuff was added. So, what I can announce for this talk is simple: I will present all stuff I will learn during the next months, which from my point of view will be noteworthy new features of the C++0x Standard Library. You might visit this talk to learn about these new features, hear about some strange or funny pitfalls, or just to correct me because you are more of an expert than I am. It's up to you ;‐)

The Case Against Test Cases (James Bach)

90 mins TBA

The Cost of Agile Testing (Schalk Cronje)

90 mins In the Agile era, unit testing has been over‐emphasised to the detriment of other forms of testing. As Agile has matured and the software industry are starting to move beyond pure Agile, we are now rediscovering the importance of other software quality practices. Quality is not free and there is a cost to implementing fully automated testing systems both economically and socially. I'll be looking at some cases studies of teams that have walked the road towards Agile testing and evaluate their decisions and compromises they made in order to release their products and how this has affected business value and team culture. I shall also demonstrate how metrics were used to measure business impact of both positive and negative actions.

The Language Stew (Robert Martin)

90 mins

ACCU Conference 2010 April 14‐17, 2010. Barcelo Oxford Hotel, Oxford, UK 14 of 30 All of a sudden we seem to be inundated by hordes of new languages, each competing for the "next big thing" award. There's Python, Ruby, Scala, Clojure, F#, and then of course all the new standards for C++, Java, and C#. What should we think about all this? Which language will win? Will _any_ language win? And how does all this tie into the craftsmanship/professionalism movement?

The Role of Static Analysis in Software Development (Paul E. Black)

90 mins I start with a brief description of my current work leading the Software Assurance Metrics And Tool Evaluation (SAMATE) project. The body of the tutorial is how automated static analysis can help in the software development process. Quality must be designed into and built into software. Nevertheless testing (dynamic analysis) and static analyzers have roles in delivering excellent software. We begin by describing what static analysis is (and isn't) and compare it in general with testing. We describe the dimensions of static analysis: universality, rigor, and subject matter, and concepts related to static analysis and their results. We review the state of the art in static analyzers, citing recent results from the 2008 and 2009 Static Analysis Tool Expositions and other work in the United States. Finally we present suggestions on how best static analysis might be incorporated into software development.

The Uncertainty Principle (Kevlin Henney)

90 mins Not sure about something? And that something affects the detailed design, an architectural decision or choice of functionality? Does that feel like a problem or a part of the solution? There is a strong tendency for humans to feel unsure about uncertainty, in two minds over ambiguity and a little wobbly with instability. Whether over technology choice, implementation options, requirements or schedule, uncertainty is normally seen as something you must either suppress or avoid. Of this many people appear, well, certain. That you should embrace it and use it to influence schedule, identify risk and inform design is not immediately obvious. A lack of certainty offers the opportunity to highlight risk and reframe questions, making uncertainty part of the solution rather than necessarily a problem.

The Unix Toolchest: Power Tools for Power Programmers (Diomidis Spinellis)

90 mins The Unix tools were designed, written, actively used, and refined by the team which defined the modern computing landscape. Although by the standards of shiny IDEs some may find the interface of these tools arcane, their power remains unmatched. Their versatility makes them the first choice for obtaining a quick answer and the last resort for tackling in minutes large, specialized, and difficult problems. Compared to scripting languages, another great productivity booster, Unix tools uniquely allow an interactive, explorative programming style, which is ideal for solving efficiently many programs that we developers face every day. Natively available on all flavors of Unix‐like systems, including GNU/Linux and Mac OS X, the tools are nowadays also easy to install under Windows. We start with a brief introduction to the key ideas behind the Unix tools, their main advantages in todays computing landscape, and the factors affecting the choice between a pipeline of individual tools, a scripting language, and a compiled language. Many one‐liners that well build around the tools follow a pattern that goes roughly like this: fetching, selection, processing, and summarization. We review the most important tools for each phase, the plumbing that joins the parts into a whole, and more specialized commands for handling software development tasks and their visualization. The examples well see involve everyday problems we face as developers. We end with a discussion of common patterns and anti‐patterns.

Things Developers Can Learn From System Test (Hubert Matthews)

90 mins Much attention has been paid lately to developer‐level testing, either as unit tests or TDD. In comparison little attention has been paid to system test and how what developers and designers do affects the ease (or not) of system test. This talk will use a number of examples and case studies to illustrate points about how developers can help get their products

ACCU Conference 2010 April 14‐17, 2010. Barcelo Oxford Hotel, Oxford, UK 15 of 30 shipped by considering handling of state, concurrency, time, scaling, logging, error handling and other system‐level issues early on in the process.

Transitioning from Traditional to High-Speed Agile Testing (Jerry E Durant)

90 mins Testing practices and behaviors are challenged by Agile software development projects. What was done in a stepwise and methodical way is now confronted by the need to take a more adaptive approach. Even tools that have been used are becoming more difficult to deploy and reach a level of value contribution. The 90 minute session will be divided up as follows; 30 minutes Transitioning from a present/traditional practice perspective to a form that adequately addresses Agility AND meets the needs for sound, responsible testing behavior. 30 minutes Discussing methods and techniques that are high‐speed. This will include Pareto based, Pair‐Wise and Exploratory. In addition, we will discuss the importance of maintaining calibration. 30 minutes Use of tools and technologies to support rapid test delivery. A close examination on how to create effective TDD (Test Driven Development).

Using Concurrency in the Real World (Anthony Williams)

90 mins The multicore revolution is upon us; the free lunch is over. CPU manufacturers are adding more cores rather than increasing the clock speed, and modern CPUs often have lower clock speeds than a year ago. In order to get maximum performance from our software we need to take advantage of these cores ‐‐‐ we need to add concurrency to our applications. In this presentation I'm going to talk about ways of doing this. Using the concurrency facilities from C++0x as a basis, I'll cover ways of wringing parallelism and concurrency out of existing programs, and ways of thinking about problems to make this process easier with new programs. I'll also cover some common pitfalls and give practical advice for testing concurrent programs.

Using the Agile Testing Quadrants to Cover Your Testing Bases (Lisa Crispin)

90 mins Software quality has many dimensions, so we must be ready with different testing approaches. We test to find defects, ensure system reliability, check that the system is easy to use, verify that its secure, and much more. How do you know the different types of tests you need? How do you know when you're done testing? In this tutorial you'll learn how to use the four categories of the Agile Testing Quadrants method to make sure your team has covered all the basesprogrammer tests (test‐driven development); customer tests that help the team meet the users' requirements; business‐facing tests that critique the product's behavior and find the important bugs; and technology‐facing tests that examine non‐functional qualities such as performance, load, scalability, reliability, and security. The quadrants provide a common vocabulary about testing, and a mechanism to encourage collaboration, whether the team uses an "agile" process or not. Group exercises will be the main focus of learning to understand some of the testing activities. Participants will take away ideas and techniques they can put to immediate use.

Wrestling with Giants (Jez Higgins, James Reddick)

90 mins Large software components ‐ content management systems, workflow engines, ERP systems, CRM tools ‐ promise much, but often seem to deliver less and with great difficulty. There sometimes seems to be some distance between what the product claims to do, and what it actually does. Sometimes it almost does what you need, but not quite. It may present a myriad of possibilities, but give no guidance as to the best path. Alternatively, it may promote one true way and punish those who need to take the highways and byways. However, all these types of systems have one thing in common ‐ you have no choice but to use what's in front of you.

ACCU Conference 2010 April 14‐17, 2010. Barcelo Oxford Hotel, Oxford, UK 16 of 30 Recently, Practical Law has replaced a large web application developed in‐house over many years with an equivalent system developed atop FatWire Content Server, a 3rd‐party content management system of precisely the category described above. The project went live on 6 September, having slipped 5 weeks on a 9 month plan. This talk is not about how wonderful Fatwire is, or how wonderful we at Practical Law are. Nor can it examine the reasons why the previous application was obsoleted, or how FatWire became the substrate for the new development. Instead, we want to look at the obstacles presented by our content management system and of our own devising, and how we overcame them. From that we'll try to draw lessons that implementators on and (this may be wishful thinking) vendors of large software systems might do well to learn.

Writing "Good" Component-Level Test Drivers (John Lakos)

90 mins In our component‐based development methodology, virtually all of the software we design is rendered as components. When we say component in C++ we are referring to a .h/.cpp pair (of files) satisfying certain well‐established, objective physical properties. Moreover, each of our developers is responsible for ensuring the correctness of the software he or she creates. Hence, along with each component developed, we require a standalone test driver to verify that all essential behavior implemented within that component behaves as advertised i.e., according to the contract delineated in its component, class, and function‐level documentation. In this very practicable talk, we will review the various categories of common classes (e.g., utilities, mechanisms, and value‐semantic types). We will also review the basic principles of testing, various methods for systematically selecting test data, and the (four) primary implementation techniques for writing test cases. We will then discuss the organization of our self‐contained (and delightfully light‐weight) component‐level test drivers. The substantial remainder of the talk will address (1) the details of how effective individual test cases are conceived, documented, and implemented, (2) how these test cases can be profitably ordered to leverage already proven component functionality, and (3) how similarities within the various class categories naturally lead to effective reusable testing patterns.

You're Going To Have To Think! Why [Insert Technique Here] Won't Cure Your Floating Point Blues. (Richard Harris)

90 mins The dragon of numerical error is not often roused from his slumber, but if incautiously approached he will occasionally inflict catastrophic damage upon the unwary programmer's calculations. So much so that some programmers, having chanced upon him in the forests of IEEE 754 floating point arithmetic, advise their fellows against travelling in that fair land. In this session we shall briefly explore the world of numerical computing, contrasting floating point arithmetic with some of the techniques that have been proposed as safer replacements for it. We shall learn that the dragon's territory is far reaching indeed and that in general we must tread carefully if we fear his devastating attention.

Speakers

Alan Griffiths

• Renovating a legacy C++ project

Alan Griffiths is a regular at the ACCU conference and has been developing software through many fashions in development processes, technologies, and programming languages. During that time he's delivered working software and development processes to a range of organizations, written for a number of magazines, spoken at a number of conferences and made many friends. Firmly convinced that common sense is a rare and marketable commodity he's currently working as an independent through his company, Octopull Limited http://www.octopull.co.uk/.

ACCU Conference 2010 April 14‐17, 2010. Barcelo Oxford Hotel, Oxford, UK 17 of 30 Alan Lenton

• Programming in a Mixed Environment

Alan Lenton specialises in client/server architecture and C++ programming. He uses the cross platform Qt libraries to build rich client applications. He is also the designer, architect and programmer of ibgames massively multi‐player game, Federation 2, which celebrated its 20th birthday last year. Alan has been programming in C and C++ since the first commercial compilers were available, and has been developing and running applications on Linux since 1993. He describes himself as a pragmatic open source evangelist, and produces a weekly technology and internet newsletter called Winding Down. Alan is currently working towards an MSc in Computer Security. http://www.ibgames.net/alan/

Albrecht Fritzsche

• GPU Computing Supercomputing for the Masses

Albrecht Fritzsche is a Senior Software Developer at mental images, involved from the very start in a project of developing a 3D web services software platform that is highly scalable to thousands of servers. Prior to that he worked at ableton for their real‐time audio sequencer Live. Throughout his now more than 12 years of C++ programming he still enjoys this very language. His personal software related interests are in the domain of lock‐free programming incl. Transactional Memory.

Allan Kelly

• Requirements 10 step

Allan is independent consulting helping companies improve the way they develop software and ensuring customers get what they need. He provides training and coaching in Agile and Lean techniques to help teams reach this goal. His focus is on the management of software development work, including business analysis; product, project and change management, and business strategy alignment. Allan is an active member of the ACCU and a regular conference speaker and has published in journals such as The Agile Journal, E‐Management Technology and ACCU Overload. His book "Changing Software Development: Learning to be Agile" was published in 2008 and looks at how software companies change. He is currently working on a book of business strategy patterns for software companies.

Andrei Alexandrescu

• Super Size Me

Andrei Alexandrescu coined the colloquial term "modern C++", used today to describe a collection of important C++ styles and idioms. His eponymous book on the topic, Modern C++ Design: Generic Programming and Design Patterns Applied (Addison‐Wesley, 2001), revolutionized C++ programming and produced a lasting influence not only on subsequent work on C++, but also on other languages and systems. With Herb Sutter, Andrei is also the coauthor of C++ Coding Standards: 101 Rules, Guidelines, and Best Practices (Addison‐Wesley, 2004). Through Andreis varied work on libraries and applications, as well as his research in machine learning and natural language processing, he has garnered a solid reputation in both industrial and academic circles. Since 2006, he has been second‐in‐command to Walter Bright, the D programming language inventor and initial implementer. Andrei has been the key designer of many important features of D and has authored a large part of D's standard library, positioning him to write an authoritative book on the new language, appropriately entitled, The D Programming Language. Andrei holds a PhD in Computer Science from the University of Washington and a BS in Electrical Engineering from University "Politehnica" Bucharest. He works as a Research Scientist for Facebook.

Anthony Williams

• Using Concurrency in the Real World

ACCU Conference 2010 April 14‐17, 2010. Barcelo Oxford Hotel, Oxford, UK 18 of 30 Anthony is the author of C++ Concurrency in Action published by Manning. He was author or co‐author for many of the papers resulting in the C++0x thread library, and has written a complete implementation of that library. He has been developing in C++ for over 10 years, and multi‐threaded applications for almost as long.

Astrid Byro

• Just In Time: Last Minute Testing

Astrid Byro is an independent consultant specialising in information management solutions for global enterprises and has been in the business for 11 years. Astrid has done projects in the construction, transport, asset management, engineering, petrochemical, banking, insurance, agrichemical and utilities industries. She hopes, one day, to retire to run a small third‐ world country.

Bernhard Merkle

• FindBugs: Testing (Java‐) Code Against Bugs And Defects

Bernhard Merkle works as a Software Architect and Engineer for Software Engineering in the central Research & Development Department at SICK AG, one of the worlds leading producers of sensors and sensor solutions. He serves as an internal consultant for the complete Software Development Cycle and is responsible for Process and Methods selection as well as Tool evaluation and introduction. In his spare time Bernhard gives lectures about MDSD (Model Driven Software Development) at the University of Furtwangen in the Faculty Application Architecture Master. In his previous job, he worked at an MDA tool vendor where he delivered client projects using MDA and Modelling Languages and gave training on MDA, J2EE, CORBA, Java and C++. He regularly writes technical articles about these subjects and new technologies in IT magazines and has also given sessions at various conferences (e.g. ACCU, Code Generation, Conquest, OOP and IX).

Charles Bailey

• Testing software in adverse memory conditions

Charles Bailey is a C++ enthusiast, always finding himself in the quest for beautiful and correct code. He is also adept at Java, C, perl, Sinclair and BBC BASIC, x86 assembler, APL and a few other dialects, and occasionally dabbles in Python, Haskell and Lisp. He started his software career at Hyperlink, an internet consultancy, where he performed the now deeply unfashionable work of building robust websites using C++. He then spent eight years working for Cognos (before it became an IBM company). During this time as a software architect he was always at the forefront of the drive to extract maximum performance and scalability from all the projects in which he was involved. He now works as technical lead at igence, an independent software company, where he works on continually improving their libraries and software development processes and provides much of the technical training for the development team.

Detlef Vollmann

• Atomics for C++

Detlef Vollmann has a background of 30 years in software engineering, about 25 years in object technology. He is an active member of the C++ standardization committee (generally assigned to the concurrency sub‐working group) and one of the authors of the C++ performance report. He designs and implements programs with and without concurrency since 1982. He's now responsible to support teams world‐wide that use embedded Linux systems. Since 1991, he has authored and taught seminars, tutorials and short presentations about C++, object‐oriented technologies, software architecture, embedded design and distributed computing for major Swiss companies and at international conferences.

Dietmar Kuehl

• Generic Programming

ACCU Conference 2010 April 14‐17, 2010. Barcelo Oxford Hotel, Oxford, UK 19 of 30 Dietmar Kuehl is a software developer at Bloomberg L.P. working on high performance systems feeding financial exchange data into the internal system. In the past, he has done mainly consulting for software projects in the banking area. He is a regular attendee of the ANSI/ISO C++ standards committee and a moderator of the newsgroup comp.lang.c++.moderated.

Diomidis Spinellis

• The Unix Toolchest: Power Tools for Power Programmers

Diomidis Spinellis is a Professor in the Department of Management Science and Technology at the Athens University of Economics and Business, Greece. He has written the two award‐winning Open Source Perspective books: Code Reading and Code Quality as well as dozens of scientific papers. He is a member of the IEEE Software editorial board, authoring the regular Tools of the Trade column. Diomidis is a FreeBSD committer and the developer of UMLGraph and other open‐ source software packages, libraries, and tools. His open source implementation of the sed stream editor is distributed with Mac OS X and the BSD Unix systems. He holds an MEng in Software Engineering and a PhD in Computer Science, both from Imperial College London. Diomidis is senior member of the ACM and the IEEE and a member of the Usenix association.

Dirk Haun

• Adventures in QA

Dirk Haun has been developing software in C and C++ for smart card POS terminals, PDAs and smartphones, service level management tools, and systems for document processing and conversion. He has since moved on to the field of software QA. In his spare time, he is maintaining an open source CMS project.

Filip van Laenen

• TestXNG Testing XML Schemas and XSL Transformations

Filip van Laenen is a Chief Engineer at the Norwegian software company Computas AS, which supplies IT solutions to the public and the private sector in Norway. He has over 10 years of experience in the software industry, from being a developer in both small and large teams to being the lead developer and compentency leader for security and software engineering for the whole company. In his professional career he has mainly used programming languages like Smalltalk, Java, Perl, Ruby and PL/SQL. He has a special interest in computer security and cryptography, and held the position of Chief Security Officer at Computas for a number of years. Filip holds a M.Sc. in Electronics and a M.Sc. in Computer Science from the KULeuven. He comes originally from Flanders, but moved to Norway in 1997 and lives now with his family in Kolss near Oslo.

Francesco Cesarini

• Styling your Architecture in an Evolving Concurrent World

Francesco Cesarini is the founder and Technical Director of Erlang Training and Consulting. He is also a co‐author of Erlang Programming, a book published by OReilly Media. Having started his career as an intern at Ericsson's computer science lab, the birth place of Erlang, and has used the language on a daily basis for the last 15 years. He has worked with flagship Erlang projects both within and outside of Ericsson, including the R1 release of the OTP middleware and the AXD301 Switch. He has taught Erlang/OTP to hundreds of professionals and undergraduate students alike. Soon after Erlang was released as Open Source, he founded Erlang Training and Consulting. With offices in the UK, Sweden, Poland (and soon the US), they have become the world leaders in Erlang based consulting, contracting, support, training and systems development. Their client base is spread on five continents and ranges from small start‐ups to blue chip companies. In his role as Technical Director, he is currently leading the research, development and consulting teams. He is active in the Erlang community not only through regularly talks, seminars and tutorials at conferences worldwide, but also through his involvement in international research projects. He organises local Erlang user groups and with the help of his colleagues and runs the Trapexit Erlang community website. ACCU Conference 2010 April 14‐17, 2010. Barcelo Oxford Hotel, Oxford, UK 20 of 30 Gavin Heavyside

• Analysing Large Data Sets ‐ an introduction to MapReduce with Apache Hadoop

Gavin is Senior Software Engineer at Journey Dynamics Ltd, a provider of highly accurate, personalised traffic speed forecasting and driver behaviour analysis. For over 10 years he has written software, mostly in C++, for platforms including mobile phones, PCs and telephone exchanges. At Journey Dynamics he swaps between C++ and Ruby depending on the task at hand, and can be called on to do anything from analysing terabytes of data on a cluster of servers, to fitting the results into kilobytes on embedded devices.

Guy Bolton King

• CouchDB: can we be comfortable without SQL?

Guy Bolton King is an independent software developer with experience of most of the popular curly‐bracket languages, some of the significant‐whitespace languages, and a few of the languages that actually use arrows to point at what happens next. He writes a lot of SQL‐generating and ‐wrangling code.

Hubert Matthews

• Things Developers Can Learn From System Test

James Bach

• The Case Against Test Cases

James Bach has been a test manager or consulting tester since Apple lured him from a programming career in 1987. He spent about 10 years in Silicon Valley before going independent and traveling the world teaching rapid software testing skills. He has also served as an expert witness in court cases involving testing. James passion is to teach testers to think, which is why he strongly opposes thoughtless programs such as ISTQB tester certification (and every other certification program currently out there). He is the author of Lessons Learned in Software Testing, and a new book: Secrets of a Buccaneer‐Scholar, which describes his approach to self‐education.

James Coplien

• Lean Architecture and Agile Software Development

Jim "Cope" Coplien is an Agile consultant and Certified Scrum Trainer in Denmark. He is a co‐founder of the software pattern discipline and introduced the idea of organizational patterns into the software world in the mid‐1990s. His early work exploring the industry's patterns of organization inspired the structural components of Extreme Programming as well as stand‐up meetings in Scrum. Today, he continues to work with Jeff Sutherland, Gabrielle Benefield and Jens stergaard in the Scrum Training Institute to bring Scrum and patterns together. He is co‐chair of the upcoming First Conference on Patterns of Scrum Development, ScrumPLoP. He currently is a partner in Gertrud & Cope in Denmark and in the internationally‐based Scrum Training Institute.

James Reddick

• Wrestling with Giants

James coaches water polo and is Secretary of Polytechnic Water Polo Club, one of the oldest and most famous clubs in the UK. He also has an interest in timetabling and constraint solving.

Jeff Kotula

• Automated Testing of a Medical Imaging Application ACCU Conference 2010 April 14‐17, 2010. Barcelo Oxford Hotel, Oxford, UK 21 of 30 For over 20 years, I have developed desktop and web applications for the mechanical CAD/CAM, telecommunications, and medical imaging (radiology) industry. I also earned a PhD in Software Engineering from the University of Minnesota while working full‐time in industry.

Jeff Sutherland

• Scrum Shock Therapy

Jeff invented Scrum at Easel Corporation in 1993 and worked with Scrum Co‐Creator Ken Schwaber to formalize the Scrum development process at OOPSLA95. In the same year, Sutherland provided Kent Beck all background information on the creation of Scrum to assist him in the creation of eXtreme Programming. XP engineering practices then evolved along with SCRUM and the two leading Agile development processes work well together. Scrum and XP are the most widely used Agile processes worldwide and their creators are authors of the Agile Manifesto. Jeff is Chairman of the Scrum Training Institute and CEO of Scrum, Inc., which is hosted by OpenView Venture Partners. He is Senior Advisor to the venture group and Scrum coach, mentor, and trainer to the venture group and their portfolio companies. Jeff maintains hands on experience with development in many software companies, and participates in project planning and team execution. His last six companies have been laboratories for improvement of Scrum implementations and each have made a unique contribution to the worldwide Scrum community of practitioners.

Jerry E Durant

• Transitioning from Traditional to High‐Speed Agile Testing

Jerry serves as Chairman Emeritus (founder) for The International Institute for Outsource Management, a trade organization dedicated to the assessment, development, and guidance of outsource service providers in the ITO, BPO, Call Center and KPO domain areas. He has authored the Outsourcing Management Body of Knowledge and implemented the only outsource provider viability assessment model Global Star Certification (GSC). GSC examinations have been conducted since 1988 in over 70 countries and for over 200 companies. Jerrys in‐depth knowledge includes extensive expertise in global information technology deployment, outsource provider assessment, contract negotiation, arbitration and risk mitigation, service delivery management and governance, and retrosourcing. IIOM in conjunction with Certellus Corporation maintains a Research and Development Center and the Business Engineering Institute (BEI), serving as a catalyst for industry guidance are under Jerrys direction. Jerry holds multiple technical certifications and established the first certification dedicated to the recognition of special nature of managing outsourced projects (Certified Outsource/Offshore Project Manager‐COOPM). With over 30 years of Information Technology experience Jerry is a widely regarded for his talents not only in IT but also in business and a consummate innovator in outsourcing.. He is widely known and respected in the industry frequently speaking at international technology and outsourcing symposiums. Jerry serves as Senior Advisor for Global Outsourcing for the Beijing Association for Software Sourcing (BASS), Boco Soft, and the Outsourcing Institute, and Council Member for China Import‐Export Software Magazine. He has appeared on CCTV9 International and Yantai TV, and has been the honor guest with the Beijing Chamber of Commerce, Qingdao & Yantai Municipal government mayoral offices. Jerry is recognized as an innovator and leader in advancing improvements in the outsourcing, information technology and business process sectors. His forward thinking has helped to develop companies around the globe. This includes innovation in outsourcing delivery, agile engineering, software reuse, SAP risk remediation and software test technologies. Pre‐IIOM: Jerry worked as Division Director Software Test Engineering for AT&T reporting to Chairman Olsen. With a staff of over 350+ professional engineers Jerrys organization was instrumental in post‐divesture testing of large scale corporate and commercial application solutions. As a technology advisor Jerry supported technology assessment and reformulation for Legislatures in the State of Maine and New Hampshire ‐ USA. Engaged to serve in assessing and recommending quality improvement for global in Asia, South America, Africa, Middle East and Europe (70 countries). Worked with Drs. Kemeny & Kurtz Dartmouth College on the first BASIC Compiler. Jerrys work was recognized by Dartmouth College for compiler level program excellence (1968).

Jez Higgins

• Wrestling with Giants

ACCU Conference 2010 April 14‐17, 2010. Barcelo Oxford Hotel, Oxford, UK 22 of 30 Jez sits in his attic and types for a living. He's allowed out occasionally to walk the dogs or ride his bike.

John Lakos

• Writing "Good" Component‐Level Test Drivers

John Lakos, author of "Large Scale C++ Software Design.", serves at Bloomberg LP in New York City as a senior architect and mentor for C++ Software Development world‐wide. Previously, Dr. Lakos directed the design and development of infrastructure libraries for proprietary analytic financial applications and later for Global Information Technologies at Bear Stearns. For 12 years prior, Dr. Lakos developed large frameworks and advanced ICCAD applications at Mentor Graphics, for which he holds multiple software patents. His academic credentials include a Ph.D. in Computer Science ('97) and an Sc.D. in Electrical Engineering ('89) from Columbia University. Dr. Lakos received his undergraduate degrees from MIT in Mathematics ('82) and Computer Science ('81).

Jon Jagger

• Code Archelogy ‐ stories from a real codebase

Jon Jagger is an independent software consultant based in England. He is specializing in agile software development (people and process), test driven development, deliberate practice, design, analysis, OO, UML and curly bracket languages. He also loves freshwater fishing.

Jonathan Wakely

• Abusive C++

Jonathan Wakely is a programmer in the financial sector and has been working with C++ and UNIX for 10 years. He is a contributor to GCC's implementation of the C++ standard library and participates in the panel which represents the UK on the C++ standards committee. When not writing software, reading about software, teaching people about software, or arguing with people about software, he's usually sleeping.

Juha-Pekka Tolvanen

• Defining Domain‐Specific Modelling Language ‐ Hands‐on

Juha‐Pekka Tolvanen is the CEO of MetaCase. He has been involved in model‐driven approaches, metamodeling, and domain‐specific modelling languages and tools since 1991. He has acted as a consultant worldwide on modelling language and code generator development. Juha‐Pekka has authored a book on Domain‐Specific Modelling (Wiley 2008) and written over sixty articles for software development magazines and conferences. He holds a Ph.D. in computer science and he is an adjunct professor at the University of Jyvaskyla, Finland.

Jutta Eckstein

• Creating Proximity over a Distance

Jutta Eckstein, a partner of IT communication, is an independent consultant and trainer from Braunschweig, Germany. Her know‐how in agile processes is based on over ten years experience in developing object‐oriented applications. She has helped many teams and organizations all over the world to make the transition to an agile approach. She has a unique experience in applying agile processes within medium‐sized to large distributed mission‐critical projects. This is also the topic of her already published book Agile Software Development in the Large and of the one she's currently writing on 'Agile Software Development with Distributed Teams'. Besides engineering software she has been designing and teaching OT courses in industry. Having completed a course of teacher training and led many 'train the trainer' programs in industry, she focuses also on techniques which help teach OT and is a main lead in the pedagogical patterns project. She has presented work in her main areas at ACCU (UK), JAOO (Denmark), OOPSLA (USA), SD West, SD Best Practices (both USA), XP (Europe) and Agile (USA). ACCU Conference 2010 April 14‐17, 2010. Barcelo Oxford Hotel, Oxford, UK 23 of 30 Karl Scotland

• 5 Steps to Kanban

Karl Scotland is a versatile software practitioner with over 15 years of experience covering development, project management, team leadership, coaching and training. For the last 10 years he has been successfully applying Agile methods, and most recently has been a pioneer and advocate of using Kanban Systems for software development. Currently a Lean and Agile Coach with EMC Consulting, Karl has previously championed Agile and Lean Thinking with the BBC and Yahoo!

Kevlin Henney

• The Uncertainty Principle • Objects of Value

Kevlin Henney is an independent consultant and trainer who specialises in programming languages and techniques, OO design, patterns, software architecture and agile development. He is co‐author of A Pattern Language for Distributed Computing and On Patterns and Pattern Languages, two volumes in the Pattern‐Oriented Software Architecture series. He is a past, present and (undoubtedly) future columnist and contributor for many publications, both online and on tree. Kevlin is also a long‐standing member of the ACCU and a regular speaker at ACCU conferences.

Klaus Marquardt

• Patterns for performance tuning

Klaus Marquardt works for Drger Medical in international projects building life supporting devices. He is particularly interested in the integration of different software worlds and attitudes, and in the mutual influences of technology, humans, processes, and organization. In the late 1990'ies he started to publish patterns, in particular about extensible architectures, performance tuning, and diagnoses of systems and organisations. He has run sessions at many conferences including OOPSLA, JAOO, OOP, and ACCU, and served as program chair of EuroPLoP 2004.

Lisa Crispin

• Using the Agile Testing Quadrants to Cover Your Testing Bases

Lisa Crispin is an agile testing coach and practitioner. She is the co‐author, with Janet Gregory, of Agile Testing: A Practical Guide for Testers and Agile Teams (Addison‐Wesley, 2009). She works as the Director of Agile Software Development, at Ultimate Software. Lisa specializes in showing testers and agile teams how testers can add value and how to guide development with business‐facing tests. Lisa joined her first agile team in 2000, having enjoyed many years working as a programmer and tester. From 2003 until 2009, she was a tester on a Scrum/XP team at ePlan Services, Inc. She's currently a tester and ScrumMaster with a Scrum/Kanban/XP team at Ultimate. She frequently leads tutorials and workshops on agile testing at conferences in North America and Europe. Lisa regularly contributes articles about agile testing to publications such as Better Software magazine, IEEE Software, and Methods and Tools. Lisa also co‐authored Testing Extreme Programming (Boston: Addison‐Wesley, 2002) with Tip House. For more about Lisas work, visit www.lisacrispin.com.

Mark Dalgarno

• Get Clojure!

Mark Dalgarno has worked in the software industry for over twenty years at companies both large and small at all levels from programmer to head of software development. Mark works for specialist software consultancy Software Acumen with a focus on Software Architecture, Model Driven Software Development, Software Product Lines and Software Process improvement. Mark is also founder of the Model Driven Software Network and organises its associated Code Generation conference series and founder of Software East and organises its regular sessions in Cambridge, UK. ACCU Conference 2010 April 14‐17, 2010. Barcelo Oxford Hotel, Oxford, UK 24 of 30 Mauro Talevi

• A Year of Misbehaving ‐ A Retrospective on using BDD in a commercial enterprise

Mauro Talevi works for Agilesque, an independent consultancy specialising in Agile coaching and development. He's helped enterprises deliver complex and large projects by introducing Agile practices and tools, believing that the best results can be achieved by bringing together the right ideas with the appropriate tools to implement them. He's active in numerous open‐source project, more recently contributing to the core development of JBehave.

Michael Stal

• Architecture Refactoring ‐ Motivation, Approach and Patterns

Michael Stal is a Principal Engineer at Siemens Corporate Technology, editor‐in‐chief of JavaSPEKTRUM as well as a Microsoft MVP. His main interests include software architecture, distributed systems and programming languages. In his daily work he is mentoring and coaching projects on these topics. Recently, Michael has been involved in establishing a Software Architect certification program within Siemens. He was co‐author of several books such as the Pattern‐ Oriented Software Architecture series.

Nat Pryce

• TDD at the System Scale

Nicolai Josuttis

• The C++0x Standard Library

Olve Maudal

• Code Archelogy ‐ stories from a real codebase • Solid C++ Code by Example

Olve Maudal works for TANDBERG, the leading provider for telepresence and video conferencing products and solutions. He loves to write code, but is just as interested in how software is developed as what it actually does. Olve is also an active member of the vibrant geek community in Oslo where he is involved in JavaPils, Cantara, XP Meetup, Oslo C++ Users Group, Lean Meetup and a few other things.

Patrick Kua

• Building the Testing Pipeline

Patrick works as an agile practitioner, coach and technical leader for ThoughtWorks UK. His interests focus on blending excellence in technical and team aspects, drawing upon agile practices to help align business and IT capabilities. He is particularly passionate about continuous improvement, learning and has presented at a wide variety of conferences including Javazone, Agile North, the XP200x series of conferences and Agile 2009.

Paul E. Black

• The Role of Static Analysis in Software Development

Dr. Black has nearly 20 years of experience in areas such as developing software for IC design and verification, assuring software quality, and managing business data processing. He is now a Computer Scientist for the U.S. National Institute of Standards and Technology (NIST) in the Systems and Software Division of the Information Technology Laboratory. His on‐line Dictionary of Algorithms and Data Structures (http://www.nist.gov/dads/) is accessed thousands of times a day. Dr. Black earned a B.S. in Physics and Mathematics in 1973 and an M.S. in Computer Science in 1983. He began his Ph.D. at ACCU Conference 2010 April 14‐17, 2010. Barcelo Oxford Hotel, Oxford, UK 25 of 30 UC Berkeley, then transferred to Brigham Young University where he graduated in 1998. He has taught classes at Brigham Young University and Johns Hopkins University. Dr. Black has published in software testing, configuration control, formal methods, software verification, quantum computing, and computer forensics. He is a member of ACM, IEEE, and the IEEE Computer Society.

Paul Field

• Change, change, change ‐ the 5 year evolution of an Agile team

Paul Field is team lead, architect, developer and general troublemaker on Deutsche Bank's Fusion system, which provides data integration, calculation and web sites for the Company Research division. Paul has been programming since he was 11, been an ACCU member for over 10 years and used to run ACCU's C Acorn User Group. He has been doing Agile development for about 8 years.

Paul Grenyer

• Enterprise Web Application Development in Java with AJAX and ORMs

Paul has been programming in one form or another for over 20 years. After several years using C++ and a brief period using C#, Paul is now happy somewhere he hoped he'd never be, programming in Java. After time in industries such as marking machinery, direct mail, mobile phones, investment banking and Internet TV, Paul is currently working for an exciting new insurance industry based startup in Norwich where he heads up an ever growing team of senior and highly skilled people. He has been an ACCU member since 2001, a regular publications contributor, including the now well established Desert Island Books column, creator of the mentored developers and a committee member for most of that time. When he's not programming and family life allows, Paul thoroughly enjoys science fiction, heavy metal and cycling.

Pete Goodliffe

• iPhone development • Stood at the bottom of the mountain looking up

Pete owns some shoes. But won't wear them.

Peter Sommerlad

• Simple Software ‐ Regain Control through Decremental Development

Peter Sommerlad is professor and head of Institute for Software at HSR Rapperswil. Peter is co‐author of Pattern‐ oriented Software Architecture Vol.1 and Security Patterns. His long‐term goal is to make software simpler by Decremental Development: Refactoring software down to 10% its size with better architecture, testability and quality and functionality.

Phil Nash

• iPhone development

Phil Nash has worked in the software industry for over sixteen years, usually in developer or architect roles, in areas from servers and grids to desktop applications to embedded devices, on projects from a one man team to a team of over twenty in size and for organizations from five persons to internationally recognised names and has worked in numerous countries across three continents. Whilst having tried his hand at many areas of application he has always come back to and specialized in the C and C++ family of languages. More recently he has crossed over to Objective‐C and successfully launched a game for the iPhone and iPod touch.

ACCU Conference 2010 April 14‐17, 2010. Barcelo Oxford Hotel, Oxford, UK 26 of 30 Richard Harris

• You're Going To Have To Think! Why [Insert Technique Here] Won't Cure Your Floating Point Blues. • Abusive C++

Richard Harris has been writing software for financial regulation for the last decade or so, principally in C++. Coming from an academic background in mathematics and artificial intelligence he has a keen interest in numerical computing. And cats. He's very fond of cats.

Robert Martin

• The Language Stew

Robert C. Martin (Uncle Bob) has been a software professional since 1970 and is founder and president of Object Mentor Inc., in Gurnee, Illinois. Object Mentor, Inc., is an international firm of highly experienced software developers and managers who specialize in helping companies get their projects done. Object Mentor offers process improvement consulting, object‐oriented software design consulting, training, and skill development services to major corporations worldwide. Mr. Martin has published dozens of articles in various trade journals, and is a regular speaker at international conferences and trade shows. Mr. Martin has authored and edited many books including: * Designing Object Oriented C++ Applications using the Booch Method * Patterns Langauages of Program Design 3 * More C++ Gems * Extreme Programming in Practice * Agile Software Development: Principles, Patterns, and Practices. * UML for Java Programmers * Clean Code A leader in the industry of software development, Mr. Martin served three years as the editor‐in‐chief of the C++ Report, and he served as the first chairman of the Agile Alliance.

Roger Orr

• A Simple Matter of Configuration" ‐ how can we tame the complex world of configuration?

I have over 20 years experience in IT, using a variety of languages and platforms and have experienced working for a number of different companies over the years. In 1989 I became a contract computer programmer and have successfully managed to remain at the technical end of IT ever since; my recent work has mostly been in C++ and Java, on Windows and Linux. I have been a member of ACCU since 1999; I currently run the Code Critique section of CVu and also write the occasional article. I've joined several projects over the years where configuring the software to run was so hard it was a couple of weeks before I had a functioning development environment and have also spent more time than I'd like dealing with problems caused by misconfiguration.

Roy Osherove

• Mocking On The Edge Isolation at the system level

Roy Osherove is the author of "The Art of Unit Testing: with Examples in .NET" . Roy is the Chielf Architect at Typemock, and helps designing the next generation of unit testing tools and APIs. For over a decade roy has consulted and worked in teams producing software used by real people. He's the founder of Agile Israel and speaks at many conferences around the world including Microsoft TechEd, JAOO, NDC and more. Roy's blog is at www.ISerializable.com

Russel Winder

• Parallelism: The JVM Rocks

Russel was originally a theoretical particle physicist but decided in 1980 that being a UNIX systems programmer was more fun. However, academia continued to call and he moved to UCL to lecture in programming, software engineering and human‐‐computer interaction, and do research on parallel programming languages and socio‐technical aspects of software development. After 13 years at UCL, Russel moved to KCL to be Professor of Computing Science. Having revamped the teaching programme, continued the research on parallel programming languages, and started research programmes in health informatics, it was time for new challenges so he left KCL to become CTO of OneEighty Software ACCU Conference 2010 April 14‐17, 2010. Barcelo Oxford Hotel, Oxford, UK 27 of 30 Ltd, a company using novel virtual machine approaches to embedded systems. Unfortunately, the money ran out for this start‐up before the orders flooded in and so it had to fold. Since then, Russel has been a consultant, analyst, trainer (Java SE, Java ME, Groovy and Python) and author ("Developing Java Software" third edition, and "Python for Rookies"). The recent rise of multicore processors means that parallelism has finally arrived (after 30 years of being the coming technology), so Russel with two colleagues started a new consultancy practice (Concertant LLP) undertaking consultancy, analysis and management work in all areas of parallelism and concurrency. Russel is centrally involved with the development of the Groovy programming language and the GParallelizer framework, is author of the Gant Ant task scripting framework, and contributes to the Gradle and SCons build frameworks.

Schalk Cronje

• The Cost of Agile Testing

Schalk Cronje has 20 years of experience in the software industry. He has delivered software as products and services with delivery cycles between 2 weeks and 12 months. He currently manages a software group within McAfee Labs which is responsible for codification of business process, automating malware detection and providing business intelligence. Besides delivering business value, he focuses on helping software engineers realise their true potential and challenge the dysfunctionality that besets many institutionalised software processes.

Seb Rose

• Googletest and Googlemock C++ libraries

Sergey Ignatchenko

• Importance of Early Bug Detection for Improving Program Reliability and Reducing Development Costs

Sergey Ignatchenko has experience in senior team‐lead / architect / consultant positions for more then 12 years, for companies ranging from start‐ups to giants like 3Com and IBM. He is an author of several patent applications as well as of several publications on C/C++, including "STL Implementations and Thread Safety" in "C++ Report", and "Some Opportunities to Increase STL Efficiency" in "Overload" (the latter article and subsequent discussion with A.Stepanov and B.Fomitchev has supposedly inspired introduction of move_traits<> into STL). Currently Sergey Ignatchenko is working with Blue Whale Software, an innovative company which aims to make software better, and on this way tends to question most of common wisdoms both in programming and software development management areas.

Stephen Blair-Chappell

• Developing Unit Tests for Multicore programs

Stephen Blair‐Chappell is a Senior Software Engineer & Technical Evangelist at Intel, and has worked in the Intel Compiler Lab for the last 12 years. He is a regular speaker at technical conferences in Europe and the US. Prior to joining Intel, Stephen worked as a lecturer at the Birmingham City University, specializing in Software Engineering and Embedded Systems. As an academic he developed and delivered CPU architecture programming courses for a number of silicon and software manufacturers. Outside work, Stephen enjoys playing the pipe organ, and is an accomplished musical instrument restorer.

Steve Freeman

• TDD at the System Scale

Steve is a pioneer of Agile software development in the UK, he has built applications for banks, ISPs, financial data providers, and specialist software companies. He has given training courses in Europe , America, and Asia. Previously, he worked in research labs, software houses, earned a PhD, and wrote shrink‐wrap software. Steve also teaches in the Computer Science department at University College London. He is a presenter and organizer at international industry conferences, and was conference chair for the first London XpDay. ACCU Conference 2010 April 14‐17, 2010. Barcelo Oxford Hotel, Oxford, UK 28 of 30 Steve Love

• Genemodulabstraxibilicity

Steve Love is a freelance software developer who has never written a compiler, but has written a (very small) operating system, of which he was once very proud. He now works on the periphery of the finance industry, writing C++, C# and Python code when he can. He can be contacted on [email protected]

Stewart Brodie

• Encodings: Decoded & Demystified

Stewart works for ANT Software Limited, leading a team of engineers implementing a web browser platform for digital media devices. He also participates in standardisation activities at the World Wide Web consorti= um, the Open IPTV Forum and the Hybrid Broadband TV group.

Sven Rosvall

• Database Testing Demystified • Data warehouse, OLAP, Data Cubes, Business Intelligence ‐ Buzzwords explained

Sven has a long career in many markets and technologies. He has a keen interest in quality and passionate about Agile methods. He has recently got involved with databases as a designer and integration developer in projects using several different database engines and development environments.

Tom Gilb

• Real QA ‐ the argument for smarter quality assurance than mere testing

Tom started his career at IBM in 1958. In 1960 he founded his own company and has been a business consultant ever since. He pioneered the evolution of iterative development, and his classic book "Principles of Software Engineering Management" (1988)now in 20th printingis explicitly credited by Kent Beck and other agile method leaders as the source of short development cycles and many other ideas in development of the agile methods. Currently he works as a consultant and trainer for companies in a wide range of industriesfrom product development to financial serviceslocated all over the world. When in London, he can often be found at the Extreme Tuesday Club (XTC)the main meeting point of the London agile community (www.xpdeveloper.net). You can find more information about Tom (along with free articles and books) at www.gilb.com.

Tony Barrett-Powell

• Coupling as resistance to change, understanding and fixing it

Tony Barrett‐Powell has been involved in software development since 1990, mainly working as a practitioner in C, C++ and Java languages focused on object orientated techniques. Tony has a strong interest in the process of software development and the techniques to make software more maintainable as he mostly works on software across many releases. For the last 4 years Tony has been working in a team maintaining and augmenting a business intelligence application which has much legacy code in need of careful and considered improvement. Ulf Wiger

• Message‐passing Concurrency in Erlang

Walter Bright

• Compiler Construction

ACCU Conference 2010 April 14‐17, 2010. Barcelo Oxford Hotel, Oxford, UK 29 of 30 Walter Bright graduated from Caltech in 1979 with a degree in mechanical engineering. He worked for Boeing for 3 years on the development of the 757 stabilizer trim system. He then switched to writing software, in particular compilers, and has been writing them ever since. He has written compilers for ABEL, C, C++, Java, Javascript, and is the lead developer of the D programming language and its compiler.

Will Stott

• Developing Unit Tests for Multicore programs

Will Stott is a cancer researcher at the Institute for Women's Health, University College London working on the development of an automated classification system for ovarian ultrasound scans. He has more than 20 years experience of software development using C, C++ and C# and has worked for a wide variety of companies in the UK and Europe. Will is the author of numerous articles about software development and co‐wrote the book Visual Studio Team System ‐ Better Software Development for Agile Teams (Addison Wesley, 2007).

ACCU Conference 2010 April 14‐17, 2010. Barcelo Oxford Hotel, Oxford, UK 30 of 30