TO1

Agile Software Development in the Large Jutta Eckstein

Description
A lot of people still believe that agile software development is for small teams only. However, the agile value system and the principles behind as stated in the agile manifesto don't say anything about team or project size. Furthermore the projects I'm working on are typically
large, distributed and mission-critical. Therefore, several years ago I took the challenge and tried agile software development in the large. Meanwhile I made the similar experience on many large projects: Also large and even distributed teams can benefit from a value system that is beneficial for small teams.
In this tutorial I want to show how to scale agile processes to teams of 200. In fact, the same techniques are also relevant to teams of ten or more developers, especially within large organizations.

Intended Audience
- Change agents and promoters of agile methods
- Executives
- Project managers, product managers, development team managers
It would be helpful if the audience would be familiar with a specific agile process, however it’s not a requirement.
Participants will recognize typical obstacles when applying agility in the large (either in a large team or/and in a large organization). They will walk away with several best practices that will help them to overcome these obstacles and with an idea how to develop their own best practices.

Presenter’s Qualification
Jutta Eckstein (je@it-communication.com) is an independent consultant and trainer for over ten years. She has a unique experience in applying agile processes within medium-sized to large mission-critical projects. This is also the topic of her book Agile Software Development in the Large. 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), OOPSLA (USA), OT (UK), XP (Europe) and Agile (USA).
 

Effective measurement of the software process Alberto Sillitti, Giancarlo Succi

Description
Measures supply essential data in all the different engineering disciplines. Such data enable and facilitate the understanding of how things work "in reality" and how to make changes to produce desired results. It has been often said that a solid and significant process improvement requires a sound measurement program.
In software engineering, it is difficult to collect useful measures.
Nearly always, metrics are collected manually with burden for software engineers (and consequently to managers) and manually collected data are often affected by errors, making them unusable. The scarcity of data makes also less valuable the limited data collected, as fewer comparisons can be drawn.
Altogether, there is an apparent contradiction. On one side managers and software engineers praise measures from a theoretical standpoint, while in practice the application of measurement is limited.
Such contradiction is even more evident in the Agile Community. Agile Methods and lean management in general requires a solid measurement program. However, collecting metrics appears to be a non directly productive activity, and, as such, it is often discarded both by managers and by software engineers. This behavior affects the ability of software companies to perform objective evaluations of the new development methods. For these reasons, a new generation of non-invasive metrics collection tools has been developed and can be used to collect data without any human effort.

Audience
This tutorial has a broad audience that includes developers and managers. Both of them are interested in the improvement of the final product and find difficult to understand if a new tool or practice is really useful or not. Collecting measures is the only way to achieve such results but traditional techniques are not designed to be applied in conjunction with AMs.

Presenters background
Alberto Sillitti, Ph.D., PEng, is Assistant Professor at the Free University of Bozen, Italy. His research areas include software engineering, software metrics, component-based software engineering, integration and measures of web services, agile methods, and open source software.

Giancarlo Succi, Ph.D., PEng is Professor of Software Engineering and Director of the Center for Applied Software Engineering at the Free University of Bozen. His research areas include agile methods, open source development, empirical software engineering, software product lines, software reuse, software engineering over the Internet. He is author of more than 150 papers published in international conferences and journals.
 

TO3

Test-Driven J2EE: Life outside the container
J. B. Rainsberger, Diaspar Software Services

Description
Experience test-driven development by building J2EE components! Many students of test-driven development are introduced to the subject through simple problems, such as the classic "Money" example from Kent Beck's Test-Driven Development: By Example. Although some people enjoy exploring new topics by tackling simple problems, there are those who would rather dive into the deep end, than merely get their feet wet. This tutorial is for those people.
The J2EE environment presents specific problems to programmers who want to practise test-driven development. When we learn to build J2EE applications, the books and tutorials we follow tend to teach us anti-testability habits. Parts of the platform themselves discourage designing for testability, and that makes test-driving J2EE applications more difficult than it needs to be. In this tutorial we'll see how to break out of that trap and build J2EE applications with all the confidence that test-driven development normally provides.
Test-Driven J2EE gives you the opportunity to practise the techniques of test-driven development with J2EE components. The goal is to build a small, but useful slice of a J2EE application while following the cardinal rule of test-driven development:
                                                         Never write a line of production code unless somewhere, a test fails.
