papers

PP01 Paper Presentation: Experience Reports

Session Chair: David Hussman

Lean Software Management Case Study: Timberline Inc. by Peter Middleton, Amy Flaxel, Ammon Cookson
This paper is believed to be the first documented account of a full adoption of lean by a software company. Lean techniques were devised by Toyota and other manufacturers over the last 50 years. The techniques are termed lean because they require less resource to produce more product and exceptional quality. Lean ideas have also been successful in service industries and product development. Applying lean to software has been advocated for over 10 years. Timberline, Inc started their lean initiative in Spring 2001 and this paper records their journey, results and lessons learned up to Fall 2003. This case study demonstrates that lean thinking can work successfully for software developers. It also indicates that the extensive lean literature is a valuable source of new ideas for software engineering.

XP South of the Equator: An Experience Implementing XP in Brazil by Alexandre Freire, Fabio Kon, Cicero Torteli
Many have reported successful experiences using XP, but we have not yet seen many experiences adapting agile methodologies in developing countries such as Brazil. In a developing economy, embracing change is extremely necessary. This paper relates our experience successfully introducing XP in a start-up company in Brazil. We will cover our adaptations of XP practices and how cultural and economical aspects of the Brazilian society affected our adoption of the methodology. We will discuss how we managed to effectively coach a team that had little or no previous skill of the technologies and practices adopted. We will also cover some new practices that we introduced mid-project and some practices we believe emerged mostly because of Brazilian culture. The lessons we learned may be applicable in other developing countries.

Introducing Extreme Programming into a Software Project at the Israeli Air Force by Yael Dubinsky, Orit Hazzan, Arie Keren
Introducing Extreme Programming (XP) to an industrial software development team usually involves technical and professional aspects as well as social and organizational ones. The introducing of a new software development method in general and XP in particular into a software project team that operates in the army emphasizes and extends these issues. In this paper we present a process through which XP has been introduced into a 60-members software development project at the Israeli Air Force. Focus is placed on an XP workshop conducted with ten officers who worked at different teams of the project. Specifically, we present the principles according to which we facilitated the workshop, the workshop agenda and data regarding the way the participants perceive some of the XP practices. Recently, the first XP team in this project has started to work the XP way.

The Agile Journey: Adopting XP in a Large Financial Services Organization by Jeff Nielsen, Dave McMunn
On January 14, 2004, two vice presidents met with a group of directors, project managers, and developers, and indicated their desire to embrace agile software development as “the way forward” in their organization. This was not the beginning of this company’s adoption of XP and Agile Methodologies, but rather the culmination of almost two and a half years of learning, experimentation, prototyping, and promotion. Making change “stick” in any large organization is problematic, and dramatically changing the way a risk-averse, highly-regulated company develops software requires more than just a successful pilot and a couple of months of coaching. This experience report documents the “agile journey” undertaken by one such corporation between 2001 and 2004. They began by outsourcing a small effort to an XP-proficient consulting firm, and proceeded to use agile techniques on a series of increasingly-significant efforts, allowing sufficient time for the new approach to gain acceptance. In retrospect, all parties involved now believe that the slow, gradual approach to XP adoption–building on incremental successes project by project–was the key to its success.

PP02 Paper Presentation: New Insights

Session Chair: Sandro Pinna

From User Stories to Code in One Day? by Michal Smialek
User stories in software engineering serve the purpose of discovering requirements and are used as units of system development. When applying stories in a project, two elements seem to be crucial: the ability to write coherent sequences of events and the ability to transform these sequences into code quickly and resourcefully. In this paper, these qualities are reflected in a notation that can be described as “stories with notions”. This notation separates the story’s sequence of events from the description of terms used in this sequence. Such a formal separation does not limit and rather enhances invention, at the same time rising the level of consistence, and facilitating translation into models of code. This translation maps domain notions into static code constructs (classes, interfaces) and also maps stories into dynamic sequences of messages. With such a mapping, programming becomes equivalent to skilled transformation of user stories, thus giving shorter development cycles.

Evaluate XP Effectiveness using Simulation Modeling by Alessandra Cau, Giulio Concas, Marco Melis, Ivana Turnu
Effectively evaluating the capability of a software development methodology has always been very difficult, owing to the number and variability of factors to control. Evaluating XP is by no way different under this respect. In this paper we present a simulation approach to evaluate the applicability and effectiveness of XP process, and the effects of some of its individual practices. Such approaches using simulation are increasing popular because they are inexpensive and flexible. Of course, they need to be calibrated with real data and complemented with empirical research. The XP process has been modelled and a simulation executive has been written, enabling to simulate XP software development activities. The model follows an object-oriented approach, and has been implemented in Smalltalk language, following XP process itself. It is able to vary the usage level of some XP practices and to simulate how all the project entities evolve consequently.

Agile Security using an Incremental Security Architecture by Howard Chivers, Richard Paige, Xiaocheng Ge
The effective provision of security in an agile development requires a new approach: traditional security practices are bound to equally traditional development methods. However, there are concerns that security is difficult to build incrementally, and can prove prohibitively expensive to refactor. This paper describes how to grow security, organically, within an agile project, by using an incremental security architecture which evolves with the code. The architecture provides an essential bridge between system-wide security properties and implementation mechanisms, a focus for understanding security in the project, and a trigger for security refactoring. The paper also describes criteria that allow implementers to recognize when refactoring is needed, and a concrete example that contrasts incremental and ‘top-down’ architectures.

