This tutorial will acquaint participants with U-CD and its place in an agile development approach. As a participant, you'll be working hands-on in a collaborative design team to produce a user role model using 3x5 cards, poster paper, discussion, and creativity. You'll learn how the role model helps build context around software features that help determine priority and make trade-off decisions throughout a development project. You'll use this understanding, and more 3x5 cards, to develop an iterative release plan that takes into account newly understood user roles. In addition, you'll learn collaborative card-sorting and modeling techniques you can apply to other tasks throughout your project.

Dynamic Mock objects provide a technique for driving out the responsibilities of an object and its interactions with its collaborators through unit tests. A unit test for a class isolates the object it is testing and replaces its collaborators with mock implementations.

IOC is an OO design pattern addressing the issue of resolving component dependencies. When this technique is applied, an object’s dependencies are supplied to it (in this case, through its constructor), rather than it locating or instantiating dependencies itself.

Using these techniques in conjunction with a top-down design approach yields a cleanly-designed system, consisting of small, testable, loosely-coupled objects with clearly defined responsibilities.

Please note that to get the most out of the hands-on exercise in this session you should bring a laptop. If not you may be able to pair program with someone who does. The session will cater for Java and .NET platforms. For Java you will need to install JUnit, jmock (http://www.jmock.org) and picocontainer (http://www.picocontainer.org). For those who prefer .NET you will need NMock and NUnit.

We all have worked on development teams where the behavior of other team members was incomprehensible, the path to effective Agile/XP self-organized teams seemed blocked or vague, or any one of a number of other problems made us feel as though being a part of the team was not worthwhile. Sometimes we conclude the best answer might be to disband the team and start over. In this session managers, team leaders, coaches and team members learn how to track a team’s progress toward self-organization, to recognize the signs that their team might be stuck and to choose strategies to move the Agile/XP team from the impasse into higher productivity, satisfaction and success.

This tutorial is hands-on and based on real world stories. Join in an exploration of the path to successful team dynamics and leadership.

That question is answered in this tutorial. We will discuss a proven approach enabling agile collaboration among teams on large projects. This tutorial covers:

• Why large projects ARE indeed different
• Why existing agile methods (XP, Scrum, ...) are insufficient to deal with large projects
• A set of agile practices enabling agile multi-team collaboration
• My experiences using the practices

At the end of the session, you will leave the room either shaking your head saying "I wish I could do that" or with definite plans to try these practices when you get back to work.

The ideal attendee is a practitioner, a software or process engineer in development leadership role or with influence on such a person. You should be familiar with developing large systems and the attendant difficulties.

But agile projects also thrive on feedback. Ideally, new releases could be pushed to users every iteration. The users would be available to make comments like "I don't like this", or "When I type that, something bizarre happens", or "Oh! my life would be so much better if only you added such and so."

But too often, such feedback is slow or missing. In this hands-on tutorial, we will demonstrate a way to partly fill the gap. We propose that the whole team end an iteration with a bout of communal exploratory testing. In it, the team gets together in a large room, forms into pairs, exercises the product manually - using a variety of inspiration-generating techniques - and thereby gets candidate ideas for the product backlog. Some of those ideas will be bugs to be fixed; others will be features to be added.

This tutorial covers methods for improving the Lean Maturity of a software development organization. First we investigate the most fundamental principle of Lean Thinking: Eliminate Waste, and discuss tools for Learning to See Waste. Next we examine how organizations might tailor the Lean Maturity Measure to fit their circumstances. Then we delve into the details of three Lean Assessment Tools: Value Stream Map, Decision Diagram, Discipline Audit, and Collaboration Review. Finally we explore a modification of the classic Kaizen Event, generating a blueprint for an effective software development improvement process.

This model is not just a diagram or an analysis artifact. It provides the very foundation of the design, the driving force of analysis, even the basis of the language spoken on the project.

The tutorial will focus on three topics:

1. The conscious use of language on the project to refine and communicate models and strengthen the connection with the implementation.
2. A subtly different style of refactoring aimed at deepening model insight, in addition to making technical improvements to the code.
3. A brief look at strategic design, which is crucial to larger projects. These are the decisions where design and politics often intersect.

The tutorial will include group reading and discussion of selected patterns from the book "Domain-Driven Design," Addison-Wesley 2003, and reenactments of domain modeling scenarios.

Recognizing and adapting to different design rhythms is an often overlooked key to agility. When things don’t exactly go according to plan, agile designers react, readjust their thinking, and try again. Even so, unanticipated problems crop up—wicked problems that can’t be solved by sheer effort alone. They require a blend of skills: creative problem solving, negotiation, the ability to craft-try-rethink-and-propose solutions that combine simpler ideas or possibly take a leap in a totally new direction. This tutorial concludes with practical advice on how to sort design problems into the core, the revealing, and the rest, so you can give each kind of problem the attention it deserves.

You will learn how to apply the most relevant practices from Feature Driven Development and how to avoid common mistakes. You will learn what a client-valued feature is and how to express a project as a categorized list of client-valued features. You will learn how the first three FDD processes form a project startup phase that reduces risk, and learn about predictive metrics from the startup phase to help you size and cost the subsequent construction phase. You will learn about feature milestones and how they are used for amazingly accurate tracking and reporting that is meaningful to clients and keeps your project team better focused.

You will learn how FDD scales to very large projects, plus where the accountability for estimating really lies, and throughout the tutorial you will learn key lessons from over 20 years experience in the industry.

Facilitation skills are crucial for agile teams, which must experience healthy team dynamics in order to continually learn and adapt. In mature teams, effective facilitation skills can emerge spontaneously and become shared amongst team member. How is this accomplished? What specific techniques can you use to promote collaboration?

This experience-based tutorial will share a set of effective facilitation skills and collaboration patterns that will help you and your team to truly collaborate better. You will be provided with a rich set of handouts containing specific techniques you can use to promote real team collaboration. In this tutorial, be prepared to enjoy recognizing, celebrating and appreciating collaboration—because collaboration works!

Participants break into small groups, and plan and execute a simulated software development project using cards and gaming tokens. The tutorial instructors act as Game Masters. Some game events are controlled randomly, by the throw of dice, and some events are injected intentionally by the instructors or by the tutorial participants. As events occur, participantsmay adjust the practices that they use, to examine the effect of those practices on the project outcomes.

This game picks up where the instructors' popular "Small Card Planning Game" leaves off, addressing the day to day, week to week, and month to month impact of agile practices on project outcomes.

What works for me and my customers, and, I suspect, will work for you and your customers is talking, listening, and working with them to uncover what they really want. This hands on, “learning by doing” tutorial describes 12 proven techniques for working with customers, and in the process understanding what your customers really want. They’re fun, and they work.

This tutorial describes the principles and techniques for shaping a methodology to the project-team combination, introduces the colors in the Crystal family, compares different examples of the Crystal family to each other relative to the principles, and shows the differences between Crystal Clear and XP. Expect to learn the methodology tuning principles, and experience how easy and fruitful a methodology-tuning session can be.

This tutorial covers more advanced use of Fit, including sequences of tables, testing workflow, new fixtures, table design and smells, managing test suites, hard tests and testing legacy systems. It assumes some experience with using Fit and the three standard types of Fit tables.

Participants are asked to bring a laptop pre-loaded with Fit and/or Fitnesse code suitable for use with their language of choice. These can be downloaded from http://fit.c2.com and http://www.fitness.org.

From materials to drugs to software, companies are relentlessly driving the cost of change out of their product development processes in order to foster innovation. These projects are the realm of Agile Project Management (APM) which operates under a philosophy of Envision and Explore rather than Plan and Do.

APM focuses on quick starts, iterative exploration, delivering customer value, low-cost change, frequent feedback, and intense collaboration. APM excels on projects in which: new, risky technologies are incorporated; requirements are volatile and evolve; time-to-market is critical; and high quality must be maintained.

APM includes core agile principles, a project management framework, and specific practices. The framework phases are: Envision — determining the product vision and project scope; Speculate — developing a feature-based release, milestone, and iteration plan; Explore — delivering tested features; Adapt — reviewing the delivered results and adapting; Close — concluding the project. Sign up for this tutorial and explore the ideas and practices of APM.