You will add a feature to an online Coffee Shop application, giving you an opportunity to see how to test-drive new features for an existing system designed for testability.

Who should attend
If you have some experience with test-driven development, but have not yet satisfactorily applied the technique to the more challenging parts of a J2EE application, then you are the ideal attendee for this tutorial. We do not provide an introduction to test-driven development in this tutorial, but even if you have no experience practising it, you can certainly benefit from the demo as well as by acting as a pair-programming partner for another attendee. Also, even though this tutorial is about J2EE, past attendees have found the principles to apply equally well to the .NET platform.

Presenter background
J. B. (Joe) Rainsberger has practised test-driven development since 2000 and refined his skills by insisting on making a number of J2EE applications testable. His book JUnit Recipes: Practical Methods for Programmer Testing provides extensive examples of how to test-drive new J2EE features as well as how to test existing applications not designed with testing in mind. He has led tutorials, workshops and Open Space sessions at XP/Agile Universe 2003-2004 as well as Agile 2005. Test-Driven J2EE is a repeat performance at this conference, with less lecturing and more interactivity!
 

TO4

Context Driven Agile Project Leadership
Todd Little, Landmark Graphics, tlittle@lgc.com

Summary
It is common in the Agile community to talk of a development process that is “barely sufficient” to meet the needs of the project team. Based on experiences at Landmark Graphics, we observed that what is “barely sufficient” for one project may be insufficient for another, or overhead for yet another. When looking at our project history, we observed two primary attributes that influenced the type of process used: complexity and uncertainty. Complexity includes project composition such as team size and criticality, while uncertainty includes both market and technical uncertainty. Similar to the Boston Consulting Group’s Boston Matrix, we used animals to represent the four quadrants:
• Dogs – Simple projects with low uncertainty
• Colts – Simple projects with high uncertainty
• Cows – Complex projects with low uncertainty
• Bulls – Complex projects with high uncertainty
Starting with a core set of common practices, additional practices are recommended depending on complexity and uncertainty. One benefit of this approach is identifying these project drivers and providing earlier guidance to project teams.
The tutorial develops this model and extends it to include the product lifecycle with linkages to the Boston Matrix and to the work of Geoffrey Moore.

Who should attend
Primary audience is designed to be Leaders, Managers, Project Managers and Executives, but all roles should be able to find value from the tutorial.
People familiar with The Declaration of Interdependence for Agile Project Leadership will note two tenets pertinent to this tutorial:
• We expect uncertainty and manage for it through iterations, anticipation, and adaptation.
• We improve effectiveness and reliability through situationally specific strategies, processes and practices.

Presenter background
Todd Little is a Sr. Development Manager for Landmark Graphics. He has been involved in most aspects of software development including development, project management and general management. His focus has been on commercial software applications for oil and gas exploration and production.
He is on the Board of Directors for the AgileAlliance and the APLN and was the Program Director for ADC2004, Agile2005, and Agile2006 conference. He is a co-author of the Declaration of Interdependence for Agile Project Leadership and a founding member of the Agile Project Leadership Network.  He received his M.S. in Petroleum Engineering from The University of Houston and a B.S. in Chemical Engineering from Iowa State University. He is a member of the AgileAlliance, APLN, IEEE, Society of Petroleum Engineers and is a registered Professional Engineer in the State of Texas. He has published several articles in both petroleum engineering and software engineering and has spoken at professional conferences in both disciplines. Contact him at tlittle@lgc.com
 

TO5

TO6

The Extreme TDD and Build Experience
From Acceptance Tests to Installation Kit
Erik Lundh