Quantifying Requirements Risk by Fred Tingey
It is possible to apply Information Theory to the Software Development process – an approach I have dubbed ‘Iterative Theory’. Focusing on the user requirements Iterative Theory is introduced and then used to quantify how the choice of development methodology affects the ‘value at risk’ on a software project. The central theme is that end-user requirements cannot be described exactly resulting in an inherent uncertainty in the correctness of any specification. This uncertainty can only be removed by receiving feedback on working software. Iterative Theory assumes that every requirement is expressed in terms of empirical tests thus it is possible to speak of working software as an implementation that passes all of its tests – although it may still fail end user acceptance testing. The implication of changing requirements is touched upon; this simply bolsters the argument for Iterative Development as a way of reducing risk. Iterative Theory, the application of Information Theory to the software development process, is certainly an area requiring further study.

PP03 Paper Presentation: Testing

Session Chair: Charlie Poole

A Survey of Test Notations and Tools for Customer Testing by Adam Geras, James Miller, Michael Smith, James Love
The term ‘customer testing’ typically refers to the functional, or correctness testing of software-intensive systems. The tests are typically described and automated in a test-first manner, that is, they exist before the target system is built. This is generally believed to have improved the testability, and perhaps the overall quality, of the systems under test. With the increasing utility and functionality of mobile and pervasive computing systems, we speculate that the need to include non-functional test cases (performance, security, usability, etc.) under the ‘test-first’ umbrella will increase. In this paper, we review the capability of existing test notations and tools to describe and execute, in a test-first style, non-functional test cases. This concept challenges the default agile position of delegating non-functional tests cases to traditional, test-last test techniques.

Testing with Guarantees and the Failure of Regression Testing in eXtreme Programming by Anthony Simons
The eXtreme Programming (XP) method eschews all formal design, but compensates for this by rigorous unit testing. Test-sets, which constitute the only enduring specification, are intuitively developed and so may not be complete. This paper presents a method for generating complete unit test-sets for objects, based on simple finite state machines. Using this method, it is possible to prove that saved regression test-sets do not provide the expected guarantees of correctness when applied to modified or extended objects. Such objects, which pass the saved tests, may yet contain introduced faults. This puts the whole practice of regression testing in XP into question. To obtain the same level of guarantee, tests must be regenerated from scratch for the extended object. A notion of guaranteed, repeatable quality after testing is defined.

Examining Usage Patterns of the FIT Acceptance Testing Framework by Kris Read, Grigori Melnik, Frank Maurer
Executable acceptance testing allows both to specify customers’ expectations in the form of the tests and to compare those to actual results that the software produces. The results of an observational study identifying patterns in the use of the FIT acceptance testing framework are presented and the data on acceptance-test driven design is discussed.

Agile Test Composition by Rick Mugridge, Ward Cunningham
Storytests in storytest driven development serve two interrelated goals. On the one hand, they are used to formulate and communicate business rules. On the other, they are used to verify that a story has been completed and that it hasn’t been subsequently broken. There is a small conflict between these views. For their communicative role, storytests are better to be concise and independent. For automated testing, speed is important in providing fast feedback, and so it makes sense to combine storytests. We show how this conflict can be avoided by automatically combining storytests. Hence the value of storytests for defining the needs of the system is not diminished when it comes to automated testing.

PP04 Paper Presentation: Social Issues

Session Chair: Michael Hill

Social Perspective of Software Development Methods: The Case of the Prisoner Dilemma and Extreme Programming by Orit Hazzan, Yael Dubinsky
One of the main dilemmas with which software development teams face is how to choose a software development method that suits the team as well as the organization. This article suggests a theory that may help in this process. Specifically, Extreme Programming (XP) is analyzed within the well known framework of the prisoner dilemma. We suggest that such an analysis may explain in what situations XP may fit for implementation and, when it is used, the way it may support software development processes.

A Framework for Understanding the Factors Influencing Pair Programming Success by Mustafa Ally, Fiona Darroch, Mark Toleman
Pair programming is one of the more controversial aspects of several Agile system development methods, in particular eXtreme Programming (XP). Various studies have assessed factors that either drive the success or suggest advantages (and disadvantages) of pair programming. In this exploratory study the literature on pair programming is examined and factors distilled. These factors are then compared and contrasted with those discovered in our recent Delphi study of pair programming. Gallis et al. (2003) have proposed an initial framework aimed at providing a comprehensive identification of the major factors impacting team programming situations including pair programming. However, this study demonstrates that the framework should be extended to include an additional category of factors that relate to organizational matters. These factors will be further refined, and used to develop and empirically evaluate a conceptual model of pair programming (success).

Empirical Study on the Productivity of the Pair Programming by Gerardo Canfora, Aniello Cimitile, Corrado Aaron Visaggio
Many authors complain the lack of empirical studies which assess the benefits and the drawbacks of agile practices. Particularly, pair programming rises an interesting question for managers: does pair programming mean to pay two developers in the place of one? We realized an experiment to compare the productivity of a developer when performing pair programming and when working as solo programmer. We obtained empirical evidence that pair programming decreases the effort of the single programmer.

