In this three-day course, you will experience creating and delivering software in a real-world Agile environment. After completing the course, you will be prepared to:
- Build and ship software weekly.
- Understand and accommodate stakeholders and their diverse opinions.
- Work in a cross-functional team with on-site customers, testers, and programmers.
- Prevent build failures with continuous integration.
- Incrementally build technical infrastructure alongside features.
- Create nearly bug-free code using test-driven development, refactoring, and exploratory testing.
Our primary audience is Agile team members, including product managers, project managers, programmers, embedded subject matter experts, business analysts, and testers.
Managers and executives interested in understanding how Agile works in practice will also benefit from this course, as will change agents and other leaders who are transitioning their organizations to Agile.
Programmers: We use Java, Eclipse, Ant, and Subversion in this course. You'll be working in teams, so it's okay if you aren't completely familiar with these technologies.
A laptop is required for most participants of this course. If you cannot bring a laptop, you can still attend, but please contact us so we can make the appropriate arrangements.
This is a hands-on course with a heavy emphasis on doing, not watching! You will form cross-functional teams and deliver actual software in four 90-minute iterations, in a real-world environment that includes version control, automated builds, and continuous integration. That's right: you'll design, build, test, and ship software, as well as build out your technical infrastructure, all in ninety minutes. If that sounds impossible, you need to come to this course!
We cover a lot of ground in this three-day course. We intersperse the real-world iterations with lots of interactive workshops to ensure that you can experience and remember everything you learn. Come prepared to drink from the firehose! Topics include test-driven development, refactoring, collaborating in a cross-functional team, working with stakeholders, and much more.
This course dovetails nicely with The Art of Agile Planning, which is typically taught in the same week.
We regularly review and refine our courses, so this outline is subject to change.
Day One: Core Delivery Skills
- Team Formation
- Review of Agile Lifecycle
- Test-Driven Development
- Customers' Role
- Story Workflow
- Customer Examples
- Automated Builds
- Story Development
- Pair Programming
- Iteration #1
Day Two: Advanced Topics
- Meeting Commitments
- Collaborationg & Collective Ownership
- Working Agreements
- Continuous Integration
- Iteration #2
- Defect Prevention
- Exploratory Testing
- Testers' Role
- Incremental Requirements
- Incremental Design & Architecture
- Grooming the Backlog
Day Three: Bringing It Together
- Iteration #3
- Lessons Learned
- Iteration #4
- Transitioning to the Real World
"I don't know how they pulled off the [class project], but going through four iterations brought the concepts home. Also I was a programmer wanting to learn about the project development side. Diana's four-quadrant diagrams (about stakeholders) were enlightening as was Jim's [incremental design] box diagrams and analogy of TDD to double-entry bookkeeping. Thank you!!"
Steve Tamura, Developer
"What an ending. I've just finished the most interactive training class I've ever taken. I spent much of the last two days on a real Agile team producing a real product in 90-minute iterations. In a word, it was intense... After four iterations we shipped a working Java console game that was demonstrated to the class. And I ended up on a development team that, in some ways, is more functional than my development team at work. Seriously, I could take this team back and start solving some real problems very, very soon."
John Hines (In his blog)
"They were great. They were funny, understanding, and answered questions well."
Ven Cohen, Programmer/Technical Lead, ISI
(See the comments for more testimonials.)
About the Instructors
James Shore is a prominent figure in the Agile software development community. He has been coaching teams in Agile development since 1999 and is a recipient of the Agile Alliance's prestigious Gordon Pask Award for Agile Excellence. James consults with development teams worldwide to help them meet commitments, improve product quality and increase productivity. He is co-author of The Art Of Agile Development.
Diana Larsen consults with leaders and teams to create work processes where innovation, inspiration, and imagination flourish. With more than fifteen years of experience working with technical professionals, Diana brings focus to the human side of organizations, teams and projects. Diana co-authored Agile Retrospectives: Making Good Teams Great! and is current chair of the Agile Alliance Board of Directors.
Together, James and Diana provide the highest level of Agile understanding and expertise. They focus on practical experiences and deep understanding. You'll learn a great deal from them, and you'll have a good time doing it.
Diana and I share two core beliefs about training: we want to our students to have experiences, not lectures; and whenever possible, we want those to be real-world experiences rather than metaphors or simulations.
Part of the reason is that "textbook" answers tend to strip out the messy complexity that occurs when you put work into practice. In real-world planning, there's tension and pressure. Different people want different things. There's a fear about what will happen if you don't get everything done by a certain time. Existing interpersonal friction is magnified.
You'll never learn this stuff by hearing a lecture. Most instructors don't even mention it. (Sadly, some teach from books, not experience, and don't know that they don't know it.)
So we do it. Suddenly the stuff that seemed so easy when it was up on the board isn't as easy any more. Mistakes are made. And real learning happens.
(Read the rest of my essay, "Come Drink from the Firehose.")