[ex-per-i-ence] – NOUN … 2a. Active participation in events or activities, leading to the accumulation of knowledge or skill. b The knowledge or skill so derived. …. 5 Ward Cunningham collects experiences as part of the Eclipse Dash project. 

Q: Why should we do automated extreme TDD and Build from storytest to tested installation?
A: You will experience why and how in this tutorial!

Q: How could I get others clued on a great technology or practice?
A: By using this experience as an inspiration to develop your own experiences that bring insight and inspiration to your coworkers and organization. 

Are you in an agile team or coaching a team? Does the team get the overall soft process but it is hard to motivate yourself or others in spending time and money on fully automated test-driven development flow from user stories/requirements to installation-tested ready-to-deploy product? 

Or do you have other areas where you look for patterns or practices that help teams and organizations “get clued” on why they should adopt a certain behaviour , infrastructure or technology? 

This tutorial is serves as both as an actual experience of Extreme Test-Driven Development & Build, and as an inspiration to develop your own hands-on experiences. 

The tutorial combines lecture with hands-on experience in Java or C# (the participant’s choice). We have experiences prepared for C# (VS2005 with addins), Java (Eclipse, RCP, and others) and web (Fitnesse integrated with Selenium) 

Available for hands-on experience: 5 Ferrari laptops with full Java and .NET development environments with popular test tools, connected to an automated build server with Subversion version control. 

Bring your own laptop and connect to the build server. Open source software, limited editions and trial editions of many popular tools will be available, including Eclipse, Cruisecontrol Java/NET, Subversion, Resharper, TestDriven.NET, Fitnesse, Selenium, JUnit/NUNIT/xUnit, coverage tools, etc.  Additional tutorial details at: http://www.compelcon.se/tutorials/xp2006-t06

TO7

 Programmers are from Mars, Customers are from Venus:
 A practical guide to working with customers on XP Projects
 Angela Martin, Robert Biddle, James Noble

Over the last three years, we have investigated many projects around the world to identify how customers succeed in this complex and difficult task — discovering not what people think should have happened, but what really happened and what actually worked!  This tutorial distils this research, grounded in practical experience, into a 3 hour session, so that by the end of this tutorial you will have gained:

C        A realistic understanding of the complexity and difficulty of the XP Customer role.

C        An understanding of the key roles required on a customer team, both what they are and why they matter. 

C        An understanding of the nine practices that enable customers to sustainably drive XP projects to successful completion – think “XP practices” BUT for customers.

Who Should Attend?
This tutorial is aimed at anyone – but most specifically programmers, customers, analysts, testers and project managers – who wants to improve the effectiveness of the Customer within XP. Participants should have a background in XP (or another Agile methodology).

Presenter Backgrounds
Angela Martin, ThoughtWorks Limited:  Angela Martin is a consultant with eleven years of professional software development experience; she works directly with programmers and customers on agile projects to deliver software that works.  She is also completing her PhD research at Victoria University of Wellington, New Zealand, supervised by James Noble and Robert Biddle. Her research utilises in-depth case studies of the XP Customer Role, on a wide range of projects world-wide.  Angela is also an Agile Alliance Board Member.

Robert Biddle, Human-Oriented Technology Laboratory, Carleton University:  Robert Biddle is Professor of Human-Oriented Technology at Carleton University in Ottawa, Canada. His research and teaching is in software engineering and human-computer interaction; he earlier worked as a software developer and as a technical consultant. He is widely recognised as an excellent teacher, presenter, and educator.

James Noble, Victoria University of Wellington:  James Noble is Professor of Software Engineering at Victoria University of Wellington, New Zealand. He has extensive experience lecturing, teaching, and mentoring software design, software visualisation, user interface design, and design patterns, and many other topics. He has presented many tutorials at conferences including OOPSLA, JAOO, TOOLS, OzCHI, and VL/HCC.
 

TO8