The social side of technical practices by Hugh Robinson, Helen Sharp
XP is a social activity as well as a technical activity. The social side of XP is emphasized typically in the values and principles which underlie the technical practices. However, the fieldwork studies we have carried out with mature XP teams have shown that the technical practices themselves are also intensely social: they have social dimensions that arise from and have consequences for the XP approach. In this paper, we report on elements of XP practice that show the social side of several XP practices, including test-first development, simple design, refactoring and on-site customer. We also illustrate the social side of the practices in combination through a thematic view of progress.

PP05 Paper Presentation: Tools

Session Chair: Yael Dubinsky

E-TDD — Embedded Test Driven Development: A Tool for Hardware-Software Co-design Projects by Michael Smith, Andrew Kwan, Alan Martin, James Miller
Test driven development (TDD) is one of the key Agile practices. A version of CppUnitLite was modified to meet the memory and speed constraints present on self-contained, high performance, digital signal processing (DSP) systems. The specific characteristics of DSP systems required that the concept of refactoring be extended to include concepts such as ‘refactoring for speed’. We provide an experience report describing the instructor-related advantages of introducing an embedded test driven development tool E-TDD into third and fourth year undergraduate Computer Engineering Hardware-Software Co-design Laboratories. The TDD format permitted customer (instructor) hardware and software tests to be specified as ‘targets’ so that the requirements for the components and full project were known ‘up-front’. Details of CppUnitLit extensions necessary to permit tests specific for a small hardware-software co-design project, and lessons learnt when using the current E-TDD tool, are given. The next stage is to explore the use of the tool in an industrial context of a video project using the hybrid communication-media (HCM) dual core Analog Devices ADSP-BF561 Blackfin processor.

Multi-criteria detection of bad smells in code using UTA method by Bartosz Walter, Blazej Pietrzak
Bad smells are indicators of inappropriate code design and implementation. They suggest a need for refactoring, i.e. restructuring the program towards better readability, understandability and eligibility for changes. Smells are defined only in terms of general, subjective criteria, which makes them difficult for automatic identification. Existing approaches to smell detection base mainly on human intuition, usually supported by code metrics. Unfortunately, these models do not comprise the full spectrum of possible smell symptoms and still are uncertain. In the paper we propose a multi-criteria approach for detecting smells adopted from UTA method. It learns from programmer’s preferences, and then combines the signals coming from different sensors in the code and computes their utility functions. The final result reflects the intensity of an examined smell, which allows the programmer to make a ranking of most onerous odors.

An Eclipse Plugin to Support Agile Reuse by Frank McCarey, Mel O Cinneide, Nicholas Kushmerick
Reuse in an Agile context is largely an unexplored research topic. On the surface, these two software engineering techniques would appear to be incompatible due to contradictory principles. For example, Agile components are usually accompanied with little or no support materials, which is likely to hamper their reuse. However we propose that Agile Reuse is possible and indeed advantageous. We have developed an Eclipse plug-in, named RASCAL, to support Agile Reuse. RASCAL is a recommender agent that infers the need for a reusable component and proactively recommends that component to the developer using a technique consistent with Agile principles. We present the benefits and the challenges encountered when implementing an Agile Reuse tool, paying particular to attention to the XP methodology, and detail our recommendation technique. Our overall results suggest RASCAL is a promising approach for enabling reuse in an Agile environment.

Automated Acceptance Testing: Expressing Requirements as Tests by Robert Martin
One of the keystones of the Agile Methods is automated acceptance testing. In Agile Projects requirements are expressed as executable tests. These tests are written in a high level language that is easily understood by business analysts and stakeholders. The tests are written by collaboration between the business analysts, QA, and the developers. These tests are accumulated on an intranet site and can be run by any project stakeholder at any time. The number of tests passing gives a clear indication of what is working, what isn’t working, and how much progress the team is making on a day to day basis. In this talk the speaker demonstrates FitNesse, an open source tool for organizing, expressing and executing acceptance tests. He describes the process for writing and executing these tests, and discusses the experiences of teams that are using this approach.

PP06 Paper Presentation: Case Studies

Session Chair: Daniel Karlström

An Approach for Assessing Suitability of Agile Solutions: A Case Study by Minna Pikkarainen, Ulla Passoja
Dynamic market situation and changing customer requirements generate more demands for the product development. Product releases should be developed and managed in short iterations answering to the rapid external changes and keeping up a high quality level. Agile practices (such as the best practices in Extreme Programming and Scrum) offer a great way of monitoring and controlling rapid product development cycles and release development. One problem in product development projects, however, is how to apply agile methods and principles as a part of the complex product development. The purpose of this paper is to describe, how Agile Assessment was conducted in a case company in order to support product development and customer support improvement. During the experiment it was found that Agile Assessment is an efficient method to clarify what agile practices are suitable for the organization’s product development and customer co-operation. Another finding was that the use of the best suitable agile practices would improve incremental development monitoring and traceability of requirements.

