Agile Software Development in the Large
Jutta Eckstein

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

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.

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.


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


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!


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


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


Hands-on Teaching Agile Development
Orit Hazzan, Yael Dubinsky


As a software team leader, how many times did you ask yourself: How shall I convey the magnificent ideas of agile development to my team? As a university professor, how many times did you try to introduce a new teaching approach to your institution? This tutorial aims at helping you achieving these goals, specifically, introducing new ideas related to software development into your organization, whether it is an academic institution or a software house. This tutorial is based on our rich experience in teaching the agile approach and Extreme Programming practices in different settings in the industry, the army and the academia, as well as our experience in guiding their implementation in the organizations. We focus on hands-on teaching and learning agile practices to enable our participants to run these processes by themselves. The tutorial consists of activities like allocation of bonus or grades, establishing a role scheme and roles distribution, managing change using evolution concepts, and defining a set of teaching principles.

This half-day tutorial is intended for software practitioners from all levels. Specifically, practitioners who hold one of the following roles can benefit the most: senior software managers, project leaders, instructors of software development methods courses, instructors of capstone project based courses, facilitators of workshops. The primary goal of the tutorial is to let the participants gaining hands-on experience with teaching agile practices while dealing with the conceptual and organizational changes introduced by them. This goal is achieved by an active learning approach that guides the participants to actually experience the practices as well as teaching them. There are no required prerequisites.


Both presenters have a significant experience with teaching Extreme Programming and agile Tutorials and guiding implementation processes at the Israeli industry, army and academia. Since 2002 we present research papers and practitioner reports in all Extreme Programming and Agile conferences and in 2005 we facilitated this tutorial in the Agile Conference.

Orit Hazzan is an Associate Professor at the Department of Education in Technology and Science of the Technion – Israel Institute of Technology. In May 2004 she published her book Human Aspects of Software Engineering, co-authored with the late Jim Tomayko. She is a consultant for several software projects in the Israeli software industry. The way she combines research and practice enables her to bring a comprehensive picture into guidance processes of software teams. She presents her research in computer science and software engineering education conferences (e.g., SIGCSE) as well as in conferences that deal with agile software development (e.g., the Agile International Conference).

Yael Dubinsky is an adjunct lecturer at the Computer Science Department at the Technion - Israel Institute of Technology, and a software engineering consultant working with the Israeli army and industry. She graduated B.Sc. and M.Sc. in Computer Science from the Technion, Israel and Ph.D in Education in Technology and Science from the Technion, Israel. Her research examines implementation of agile software development methods in software teamwork, focuses on measurement of software processes and product quality. Yael has a significant experience with guiding Extreme Programming and agile implementation processes.


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 



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

This interactive and informative tutorial will introduce you to practices that will increase the effectiveness of the customer on your XP project. Customers have one of the most complex and difficult roles on a project, yet XP includes very few practices that support the customer in their role — the aim of this tutorial is to change that.  

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.


 From Concept to Cash: Deliver Fast
 Mary Poppendieck, Tom Poppendieck


When an industry imposes a compromise on its customers, the company that breaks the compromise stands to gain a significant competitive advantage. In software development, we tell our customers that high quality software takes a lot of time. There is a significant competitive advantage awaiting the companies that break this compromise.  This tutorial will show how to organize software development so that value flows rapidly from concept to cash, for both new systems and on-going support.
Lean Software Development moves beyond agile practices by focusing on the speed of delivery. Counterintuitive tactics such as aggressive development of multiple options, dramatic shortening of lists and queues, and responsibility-based scheduling are at the heart of going fast.  Counterintuitive measurements such as cycle time replace localized productivity measurements.  A counterintuitive focus on product development replaces a project-oriented approach.  This tutorial will give participates a framework for organizing software development to compete on the basis of speed. It will show what works, what doesn’t and why.

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.


Collaborative Workplaces: Creating an Open Environment for Agile/Adaptive Projects
Polyanna Pixton, Diana Larsen

Agile flourishes in collaborative workplaces with open environments. Self-organizing teams thrive in organizational climates that stimulate communication, foster working relationships, encourage feedback and strengthen innovative thinking. Creating these open environments requires attention to a collaborative model as well as continuing focus on small, daily interactions and information flows. Business prospers when teams can collaborate and contribute.

In “Collaborative Workplaces” Pollyanna Pixton and Diana Larsen define the key factors involved in creating an open environment through developing and sustaining collaborative workplaces. The workshop includes opportunities for practice in the collaborative process and in other techniques to unleash the talent on teams. The presenters demonstrate ways to foster open dialogue that stimulates innovative development and improved processes, operations, products and services. Participants will develop specific strategies for creating collaborative workplaces in their work situations, including an action plan to begin the transition.

This tutorial will combine short interactive exercises with lecture and discussion. We will intersperse the introduction of key content pieces through lecture/description with experiential activities to reinforce the concepts. We also rely on audience participation in sharing knowledge and create a collaborative learning environment.

CxO’s, Vice Presidents of Development, Product or Program Managers, Project Leaders and Team Leaders with an interest, or some experience, in leading in Agile environments.

Presenter bios:

Pollyanna Pixton is widely recognized for her ability to lead the collaborative efforts of talented people who want to expand what they already do very well to being even better. She works with executives and teams inside corporations and organizations to improve their productivity and effectiveness to achieve lasting results using collaboration. She founded Evolutionary Systems in 1996, and brings over 35 years of executive and managerial experience from a variety of successful business and information technology ventures to her work as a consultant. Ms Pixton's education includes a Master's degree in Computer Science, three years of graduate studies in Theoretical Physics, and a Bachelor's degree in Mathematics.
She was primarily responsible for managing the building of the Swiss Electronic Stock Exchange, developing sophisticated control systems for electrical power plants throughout the world, and merging the complex technologies and data systems of large financial institutions. Her background includes leading the development of complex e-commerce projects, real-time applications, positioning systems, and generating original computational research.
Pixton co-founded the Agile Project Leadership Network (APLN) and serves on that Executive Board. She chairs the APLN Leadership Summit for 2006 and in Agile 2005 she presented a tutorial and workshop on becoming and agile leader. In 2004, she chaired the ADC Executive Summit and held the Getting Leaders Onboard workshop at XP Universe. www.evolutionarysystems.net

Diana Larsen  concentrates on building people’s capability to interact, self-organize and shape an environment for productive teams. Through her work, Diana demonstrates a unique blend of expertise, proficiency, candidness and compassion. Past clients recognized her as the consultant who set a standard for future working relationships. Her employees named her “the best boss ever,” and colleagues identify Diana as an exceptional facilitator.
In her consulting practice, Diana unites with leaders and teams on software development projects to strengthen their ability to support and sustain change initiatives, improve project performance, and retain organizational learning. She collaborates with her extended network of extraordinary colleagues to bring the best combination of talents to every project. Diana co-presents the workshop, “Secrets of Agile Teamwork: Beyond Technical Skills” and co-authored the book on retrospectives for Agile development with Esther Derby. She presents workshops on collaborative executive and project leadership with Pollyanna Pixton. Diana Larsen speaks and writes on subjects including team deveopment, project leadership, Agile methods, retrospectives, and organizational change. http://www.futureworksconsulting.com

Primary Contact:
Contact Ms Pixton at 801.582.1608, cell: 801.209.0195, via email: ppixton@evolutionarysystems.net and web site: evolutionarysystems.net




Agile System Testing with Texttest and xUseCase
Geoff Bache, Emily Bache


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.


Expressing Business Rules as Executable Specifications
Rick Mugridge, Rimu Research Ltd


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.



 Using stories effectively: Requirements, planning and testing made easy
 Michael Hill

If you think you already know everything you need to know about user stories, then you’re ready for a pop quiz: which of the statements below is true?
1. The key benefit of user stories is that they maximize developer efficiency.
2. Working by stories is like working from a requirements document.
3. You should use a generalized user-interface scripting tool for storytesting.
4. Writing storytests is strictly a customer responsibility.
5. Stories are best estimated in units of time.

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.


Agile Estimating and Planning
Mike Cohn,
Mountain Goat Software, mike@mountaingoatsoftware.com


Planning is important even for projects using agile processes such as XP, Scrum, or Feature-Driven Development. Unfortunately, we've all seen so many worthless plans that we'd like to throw them away altogether. Too many teams view planning as something to be avoided and too many organizations view plans as something to hold against their development teams. In this session you will learn how to break that cycle by learning and practicing skills that will help create useful plans that lead to reliable decision-making.
You will learn about story points, ideal days, and how to estimate with 'Planning Poker'. Both short-term iteration and long-term release planning will be covered as will be three techniques for estimating velocity. By the end of this session you'll have a new view on estimating and will have gained experience with practical techniques you can use to make estimating and planning useful on your next project.

Who Should Attend
This class will be equally suited for managers, programmers, testers, or anyone involved in estimating or planning a project. The only prerequisite is that you must have given an inaccurate estimate sometime in your life.

Presenter Background

Mike Cohn is the founder of Mountain Goat Software, a process and project management consultancy and training firm. He is the author of Agile Estimating and Planning and User Stories Applied for Agile Software Development, as well as books on Java and C++ programming. With more than 20 years of experience, Mike has previously been a technology executive in companies of various sizes, from startup to Fortune 40. A frequent magazine contributor and conference speaker, Mike is a founding member of the Agile Alliance, and serves on its board of directors. He can be reached at mike@mountaingoatsoftware.com.



 Team Health Indicators and Holistic Coaching
 David Hussman, Michael Feathers
The philosophy of Agile Development is to place people before process. While this can be liberating for many teams, allowing them to meet their goals with increased responsiveness, it also makes development sensitively dependent on team health and dynamics.

In this tutorial, we will describe a series of observations about healthy teams, and key indicators that you can use to determine whether a team is living up to its potential. We will also describe techniques for addressing common team issues and ways to promote healthy agile culture within your team.

Who should attend
Anyone working on, forming or joining an agile project will benefit from this tutorial. Healthy teams most often have more that one person fostering collaboration; if you are one these people, or would like to be, this tutorial will provide you with examples, tools, and experience.

Presenters' backgrounds
Both presenters have 15+ years of software development experience, and both have chosen to use their experiences to help transition others to using agile practices and principles to build better software in ways to draw out the creative and collaborative in people.
David Hussman has presented at XP / Agile conferences for the past 5 years. He is also a full time coach and agile trainer, working in the US, Canada, Ukraine, and Russia. For the past 5 years, he has coached and training many companies of various sizes across many industries. In a previous life, David was a music producer and he draws on that experience in helping communities transition to using Agile. David is also a Cutter Consortium Senior Consultant and presenter at the NoFluffJustStuff conferences.
Michael Feathers has been involved in the XP/Agile community since its 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 spent most of his time transitioning teams to XP. Michael is also the author of 'Working Effectively with Legacy Code'


 Testing in a Quasi-Agile Software Development Environment:
 Practical strategies for mixed culture projects

 Timothy D. Korson


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.







Merciless Refactoring with Eclipse
Matthias Lübken, Martin Lippert


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.

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
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.


Information Radiation in Practice: Communication Tools for Colocated Teams
Ilja Preuß



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.