Who Should Attend
This tutorial will be of interest to managers and technical leads that are familiar with the basics of agile software development.  

Presenter background
Mary Poppendieck has been in the Information Technology industry for thirty years. She has managed solutions for companies in several disciplines, including supply chain management, manufacturing systems, and digital media. As a seasoned leader in both operations and new product development, she provides a business perspective to software development problems.
A popular writer and speaker, Mary’s classes on managing software development have been popular with both large and small companies.  She is co-author of the book Lean Software Development: An Agile Toolkit, published by Addison Wesley in May, 2003 and winner of the Software Development Productivity Award in 2004.
 

TO9

T10

Description
In this tutorial we are going to present an innovative approach to automating system-level, customer-owned tests.

One of the most important aspects of an agile development approach is that the 'correct behaviour' of a system will change over time as the customer steers the direction of development. Rather than just 'correctness assertion', you can think of the purpose of automated system tests as being more 'behaviour change management'. The tools Texttest and xUseCase together give you a powerful means to create a customer-understandable representation of the system behaviour independent of the source code, and help you to easily update and manage it as the system develops.

Both user choices and system responses are stored in plain text files, written in a domain specific language. These files are detailed enough that the tools can use them to reproduce the user choices and ensure that the system still does whatever is recorded in the file. When the customer decides the system should change its behaviour, these files are updated and the reason for the change can be noted.

Although there is nothing inherent in the approach to restrict it to testing only certain kinds of systems, we know from experience that this approach is particularly useful when testing:

1. Legacy code
2. Scripts and other non-interactive systems
3. computationally intensive systems such as optimisers or simulators

For more information, please visit http://www.texttest.org

Who should attend this tutorial
Software developers, architects and testers will all benefit from learning about this innovative testing approach, both in theory and in practice.

Presenter backgrounds
Geoff Bache is an experienced software developer and XP coach, working for the software product company Carmen Systems in Gothenburg, Sweden. He has been interested in XP Acceptance Testing since 2000 and working on developing the approach that has become TextTest and xUseCase since then. He has presented papers on Acceptance Testing at the XP2003 and XP2004 conferences. At XP2005, he co-chaired two successful workshops together with Rick Mugridge (of the Fit tool) and Brian Swan (of the Exactor tool). He maintains the site www.texttest.org.

Emily Bache currently works for AstraZeneca in Mölndal, Sweden, writing applications in python to help scientists with their research. She has been practicing Test Driven Development with xUnit since 2000, and with TextTest since 2002. Emily has presented posters about automated testing and writing software in collaboration with scientists respectively at two previous XP conferences. More recently Emily has started a regular coders dojo at her workplace, with the aim of teaching and learning Test Driven Development.
 

T11

Description:

Learn how to express business rules as storytests, with a focus on expressing the business domain with clarity and brevity. Storytests serve to clarify and communicate the domain as executable specifications and to aid in developing the system and testing it in a variety of ways.

Writing storytests is usually complicated by several factors: The business domain needs to be understood, and often needs to be clarified. Storytests need to evolve to help this understanding evolve. Emphasis is often placed too early on the detailed testing aspects, rather than on expressing the business domain as clearly as possible.
The storytests 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 experience in expressing business rules well as storytests with FitLibrary, through small group exercises. We'll see that such storytests evolve as the whole team's understanding of the business needs and the system evolve.

Who should attend

Audience: Customers, business analysts, product managers, project managers, testers, programmers.

This tutorial is suitable for those with no experience in storytests, right through to those experienced with Fit and/or FitLibrary  who want to refine and advance their techniques and extend their knowledge. It's as relevant to programmers as it is to others in a project team.
After attending this tutorial, you will use (or better use) storytests as executable specifications  that are a powerful, alternative approach to agile requirements. You will have gained some experience in writing and evolving storytests, which you'll be able to apply to your own work.

Presenter's Background