XP Expanded: Distributed Extreme Programming by Keith Braithwaite, Tim Joyce
Colocation has come to be seen as a necessary precondition for obtaining the majority of the benefits of XP. Without colocation teams expect to struggle, to compromise and to trade off the benefits of XP vs the benefits of distributed development. We have found that you can stay true to the principles and not compromise the practices of XP in a distributed environment. Thus, business can realize both the benefits of distributed and of truly agile development.

A Case Study on Naked Objects in Agile Software Development by Heikki Kernen, Pekka Abrahamsson
Naked Objects and agile software development have been suggested to complement each other. Very few empirical studies to date exist where a product has been developed using the Naked Objects technologies in an agile development environment. This study reports results of a case study where a mobile application was developed using the Naked Objects Framework. Qualitative and quantitative data was collected systematically throughout the project. The empirical results offer support for the argument that the Naked Objects approach is suitable for agile software development. The results also reveal weak-nesses in the current Naked Object Framework, namely, that it is not yet mature enough for applications that require intense database operations. The results also show that the development team was able to create an operational user interface just in five hours, which demonstrates the applicability of the Naked Object Framework in practical settings.

posters

Poster and Demonstration Chair: Barbara Russo

A Process Improvement Framework for XP based SMEs by Muthu Ramachandran
Standardization and improvement of processes and practices using XP, FDD and RUP in the Systems Information Area of a Mexican Steel Manufacturing Company by Luis Aceves, Enrique Canseco, Mauricio Ruanova
Multithreading and Web Applications: Further Adventures in Acceptance Testing by Johan Andersson, Geoff Bache, Claes Verdoes
Using State Diagrams to Generate Unit Tests for Object-Oriented Systems by Florentin Ipate, Mike Holcombe
The Positive Affect Of The XP Methodology by Sharifah Syed-Abdullah, Mike Holcombe, John Karn, Marian Gheorge, Tony Cowling
Adjusting to XP: Observational Studies of Inexperienced Developers by John Karn, Tony Cowling, Mike Holcombe, Sharifah Syed-Abdullah
An Agile and Extensible Code Generation Framework by Dimitrios Kolovos, Richard Paige, Fiona Polack
UC Workbench – A Tool for Writing Use Cases and Generating Mockups by Jerzy Nawrocki, Lukasz Olek
Desperately Seeking Metaphor by Ben Aveling
Cash loans online in UK
Agile Testing of Location Based Services by Jiang Yu, Andrew Tappenden, Adam Geras, Michael Smith, James Miller
Source Code Repositories and Agile Methods by Alberto Sillitti, Giancarlo Succi
Writing Coherent User Stories with Tool Support by Michal Smialek, Jacek Bojarski, Wiktor Nowakowski, Tomasz Straszak
BPUF: Big Picture Up Front. by Frank Keenan, David Bustard
Agile Development Environment for Programming and Testing (ADEPT) by Mike Holcombe, Bhavnidhi Kalra
Tailoring Agile Methodologies to the Southern African Environment by Ernest Mnkandla, Barry Dwolatzky, Sifiso Mlotshwa

phdsymposium

Phd and Master’s Symposium

Chair: Sandro Pinna

A Thinking Framework for the Adaptation of Iterative Incremental Development Methodologies by Ernest Mnkandla
Exploring XP’s Efficacy in a Distributed Software Development Team by Alessandra Cau
Agile Methods for Embedded Systems by Dirk Wilking
Tool Support For The Effective Distribution Of Agile Practice – Extended Abstract by Paul Adams
The Software Hut—A Student Experience of Extreme Programming with Real Commercial Clients by Bhavnidhi Kalra, Chris Thomson, Mike Holcombe
Eclipse Platform Integration of Jester—the JUnit test tester by Simon Lever
Extreme Programming: The Genesys Experience by Susheel Varma, Mike Holcombe
Shared Code Repository: A Narrative by Susheel Varma, Mike Holcombe

panels

Panels and Activities

Document Actions

Send this page to somebody
Print this page
Panels and Activities Co-Chairs: David Hussman and David Putman

Panels

P01: Angela Martin, Steven Fraser, Rachel Davies, Mike Holcombe, Rick Mugridge, Duncan Pierce, Tom Poppendieck, Giancarlo Succi: XP/Agile Education and Training

XP/Agile education and training remains a challenge from the perspective of determining relevant content; identifying effective methods for delivery; and maintaining the focus and motivation of students. This panel brings together academic and industry professionals to share their perspectives and experiences. Anticipated points for discussion include: education/training delivery strategies, curriculum definition, certification challenges, marketing issues, collaboration strategies to engage industry sponsorship, value assessments for students and sponsoring organizations, and program success stories. This will be a highly interactive panel and the audience should come prepared to both ask and answer questions.

P02: Steven Fraser, Angela Martin, Mack Adams, Carl Chilley, David Hussman, Mary Poppendieck, Mark Striebeck: Off-Shore Agile Software Development

Off-shore development is increasing in popularity. Off-shoring affects many things in our environment: what and where we build and deploy; how we budget and deliver services; and how and when we communicate. Can the high touch, high bandwidth model that Agile purports be applied to a situation where one of the fundamental tenants – a co-located team – is shattered? This panel will offer a forum to share and learn from industry practitioners and researchers on how to make off-shore software development work in an agile context.

