Using agile methods and the tools of Visual Studio 2010, development teams can deliver higher-value software faster, systematically eliminate waste, and increase transparency throughout the entire development lifecycle. Now, Microsoft Visual Studio product owner Sam Guckenheimer and leading Visual Studio implementation consultant Neno Loje show how to make the most of Microsoft’s new Visual Studio 2010 Application Lifecycle Management (ALM) tools in your environment. This book is the definitive guide to the application of agile development with Scrum and modern software engineering practices using Visual Studio 2010. You’ll learn how to use Visual Studio 2010 to empower and engage multidisciplinary, self-managing teams and provide the transparency they need to maximize productivity. Along the way, Guckenheimer and Loje help you overcome every major impediment that leads to stakeholder dissatisfaction—from mismatched schedules to poor quality, blocked builds to irreproducible bugs, and technology “silos” to geographic “silos.” Coverage includes• Accelerating the “flow of value” to customers in any software project, no matter how large or complex• Empowering high-performance software teams and removing overhead in software delivery• Automating “burndowns” and using dashboards to gain a real-time, multidimensional view of quality and progress• Using Visual Studio 2010 to reduce or eliminate “no repro” bugs• Automating deployment and virtualizing test labs to make continuous builds deployable• Using Test Impact Analysis to quickly choose the right tests based on recent code changes• Working effectively with sources, branches, and backlogs across distributed teams• Sharing code, build automation, test, project and other data across .NET and Java teams• Uncovering hidden architectural patterns in legacy software, so you can refactor changes more confidently• Scaling Scrum to large, distributed organizations Whatever your discipline, this book will help you use Visual Studio 2010 to focus on what really matters: building software that delivers exceptional value sooner and keeps customers happy far into the future. Foreword by Ken Schwaber It is my honor to write a foreword for Sam’s book, Agile Software Delivery with Visual Studio. Sam is both a practitioner of software development, as well as a scholar. I have worked with Sam for the last two years to merge Scrum with modern engineering practices and an excellent toolset, Microsoft’s VS 2010. We are both indebted to Aaron Bjork of Microsoft, who developed the Scrum template that instantiates Scrum in VS 2010 through the Scrum Template. I do not want Scrum to be prescriptive. I left many holes, such as what as the syntax and organization of the Product Backlog, the engineering practices that turned Product Backlog items into a potentially shippable increment, and the magic that would create self-organizing teams. Sam has superbly described one way of filling in these holes in his book. He describes the techniques and tooling, as well as the rationale of the approach that he prescribes. He does this in detail, with scope and humor. Since I have worked with Microsoft since 2004 and Sam since 2009 on these practices and tooling, I am delighted. Our first launch was a course, the Professional Scrum Developer .NET course, that taught developers how to use solid increments using modern engineering practices on VS 2010 — working in self-organizing, cross-functional teams. Sam’s book is the bible to this course and more, laying it all out in detail and philosophy. If you are on a Scrum Team building software with .NET technologies, this is the book for you. If you are using Java, this book is compelling enough to read anyway, and maybe worth switching to .NET. When we devised and signed the Agile Manifesto in 2001, our first value was “Individuals and interactions over processes and tools.” Well, we have the processes and tools nailed for the Microsoft environment. In Sam’s book, we have something developers, who are also people, can use to understand the approach and value of the processes and tools. Now the really hard work, people. After twenty years of being treated as resources, becoming accountable, creative, responsible people is hard. Our first challenge will be the people who manage the developers. They could use the metrics from the VS 2010 tooling to micro-manage the processes and developers, squeezing the last bit of creativity out and leaving Agility flat. Or, they could use the metrics from the tools to understand the challenges facing the developers. They could then coach and lead them to a better, more creative and productive place. This is the challenge of any tool. It may be excellent, but how it is used will determine its success. Thanks for the book, Sam. Praise for Agile Software Engineering with Visual Studio “Agile dominates projects increasingly from IT to product and business development, and Sam Guckenheimer and Neno Loje provide pragmatic context for users seeking clarity and specifics with this book. Their knowledge of past history and current practice, combined with acuity and details about Visual Studio’s agile capabilities, enable a precise path to execution. Yet their voice and advice remain non-dogmatic and wise. Their examples are clear and relevant, enabling a valuable perspective to those seeking a broad and deep historical background along with a definitive understanding of the way in which Visual Studio can incorporate agile approaches.”—Melinda Ballou, Program Director, Application Lifecycle Management and Executive Strategies Service, International Data Corporation (IDC) “Sam Guckenheimer and Neno Loje have forgotten more about software development processes than most development ‘gurus’ ever knew, and that’s a good thing! In Agile Software Engineering with Visual Studio, Sam and Neno distill the essence of years of hard-won experience and hundreds of pages of process theory into what really matters—the techniques that high performance software teams use to get stuff done. By combining these critical techniques with examples of how they work in Visual Studio, they created a de-facto user guide that no Visual Studio developer should be without.”—Jeffrey Hammond, Principal Analyst, Forrester Research “If you employ Microsoft’s Team Foundation Server and are considering Agile projects, this text will give you a sound foundation of the principles behind its agile template and the choices you will need to make. The insights from Microsoft’s own experience in adopting agile help illustrate challenges with scale and the issues beyond pure functionality that a team needs to deal with. This book pulls together into one location a wide set of knowledge and practices to create a solid foundation to guide the decisions and effective transition, and will be a valuable addition to any team manager’s bookshelf.”—Thomas Murphy, Research Director, Gartner “This book presents software practices you should want to implement on your team and the tools available to do so. It paints a picture of how first class teams can work, and in my opinion, is a must read for anyone involved in software development. It will be mandatory reading for all our consultants.”—Claude Remillard, President, InCycle “This book is the perfect tool for teams and organizations implementing agile practices using Microsoft’s Application Lifecycle Management platform. It proves disciplined engineering and agility are not at odds; each needs the other to be truly effective.”—David Starr, Scrum.org “Sam Guckenheimer and Neno Loje have written a very practical book on how Agile teams can optimize their practices with Visual Studio. It describes not only how Agile and Visual Studio work, but also the motivation and context for many of the functions provided in the platform. If you are using Agile and Visual Studio, this book should be a required read for everyone on the team. If you are not using Agile or Visual Studio, then reading this book will describe a place that perhaps you want to get to with your process and tools.”—Dave West, Analyst, Forrester Research “Sam Guckenheimer and Neno Loje are leading authorities on agile methods and Visual Studio. The book you are holding in your hand is the authoritative way to bring these two technologies together. If you are a Visual Studio user doing agile, this book is a must read.”—Dr. James A. Whittaker, Software Engineering Director Google “Agile development practices are a core part of modern software development. Drawing from our own lessons in adopting agile practices at Microsoft, Sam Guckenheimer and Neno Loje ...
Author(s): Sam Guckenheimer, Neno Loje
Edition: 2
Publisher: Addison-Wesley Professional
Year: 2011
Language: English
Pages: 321
Contents......Page 10
Foreword......Page 18
Preface......Page 20
Acknowledgements......Page 27
About the Authors......Page 28
The Origins of Agile......Page 32
Agile Emerged to Handle Complexity......Page 33
A New Consensus......Page 35
Scrum......Page 37
Potentially Shippable......Page 38
Increasing the Flow of Value in Software......Page 39
Reducing Waste in Software......Page 40
Technical Debt......Page 42
An Example......Page 43
Self-Managing Teams......Page 44
Summary......Page 46
End Notes......Page 47
2 Scrum, Agile Practices, and Visual Studio......Page 50
Visual Studio and Process Enactment......Page 51
Process Templates......Page 52
Teams......Page 53
Process Cycles and TFS......Page 54
Release......Page 55
Sprint......Page 57
Check-In......Page 61
Test Cycle......Page 62
Definition of Done at Every Cycle......Page 66
Task Boards......Page 67
Kanban......Page 69
Fit the Process to the Project......Page 70
Geographic Distribution......Page 71
One Project at a Time Versus Many Projects at Once......Page 72
Summary......Page 73
End Notes......Page 74
3 Product Ownership......Page 76
What Is Product Ownership?......Page 77
The Customer Value Problem: Dead Parrots......Page 78
The Scope-Creep Problem: Ships That Sink......Page 79
The Perishable Requirements Problem: Ineffective Armor......Page 80
Scrum Product Ownership......Page 81
Release Planning......Page 82
Customer Value......Page 83
Exciters, Satisfiers, and Dissatisfiers: Kano Analysis......Page 86
Design Thinking......Page 89
Customer Validation......Page 93
Qualities of Service......Page 94
Performance......Page 95
User Experience......Page 96
Manageability......Page 97
How Many Levels of Requirements......Page 98
Work Breakdown......Page 99
End Notes......Page 101
4 Running the Sprint......Page 104
Empirical over Defined Process Control......Page 106
Scrum Mastery......Page 107
Team Size......Page 108
Rapid Estimation (Planning Poker)......Page 109
A Contrasting Analogy......Page 111
Use Descriptive Rather Than Prescriptive Metrics......Page 112
Prevent Distortion......Page 115
Avoid Broken Windows......Page 116
Answering Everyday Questions with Dashboards......Page 117
Burndown......Page 118
Quality......Page 119
Bugs......Page 121
Test......Page 122
Build......Page 124
Choosing and Customizing Dashboards......Page 125
Using Microsoft Outlook to Manage the Sprint......Page 126
End Notes......Page 127
5 Architecture......Page 130
Inspect and Adapt: Emergent Architecture......Page 131
Architecture and Transparency......Page 132
Design for Maintainability......Page 133
Understanding the Code......Page 134
Maintaining Control......Page 140
Understanding the Domain......Page 144
Summary......Page 152
End Notes......Page 154
6 Development......Page 156
Development in the Agile Consensus......Page 157
Smells to Avoid in the Daily Cycle......Page 158
Catching Errors at Check-In......Page 159
Shelving Instead of Checking In......Page 165
Test-Driven Development Provides Clarity......Page 166
Catching Programming Errors with Code Reviews, Automated and Manual......Page 179
Isolating Unexpected Behavior......Page 183
Isolating the Root Cause in Production......Page 186
Tuning Performance......Page 187
What to Version......Page 191
Branching......Page 193
Working on Different Versions in Parallel......Page 194
Merging and Tracking Changes Across Branches......Page 196
Working with Eclipse or the Windows Shell Directly......Page 198
Making Work Transparent......Page 199
Summary......Page 200
End Notes......Page 202
7 Build and Lab......Page 204
Cycle Time......Page 205
Defining Done......Page 206
Continuous Integration......Page 208
Automating the Build......Page 210
Daily Build......Page 211
Build Report......Page 212
Maintaining the Build Agents......Page 214
Setting Up a Test Lab......Page 216
Does It Work in Production as Well as in the Lab?......Page 218
Automating Deployment and Test......Page 221
Get PBIs Done......Page 227
Integrate As Frequently As Possible......Page 228
Detecting Inefficiencies Within the Flow......Page 229
Summary......Page 232
End Notes......Page 233
8 Test......Page 234
Testing in the Agile Consensus......Page 235
Testing and Flow of Value......Page 236
Testing and Reduction of Waste......Page 237
Testing Product Backlog Items......Page 238
The Most Important Tests First......Page 240
Actionable Test Results and Bug Reports......Page 243
No More “No Repro”......Page 245
Use Exploratory Testing to Avoid False Confidence......Page 247
Handling Bugs......Page 249
Which Tests Should Be Automated?......Page 250
Automating Scenario Tests......Page 251
Testing “Underneath the Browser” Using HTTP......Page 252
Load Tests, as Part of the Sprint......Page 256
Understanding the Output......Page 259
Diagnosing the Performance Problem......Page 260
Production-Realistic Test Environments......Page 261
Risk-Based Testing......Page 263
Capturing Risks as Work Items......Page 265
Summary......Page 266
End Notes......Page 267
9 Lessons Learned at Microsoft Developer Division......Page 270
Scale......Page 271
Culture......Page 272
Waste......Page 274
Debt Crisis......Page 275
Get Clean, Stay Clean......Page 276
Defining Done......Page 277
Product Backlog......Page 280
Iteration Backlog......Page 282
Results......Page 285
Social Contracts Need Renewal......Page 286
Lessons (Re)Learned......Page 287
Celebrate Successes, but Don’t Declare Victory......Page 289
End Notes......Page 290
10 Continuous Feedback......Page 292
Agile Consensus in Action......Page 293
The Next Version......Page 294
Storyboarding......Page 295
Getting Feedback on Working Software......Page 296
Balancing Capacity......Page 298
Managing Work Visually......Page 299
Staying in the Groove......Page 301
Collaborating on Code......Page 303
Cleaning Up the Campground......Page 304
TFS in the Cloud......Page 306
Conclusion......Page 307
Living on the Edge of Chaos......Page 309
End Notes......Page 310
A......Page 312
C......Page 313
D......Page 314
K-L......Page 315
P......Page 316
Q-R......Page 317
S......Page 318
T......Page 319
W-X-Y-Z......Page 320