Rick Mugridge is the lead author of the first book on storytests: Fit for Developing Software, Prentice-Hall, June 2005. He has developed and is evolving FitLibrary to better support storytest driven development. He is a leading thinker and inventor in this area, and consults and coaches internationally in storytests, domain driven design, and agile software development. He ran tutorials at XP2005 and Agile2005. Rick runs his consulting company, www.rimuresearch.com, out of New Zealand.

 

T12

If you answered ‘true’ to any of these five statements, you should consider taking this tutorial, as you’re still working with some user story myths. Stories are a simplifying token in a complex protocol requiring domain knowledge, technical skill, and delicate human judgment. The tutorial emphasizes real-world experiences and gives the students a firm grounding in these areas:
• Why using stories is preferable to other planning techniques.
• How to write and recognize a ‘perfect’ user story.
• How to run stories through the planning process.
• How (and when) to break larger features into stories.
• How to write and implement good storytests.
• How to sort user stories to bring maximum value to their enterprise.

Who Should Attend
Because planning and estimating involves both Customer and Developer roles, this tutorial is equally suited to either side of an agile team. No previous knowledge of agile practices is required. The final section is dedicated entirely to real-world story-writing problems supplied by the audience. Students may wish to prepare in advance by thinking of the kinds of problems they anticipate in using stories inside their teams. Students will get real hands-on work with stories, confronting the same problems they’ll see when they return to work from the conference.

Presenter Background
Mike Hill has been helping companies transition to XP since the beginning of the movement. His work has taken him to groups large and small all over North America and Europe. Currently, he is a senior coach working for Industrial Logic, Inc., the world’s leading experts on adopting Agile Practices. He is widely known for his direct and humorous presentation style, and for his willingness to get down in the trenches with his clients.
 

T13

T14

T15

Description

This tutorial focuses on practical issues faced by increasing numbers of testers today. These issues arise from the fact that most test organizations are still structured around traditional software development practices even though many software development teams are heading full steam into modern agile software development techniques. QA managers trying to encourage best practices as recommended by CMMI and SPICE find themselves at odds with developers trying to adopt best practices as recommended by the Agile Manifesto. This leaves corporate QA stuck coping with an organizational and technical paradigm shift that traditional QA policies and practices are inadequate to handle.

In the highly iterative environment characteristic of these agile development projects, development and testing processes are much more tightly integrated. System testers are expected to test early immature increments of the software, and are often called upon to plan, support and review the unit and component-level testing process. Developers, in addition to unit testing, may be called upon to assist with the automation of certain system-level tests. Risk assessment and overall test asset allocation must also be adapted.
In addition to the discussion of specific techniques and best practices, this tutorial addresses how to adapt, survive, and hopefully even thrive in mixed culture environments, where the developers are coming from an agile mindset, but some or all of the stakeholders, managers, testers, and others in the organization are coming from a traditional mindset.

Who should attend

• Testers

• Test Managers

• Project Managers

• Process improvement staff

• Business Analysts

• Clients and other stakeholders

• Developers
   

Presenter background
Timothy Korson has had over two decades of substantial experience working on a large variety of systems developed using modern software engineering techniques. This experience includes distributed, real time, embedded systems as well as business information systems in an n-tier, client-server environment. Dr. Korson’s typical involvement on a project is as a senior management consultant with additional technical responsibilities to ensure high quality, robust test and quality assurance processes and practices. Dr. Korson has authored numerous articles, and co-authored a book on Object Technology Centers. He has given frequent invited lectures at major international conferences and has contributed to the discipline through original research. Dr. Korson has recently presented this tutorial at a number of conferences in the USA and in Europe. This tutorial has received outstanding feedback from attendees.
 

T16

T17

Abstract
Since Martin Fowler has published his ground-breaking book on refactoring many things have changed, especially the day-to-day refactoring work has changed due to the comfortable IDE support. The goal of the tutorial is to provide an insight how the refactoring support that is built into common modern IDEs can be utilized to do merciless refactoring on a minute-to-minute basis. The tutorial demonstrates the refactoring capabilities of modern IDEs and lets the attendees feel how those refactoring tools can change their way to develop software. They learn how to utilize modern refactoring support to do improve the design of their software systems all the time.