P03: Steve Freeman, Kent Beck, Fred Tingey, John Nolan: Leadership in XP

A panel of expert practitioners will offer advice to members of theaudience on how to address the issues they are facing when applying XP. Theformat is to consider concrete cases, to talk about what we would do in those cases, and discuss the principles behind the actions. The goal is to help theaudience to be more effective in response to their ‘leadership moments’ as theyapply XP.

Activities

A01: Karl Scotland: The Music Of Agile Software Development

A significant number of members of the Agile community seem to have a musical background, leading to a hypothesis that there are commonalities between the two disciplines, both of which draw on diversely skilled individuals, collaborating to create a common vision. While this notion is purely anecdotal and subjective, it is interesting enough to explore further, and this activity session is intended to delve into those commonalities in more detail.

A02: Pascal Van Cauwenberghe, Olivier Lafontan, Ivan Moore, Vera Peeters: The XP Game

The XP Game is a playful way to familiarize the players with some of the more difficult concepts of the XP Planning Game, like velocity, story esti-mation, yesterday’s weather and the cycle of life. Anyone can participate. The goal is to make development and business people work together, they both play both roles. It’s especially useful when a company starts adopting XP.

A03: Vera Peeters, Peter Schrier: The Drawing Carousel: a Pair Programming Experience.

