Essential Skills for the Agile Developer

Alan Shalloway, founder and CEO of Net Objectives, is a renowned thought leader, trainer, and coach in Lean, Kanban, product portfolio management, Scrum, and agile design. His books include Lean-Agile Software Development (Addison-Wesley, 2009), Lean-Agile Pocket Guide For Scrum Teams (Lean-Agile Press, 2009), and both editions of Design Patterns Explained (Addison-Wesley, 2001 and 2004).  Scott Bain, senior consultant at Net Objectives, is a 35+-year veteran in software development, engineering, and design. He authored the Jolt award-winning book Emergent Design (Addison-Wesley, 2008).  Ken Pugh, a fellow consultant at Net Objectives, helps companies move to Lean-Agility through training and coaching. His books include Lean-Agile Acceptance Test Driven Development (Addison-Wesley, 2011) and the Jolt Award-winner Prefactoring (O’Reilly, 2005).  Amir Kolsky is a senior consultant, coach, and trainer for Net Objectives with more than 25 years of experience.

“I tell teams that the lean and agile practices should be treated like a buffet: Don’t try and take everything, or it will make you ill–try the things that make sense for your project. In this book the authors have succinctly described the ‘why’ and the ‘how’ of some of the most effective practices, enabling all software engineers to write quality code for short iterations in an efficient manner.” –Kay JohnsonSoftware Development Effectiveness Consultant, IBM  “Successful agile development requires much more than simply mastering a computer language. It requires a deeper understanding of agile development methodologies and best practices. Essential Skills for the Agile Developer provides the perfect foundation for not only learning but truly understanding the methods and motivations behind agile development.”–R.L. Bogettiwww.RLBogetti.comLead System Designer, Baxter Healthcare  “Essential Skills for the Agile Developer is an excellent resource filled with practical coding examples that demonstrate key agile practices.”–Dave HendricksenSoftware Architect, Thomson Reuters

• Series Foreword xvii Preface xxiAcknowledgments xxiiiAbout the Authors xxv  Part I: The Core Trim Tabs 1  Chapter 1: Programming by Intention 3Programming by Intention: A Demonstration 3Advantages 6Summary 18  Chapter 2: Separate Use from Construction 21An Important Question to Ask 21Perspectives 22Timing Your Decisions 30Overloading and C++ 31Validating This for Yourself 32Summary 33  Chapter 3: Define Tests Up Front 35A Trim Tab: Testing and Testability 35What Is Testing? 35Testability and Code Quality 36Case Study: Testability 37A Reflection on Up-Front Testing 39Summary 44  Chapter 4: Shalloway’s Law and Shalloway’s Principle 45Types of Redundancy 46Redefining Redundancy 46Other Types of Redundancy 47The Role of Design Patterns in Reducing Redundancy 48Few Developers Spend a Lot of Time Fixing Bugs 48Redundancy and Other Code Qualities 50Summary 52  Chapter 5: Encapsulate That! 53Unencapsulated Code: The Sabotage of the Global Variable 53Encapsulation of Member Identity 54Self-Encapsulating Members 56Preventing Changes 58The Difficulty of Encapsulating Reference Objects 59Breaking Encapsulation with Get() 62Encapsulation of Object Type 64Encapsulation of Design 67Encapsulation on All Levels 69Practical Advice: Encapsulate Your Impediments 69Summary 72  Chapter 6: Interface-Oriented Design 75Design to Interfaces 75Definition of Interface 75Interface Contracts 76Separating Perspectives 77Mock Implementations of Interfaces 79Keep Interfaces Simple 79Avoids Premature Hierarchies 80Interfaces and Abstract Classes 81Dependency Inversion Principle 82Polymorphism in General 83Not for Every Class 84Summary 84  Chapter 7: Acceptance Test—Driven Development (ATDD) 85Two Flows for Development 85Acceptance Tests 88An Example Test 88Implementing the Acceptance Tests 90An Exercise 95What to Do If the Customer Won’t Tell You 95Summary 96  Part II: General Attitudes 97  Chapter 8: Avoid Over- and Under-Design 99A Mantra for Development 99The Pathologies of Code Qualities 100Avoid Over- and Under-Design 101Minimize Complexity and Rework 102Never Make Your Code Worse/Only Degrade Your Code Intentionally 102Keep Your Code Easy to Change, Robust, and Safe to Change 103A Strategy for Writing Modifiable Code in a Non-Object-Oriented or Legacy System 103Summary 107  Chapter 9: Continuous Integration 109Branching the Source Code 109The Merge-Back 115Test-Driven Development and Merge Cost 117Continuous Integration 119Continuous Integration Servers 121Summary 122  Part III: Design Issues 125  Chapter 10: Commonality and Variability Analysis 127Using Nouns and Verbs as a Guide: Warning, Danger Ahead! 127What Is the Real Problem? 130What We Need to Know 131Commonality and Variability Analysis 132A New Paradigm for Finding Objects 134The Analysis Matrix: A Case Study 136Summary 145  Chapter 11: Refactor to the Open-Closed 147The Open-Closed Principle 147Refactoring 154Summary 161  Chapter 12: Needs versus Capabilities Interfaces 163The Law of Demeter 163Coupling, Damned Coupling, and Dependencies 166The Ideal Separation: Needs Interfaces and Capabilities Interfaces 168Back to the Law of Demeter 169Summary 171  Chapter 13: When and How to Use Inheritance 173The Gang of Four 173Initial Vectors, Eventual Results 176Favoring Delegation 178The Use of Inheritance versus Delegation 180Uses of Inheritance 181Scalability 183Applying the Lessons from the Gang of Four to Agile Development 184Testing Issues 185There’s More 187  Part IV: Appendixes 189  Appendix A: Overview of the Unified Modeling Language (UML) 191What Is the UML? 191The Class Diagram 192Sequence Diagram 198Summary 200  Appendix B: Code Qualities 201Christmas-Tree Lights: An Analogy 201Cohesion 204Coupling 205Redundancy 207Encapsulation 208  Appendix C: Encapsulating Primitives 211Encapsulating Primitives in Abstract Data Types 211Principles 212Narrow the Contract 213Expanding Abstract Data Types 214Use Text as External Values 215Enumerations Instead of Magic Values 217Disadvantages 218Summary 219  Index 221