Aside of the very basic and small refactorings we will explain how more complicated refactorings can be realized using the IDEs refactoring support. E.g. we show how to use the often overlooked “Change Method Signature” refactoring to do even complex refactorings in a few minutes, we will demonstrate how to use “Inline Method” to remove deprecated method calls and “Inline Constructor” as a combination of “Introduce Factory” and “Inline Method”.

Special attention is paid to the boundaries of modern refactoring support within integrated development environments. Especially those refactorings that are supported in a non-safe way will be uncovered. This will protect attendees from blindly using these automated refactorings while changing the behavior of the system at the same time.

Presenters
Martin Lippert [contact person]
lippert@acm.org , www.martinlippert.com
Consultant and Coach at it-agile GmbH
Paul-Stritter-Weg 5, 22297 Hamburg, Germany

Martin Lippert is a consultant and coach for software engineering technology and agile development methods. He focuses on software development on top of the Eclipse platform, refactoring, extreme programming and aspect-oriented programming. He worked for the AspectJ project at PARC as an intern during the summer of ’99 and has given a number of talks, tutorials and demonstrations on various topics of software engineering at international conferences. He is co-author of the upcoming book on complex refactorings in large software projects that will be published by Wiley in March 2006.

Matthias Lübken
matthias.luebken@it-agile.de
Software Engineer at it-agile GmbH
Paul-Stritter-Weg 5, 22297 Hamburg, Germany

Matthias Lübken is software engineer at it-agile in Hamburg. He has several years of experience with agile software projects, mainly eXtreme Programming. He focuses on development on top of the Eclipse rich-client platform and is co-author of the German book “Eclipse – The Platform”.

Who should attend
The tutorial is targeted to practitioners: developers and architects. The attendees will get an insight how merciless refactoring can be realized using the refactoring support that is built into the Eclipse IDE. Best practices ranging from nice keystrokes to tips and tricks to combine small refactoring features will be demonstrated in a way to be used right away. We will refactor a system with code smells in front of the audience. The tutorial will contain pair programming by the two instructors and pair programming together with the audience. While we refactor the system we explain what we are doing and introduce the IDE refactoring features. Attendees should have a solid understanding of object-orientation. Basic understanding of refactoring or Eclipse is not required.
 

T18

Description
Communication is a cornerstone of Agile software development. Well working communication allows a team to self-organize, to keep focused, to act responsibly and to build trustful relationships, leading to more effective collaboration. With their emphasis on informal ad hoc communication, Agile teams can benefit from tools that guide communication without restricting it. Information Radiators, which make key information easily and publicly accessible, are such a set of tools.

The goal of this tutorial is to provide you with the thought models and tools to make effective use of Information Radiators. We will explore the communication needs of Agile teams and how Information Radiators can help to meet them. We will take a look at examples from real projects and discuss the qualities that made them help the team, or how they failed to do so. We will learn about different formats that are in use in the community, and how to adapt them to individual situations. One focus will be on important social and economical implications of introducing Information Radiators at the workplace.
A group activity will allow us to relate the discussion to individual experience.

Who should attend
This tutorial will be of equal interest to developers, managers, coaches and anyone else who is part of a development team. The only prerequisite is a basic understanding of Agile software development approaches.

Presenter background
Ilja Preuß is a developer and mentor at disy Informationssysteme GmbH, a German software and consultancy service provider. His focus is on improving all aspects of the team's development process and promoting technical excellence, for a big part by driving forward the adoption of Agile practices. He is a co-author of the German book "Softwaretests mit JUnit" (Link et. al, 2005) and holds presentations and tutorials at conferences and local user groups. He also is a Sheriff at JavaRanch.com, the biggest non-commercial website for Java.