The participants will experience how a pair programming team works. Working in a single pair is different from working on your own: You have to articulate what you want to do, the other person (probably) has some different insights, and the result will be different from what you would have done on your own. But.. this is only half of the story: working in a Pair Programming Team has many more advantages: knowledge is spread, the team creates an own style, parallel development becomes easy, truck factor (http://c2.com/cgi/wiki?TruckNumber) is reduced. The team creates the product (instead of individual programmers creating the parts), the product is a whole, not a mixture of individual results. You will learn about the necessity of agile tools like daily standup meetings, pair rotation, coding standards and collective code ownership, how they work, and what their effects are. You will experience improvements for the quality of you product, and for the productivity of the team.

workshops

Workshop chair: Vera Peeters

W01: Laurent Bossavit, Emmanuel Gaillot: The Coder’s Dojo

If I want to learn Judo, I will enroll at the nearest dojo, and show up for one hour every week for the next two years, at the end of which I may opt for a more assiduous course of study to progress in the art. Years of further training might be rewarded with a black belt, which is merely the sign of ascent to a different stage of learning. No master ever stops learning. If I want to learn object programming… my employer will pack me off to a three-day Java course picked from this year’s issue of a big training firm’s catalog. Nuts to that – acquiring coding skills is not an “instant gratification” process. This workshop proposes to discover a way of teaching and learning programming in a more appropriate manner, respecting the depth and subtlety of the craft. More Info…

W02: Alan Cameron Wills, Steven Kelly: Agile Development with Domain Specific Languages – Part 1
W03: Alan Cameron Wills, Steven Kelly: Agile Development with Domain Specific Languages – Part 2

This workshop will investigate the application of Domain Specific Languages within Agile development. A Domain Specific Language (DSL) is designed to express the requirements and solutions of a particular business or architectural domain. SQL, GUI designers, workflow languages and regular expressions are familiar examples. In recent years, Domain-Specific Modeling has yielded spectacular productivity improvements in domains such as telephony and embedded systems. By creating graphical or textual languages specific to the needs of an individual project or product line within one company, DSM offers maximum agility. With current tools, creating a language and related tool sup-port is fast enough to make DSM a realistic possibility for projects of all sizes. Workshop W02 and W03 are 2 parts of a 1-day workshop, it is best to follow both parts. More Info… See also the workshop website

W04: Pascal Van Cauwenberghe, Marc Evers: The Toyota Way of running IT projects

Toyota has pioneered “Lean Thinking” in the manufacturing world. The “Toyota Production System” has brought powerful tools like “Just In Time”, “Flow”, “Kaizen” into the world.
But the “Toyota Way” is more than a lean production system. It’s a whole philosophy and organisation that keeps learning and improving to keep ahead of the competition in production, product development, quality and sales.
What if Toyota applied their knowledge to IT projects? Are their manufacturing and product development lessons applicable to IT, or are we really that different? This session explores the 14 “Toyota Way” management principles, as described by Jeffrey Liker, to see if they are applicable and useful to the management of IT projects. Participants examine a number of principles in small groups and present their results. More Info…

W05: Laurent Bossavit, Emmanuel Gaillot: Lightning Writing Workshop

All software-related jobs also require writing about software as an ongoing duty, in one form or another – from writing articles evangelizing particular methods or technologies, to writing end user or technical documentation, to writing comments in code. Writing well increases your effectiveness in spreading crucial ideas, and focuses your own thinking as well. Writing is a complex technology in its own right, but it can be mastered through the diligent use of simple practices. This workshop focuses on one such practice, and invites discussion of other practices that develop writing skills. More Info…

W06: Lars Arne Skar, Jan-Erik Sandberg: How to sell the idea of XP to managers, customers and peers

This workshop aims to gather developers with XP experience, project managers and customers. We want this group to share and discuss experiences, thoughts and ideas on starting an XP project with the right foundation. The goal is to enable the participants to bring an understanding of the agile process and the values it gives back to their own organization and customers. In order to do so, we have to understand what is pressing the customer and what she cares about. The organizers have been through several successful processes in delivering the starting and ongoing values of an XP approach, both in their own organization and the customer side. Most of them were used to waterfall and similar approaches. After experiencing more control and confidence in their projects during the agile process, they report back to us with an eagerness to continue and further develop the process. In addition, they experienced a flexibility that they just could not get with their former habits. The most effective way of explaining the benefits of an agile process successfully is to communicate in a way that is meaningful for both the customer and your organization. More Info…

W07: Rachel Davies, Tim Bacon: Informative Workspace

Informative Workspace is one of the new XP practices launched in the second edition of XP Explained. The practice is to build feedback mechanisms around an agile team that support them in their daily work. These feedback mechanisms can take the form of visual displays (Information Radiators) that are manually updated by the team or electronic eXtreme Feedback Devices (XFD) such as lava lamps or audio signals linked to automated processes. It is vital to ensure that feedback mechanisms are easy to interpret, low maintenance and adapted to local practices. This workshop aims to answer how to implement this practice and explore ways to make workspaces more informative. More Info…

W08: Mary Poppendieck, Tom Poppendieck: Agile Contracts; How to develop contracts that support agile software development

Agile Development sounds great, but it depends on the ability to determine the details of scope as the system is developed, driven by feedback from customers and users. Much software development is done under contract, where there is often a requirement to determine the details of the system early in the development process. More Info…

W09: Tim Bacon, Dave Hoover: When Teamwork Isn’t Working

XP is a team game. It relies on teamwork to be successful. But sometimes our teams don’t work as well as we would like. This workshop examines real projects from different angles to explore answers to three powerful questions: – How can we tell that our team isn’t working? – Which are the root causes of our problems? – What actions can we take to improve our teams effectiveness? More Info…

W10: David Putman, David Hussman: The Origin of Value

Many authors have presented techniques for using business value to measure and prioritise requirements. Unfortunately, although there is much written about using value in this way, there is very little written about how to measure value itself. This workshop is intended to help the participants answer questions such as: Where does value come from? How do we know what is valuable and what is not? Who determines value? Are there different types of value and, if so, how can we compare them? More Info…

W11: Geoff Bache, Rick Mugridge, Brian Swan: Hands-on Domain-Driven Acceptance Testing

A recent phenomenon in the world of acceptance testing is tools that emphasize the creation of a domain language in which to express tests. The benefits of this are twofold: customers and testers are more likely to get involved in tests expressed in a language they understand. Also, tests that express intentions rather than mechanics tend to be much easier to maintain in the long run as they do not break when circumstantial things change. The aim of this workshop is to see how tools that support this work in practice. The presenters have each been involved in the development of such a tool, TextTest+xUseCase, Fit+FitLibrary and Exactor, respectively, and there is room for attendees to bring their own tools along too. We aim to learn enough about these tools to compare and contrast them with each other, as well as with agile approaches that are less focussed on the creation of a domain language. More Info…

W12: Pascal Van Cauwenberghe, Marc Evers: I’m not a bottleneck, I’m a free man!

Eliyahu Goldratt’s “Theory of Constraints” is a continuous process improvement method that was developed in the manufacturing world and is now being applied to other industries, among others in IT. In this respect, its history is similar to that of “Lean Thinking”. Where Lean tells you HOW to optimize a system, ToC tells you WHAT to optimize.
The basic insight of ToC is this: every system has ONE constraint (or “bottleneck”) that determines the throughput of the system. If you want to improve the system, you have to find and work on the constraint. The same way you need to strengthen the weakest link if you want to make a chain stronger.
From this idea, ToC derives a program of continuous process improvement steps to increase throughput, by attacking the system’s constraint. These ideas have been developed for manufacturing plants, but, like “Lean Thinking”, they can be applied suprisingly well to software development. ToC? principles have been applied to planning (the “Critical Chain” planning method), to accounting/management decision support (“Throughput Accounting”) and to Systems Thinking (the “Thinking Processes”).
The Theory of Constraints provides a useful model that can be used to measure and predict the costs and return on investment of different processes, including agile methods.
The goal of this workshop is to explore the ideas behind the ToC? method and discover how they can be applied to process improvement, planning and measuring of IT projects. The session contains a mixture of presentation/discussion and small games/simulations that allow the participants to try out the different concepts in small groups. More Info…

W13: Geoff Bache, Rick Mugridge, Brian Swan: Exploring Best Practice for XP Acceptance Testing

A few years ago, Acceptance Testing was one of the more poorly understood concepts of XP, with both tools and advice thin on the ground. This has meant that different people have gone different ways with it and an overview of knowledge gathered in the process has been lacking. The presenters are three such people, each of whom has developed a different tool for acceptance testing: TextTest+xUseCase, Fit+FitLibrary and Exactor, respectively. We are aware that there are lots of other tools around, both within the XP community and outside it. The aim of this workshop is to gather together all this disparate knowledge and start to work towards a common understanding of “best practice”. More Info…

tutorials

Tutorial Chairs: Geoff and Emily Bache
T01:Working Effectively with Legacy Code

Learn how to get code under test to change it deterministically and safely

Michael Feathers

Test Driven Development and Refactoring are powerful tools in the XP/Agile arsenal. With them you can add new code to systems and make existing code more maintainable. However, refactoring code without having tests in place can be hazardous.

This tutorial presents a collection of dependency breaking and test writing techniques that can be used to get existing code safely under test for refactoring. These techniques can be used in conjunction with Test Driven Development to breathe new life into large existing code bases.

Who should attend:
Attendees should be developers with a working knowledge of UML, experience with significant amounts of legacy code, and familiarity with Java or C++ syntax. At the tutorial, attendees will learn how to identify good test points within their applications, how to break dependencies well enough get portions of legacy code under test, and how to write tests to support refactoring and additional development. The exercises will be in Java. Attendees will be expected to bring a laptop with an installed version of the Sun Java JDK version 1.4 or later. Exercise packets will be distributed to attendees via email prior to the class

Michael Feathers, Object Mentor, has been involved in the XP/Agile community since is inception. While designing biomedical instrumentation software in the late 1990s, he met several of the members of the Chrysler C3 team at a conference and was persuaded by them to try XP practices. Subsequently, he joined Object Mentor where he has transitioned over eight teams to XP. Michael first became interested in legacy code problems when he noticed that the first teams he transitioned to XP had significant problems moving beyond the quality problems their legacy code bases presented. Since then he has concentrated on learning and developing techniques which aid this transition.

T02:Expressing Business Rules

Learn how to express business rules as tests, with a focus on expressing the business domain with brevity and clarity

Rick Mugridge

Learn how to express business rules as tests, with a focus on expressing the business domain with clarity and brevity.
Learn how to focus on understanding and communicating the domain with concrete examples, formulating a ubiquitous language in the process

Writing Customer tests is usually complicated by several factors: The business domain needs to be understood, and often needs to be clarified. Tests need to evolve to help this understanding evolve. Emphasis is often placed too early on the testing aspects, rather than on expressing the business domain (business objects, rules and constraints) as clearly as possible. The tests often make premature commitments to details of the application being developed, or are not written until those details are known.
This tutorial will give you active experience, through focussed exercises in small groups, in expressing business rules with clarity as Customer tests. You’ll see that such tests evolve as the whole team’s understanding of the business needs and the system evolve. You’ll learn to identify smells in tests and learn how to refactor them.

Who should attend:
Customers, business analysts, project managers, testers, programmers.
This tutorial is suitable for those with little experience with Customer tests, right through to those who want to refine and advance their techniques. It is as relevant to programmers as it is to others in a project team, given the central role of the ubiquitous language in communicating about the business domain

Rick Mugridge is the author, with Ward Cunningham, of Fit for Developing Software, Prentice-Hall, 2005. He developed the FitLibrary as he explored ways of expressing business rules well under change. He has been teaching, coaching and researching into agile software development for some years. Rick ran tutorials on Acceptance testing using Fit at XP2004, ADC2004 and XPAU2004. He runs his own consulting company, Rimu Research, and teaches agility to software engineering students at the University of Auckland, NZ.

T03:Agile User Experience Design

Agile Requirements Using User Experience Design

Jeff Patton

This tutorial has been cancelled!

T04:Test Driven User Interfaces

Techniques to support unit-testing and TDD of user interfaces.

Charlie Poole

Certain kinds of code have a reputation of being quite difficult to test. One of the most frequently cited examples is testing of user interfaces – particularly GUIs. .

This tutorial will begin with a quick review of the principles of unit-testing and test-driven development but will then drill down to the issues surrounding user interface testing. We’ll look at design issues, identification of what needs to be tested, how test-driven development can be applied to the UI and specific testing techniques for GUIs.
The tutorial will include both presentation and hands on exercises. Participants are encouraged to bring laptops for use in the exercises. We will arrange pairing for those without a laptop. Class examples will be presented in C# and Java, but the exercises may be done in other languages if desired.

Duration
Three hours ( half day )

Audience
This tutorial is aimed at programmers and project leaders who want to apply Test-Driven Development to the user interface. This includes both those with significant TDD experience, who need to develop testable user interfaces, and those who are just adopting TDD.

Outline
Topics covered will include:

A brief review of unit testing practices and test-first development, and of the facilities of standard unit-testing frameworks, to get us all on the same page.
A series of motivating examples showing why UI testing seems to be difficult.
T06:Introduction to Lean Software Development

Practical approaches for applying lean principles to software development.

Mary Poppendieck, Tom Poppendieck

Long feedback loops are the biggest cause of waste in software development. They are the reason why well over 50% of all newly developed software is seldom or never used. Long feedback loops are the cause of seriously delayed projects, unmanageable software defect counts, and code bases that calcify because of their complexity.
Lean Software Development is all about shortening information feedback loops in the software development process and creating flow. The result is increased speed and quality along with lower cost. If this sounds unlikely, consider that in manufacturing, operations, and logistics, lean processes routinely deliver the highest speed, highest quality and lowest cost in extremely competitive environments. This tutorial will show you how to apply the principles that underlay lean manufacturing, lean logistics and lean product development to software development.

As global competitiveness comes to the software development industry, the search is on for a better way to create first-class software rapidly, repeatedly, and reliably. Lean initiatives in manufacturing, logistics, and services have led to dramatic improvements in cost, quality and delivery time; can they do the same for software development? The short answer is “Absolutely!”

Of the many methods that have arisen to improve software development, Lean is emerging as one that is grounded in decades of work understanding how to make processes better. Lean thinking focuses on giving customers what they want, when and where the want it, without a wasted motion or wasted minute.

This one day workshop provides an introduction to applying lean principles such as Value, Learning, Flow, Integrity, Respect, and Perspective to software development.

You will learn how to:

Develop a value stream map for a software development organization and what to do once you have the map.
Assess the state of the basic disciplines which determine your software development process capability.
Create a financial model for a software development project and use it to make optimal tradeoff decisions.
Organize a visual workplace so that everyone knows the most important thing to do next without being told.
Design a decision-making process which simultaneously delivers high speed, high quality and low cost.
Course Description
This workshop is about 75% lecture and 25% small group work on case studies. After each topic is presented, attendees apply the concept to a real project of someone in the group. The format provides an introduction to strategies for applying the seven lean principles of:

Eliminate Waste
Amplify Learning
Delay Commitment
Deliver Fast
Build Integrity In
Empower the Team
See the Whole
In addition, practical implementation techniques are covered, including:

Creating and using value stream maps
Key metrics
Assessing your process capability
Using financial calculations to make optimal decisions
Who Should Attend
This program is designed for senior software development practitioners, team leads and managers who are considering lean software development for their organizations. It will be particularly useful to those who are looking for tools and practices that they can put to use.
T07:XP/Agile Overview

Get an overview of Agile software development practices and how those practices are implemented in XP.

Robert C. Martin

In this session Robert Martin describes the essential principles and patterns of XP/Agile methods, and how they fit into a development organization.

The talk begins with a history and overview of iterative and agile methods, comparing and contrasting these methods to waterfall. The talk continues with an in-depth discussion of agile planning and the individual practices of XP and Agile development. Then begin two critical TDD demonstrations. The first demonstrates Test First Design using unit tests and JUnit. The second demonstrates Acceptance Tests using FitNesse. The talk concludes with a description of several real projects that have used XP. Robert talks about the things they did right, the things they did wrong, and what they did to fix them.

T08:Transitioning to XP:real world advice from the front

A beginners course in how to become and XP change agent for your own organization

Michael Hill

This tutorial focuses on a practical real-world approach to adopting and adapting the XP stance.

Featuring explicit guidance for would-be change agents at every level of an existing organization, we include sections on the period before XP, the rollout itself, and the early days of the change, as well as a discussion of special challenges like large organizations and distributed teams. In the last six years, Mike Hill has helped over 25 teams transition to the XP stance, and witnessed hundreds more. The class is open to all comers: Anyone who wants to foment a transition to the XP stance in their own company can benefit from Mike’s guidance.

T09:The courage to communicate:collaborative team skills for XP/Agile teams

Experience and practice group and interpersonal collaboration skills that create the optimum environment for XP/Agile team success

Diana Larsen

In their highly collaborative work environments, XP and other Agile teams deal with many interactions within the team and project community. These interactions highlight the benefit of a solid grounding, not only in technical development skills, but also in interpersonal and collaborative team skills. The values of XP – Communication, Courage, Simplicity and Feedback – emphasize the need for these team skills as well. In this highly interactive tutorial, we’ll discuss three team and interpersonal collaboration skills critical for team success: team decision-making, focused listening and interpersonal feedback – seeking it, giving it, and receiving it. We’ll also explore activities and approaches to support and encourage team members as they develop more effective collaboration skills

In this highly interactive tutorial, we’ll discuss three team and interpersonal collaboration skills critical for team success: team decision-making, focused listening and interpersonal feedback – seeking it, giving it, and receiving it. We’ll also explore activities and approaches to support and encourage team members as they develop more effective collaboration skills.

Who should attend:
Experienced XP and Agile practitioners with a variety of roles on the team – project managers, coaches, scrum masters, business analysts, customer proxies, testers, senior developers – and anyone who steps into a leadership role on an XP/Agile team

Diana Larsen, FutureWorks Consulting, is identified as a standard-setting consultant by clients, an exceptional facilitator by colleagues and the “best boss ever” by former employees. Diana partners with leaders of software development projects to strengthen their ability to create and maintain culture, manage change and improve project performance. As a specialist in the human side of software development, she has over 15 years of experience in supporting effective interaction, planning and review, as well as managing projects. Diana speaks at conferences and authors articles on topics affecting project teams, team leadership and organizational change. She serves on the Agile Alliance Board of Directors, is a partner in FutureWorks Consulting, and is a team performance and facilitation expert with Cutter Consortium.

T10:The XP Geography: Mapping Your Next Step

A Guide to Planning Your Journey

Kent Beck

We will explore the primary practices of XP in detail using mind mapping exercises. You will examine your needs and find practices to address them. We will discuss the change process, how to reach agreement on goals and principles, how to implement new practices and how to sustain them. You will make a plan to share with your team and set up incentives for accountability. This tutorial will be interactive and involve many colored felt pens