Pub. Date:
Essential Skills for the Agile Developer: A Guide to Better Programming and Design / Edition 1

Essential Skills for the Agile Developer: A Guide to Better Programming and Design / Edition 1

Current price is , Original price is $49.99. You

Temporarily Out of Stock Online

Please check back later for updated availability.

Product Details

ISBN-13: 9780321543738
Publisher: Addison-Wesley
Publication date: 09/02/2011
Series: Net Objectives Lean-Agile Series
Pages: 272
Product dimensions: 6.90(w) x 9.00(h) x 0.70(d)

About the Author

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.

Table of Contents

Series Foreword xvii

Preface xxi

Acknowledgments xxiii

About the Authors xxv

Part I: The Core Trim Tabs 1

Chapter 1: Programming by Intention 3

Programming by Intention: A Demonstration 3

Advantages 6

Summary 18

Chapter 2: Separate Use from Construction 21

An Important Question to Ask 21

Perspectives 22

Timing Your Decisions 30

Overloading and C++ 31

Validating This for Yourself 32

Summary 33

Chapter 3: Define Tests Up Front 35

A Trim Tab: Testing and Testability 35

What Is Testing? 35

Testability and Code Quality 36

Case Study: Testability 37

A Reflection on Up-Front Testing 39

Summary 44

Chapter 4: Shalloway’s Law and Shalloway’s Principle 45

Types of Redundancy 46

Redefining Redundancy 46

Other Types of Redundancy 47

The Role of Design Patterns in Reducing Redundancy 48

Few Developers Spend a Lot of Time Fixing Bugs 48

Redundancy and Other Code Qualities 50

Summary 52

Chapter 5: Encapsulate That! 53

Unencapsulated Code: The Sabotage of the Global Variable 53

Encapsulation of Member Identity 54

Self-Encapsulating Members 56

Preventing Changes 58

The Difficulty of Encapsulating Reference Objects 59

Breaking Encapsulation with Get() 62

Encapsulation of Object Type 64

Encapsulation of Design 67

Encapsulation on All Levels 69

Practical Advice: Encapsulate Your Impediments 69

Summary 72

Chapter 6: Interface-Oriented Design 75

Design to Interfaces 75

Definition of Interface 75

Interface Contracts 76

Separating Perspectives 77

Mock Implementations of Interfaces 79

Keep Interfaces Simple 79

Avoids Premature Hierarchies 80

Interfaces and Abstract Classes 81

Dependency Inversion Principle 82

Polymorphism in General 83

Not for Every Class 84

Summary 84

Chapter 7: Acceptance Test—Driven Development (ATDD) 85

Two Flows for Development 85

Acceptance Tests 88

An Example Test 88

Implementing the Acceptance Tests 90

An Exercise 95

What to Do If the Customer Won’t Tell You 95

Summary 96

Part II: General Attitudes 97

Chapter 8: Avoid Over- and Under-Design 99

A Mantra for Development 99

The Pathologies of Code Qualities 100

Avoid Over- and Under-Design 101

Minimize Complexity and Rework 102

Never Make Your Code Worse/Only Degrade Your Code Intentionally 102

Keep Your Code Easy to Change, Robust, and Safe to Change 103

A Strategy for Writing Modifiable Code in a Non-Object-Oriented or Legacy System 103

Summary 107

Chapter 9: Continuous Integration 109

Branching the Source Code 109

The Merge-Back 115

Test-Driven Development and Merge Cost 117

Continuous Integration 119

Continuous Integration Servers 121

Summary 122

Part III: Design Issues 125

Chapter 10: Commonality and Variability Analysis 127

Using Nouns and Verbs as a Guide: Warning, Danger Ahead! 127

What Is the Real Problem? 130

What We Need to Know 131

Commonality and Variability Analysis 132

A New Paradigm for Finding Objects 134

The Analysis Matrix: A Case Study 136

Summary 145

Chapter 11: Refactor to the Open-Closed 147

The Open-Closed Principle 147

Refactoring 154

Summary 161

Chapter 12: Needs versus Capabilities Interfaces 163

The Law of Demeter 163

Coupling, Damned Coupling, and Dependencies 166

The Ideal Separation: Needs Interfaces and Capabilities Interfaces 168

Back to the Law of Demeter 169

Summary 171

Chapter 13: When and How to Use Inheritance 173

The Gang of Four 173

Initial Vectors, Eventual Results 176

Favoring Delegation 178

The Use of Inheritance versus Delegation 180

Uses of Inheritance 181

Scalability 183

Applying the Lessons from the Gang of Four to Agile Development 184

Testing Issues 185

There’s More 187

Part IV: Appendixes 189

Appendix A: Overview of the Unified Modeling Language (UML) 191

What Is the UML? 191

The Class Diagram 192

Sequence Diagram 198

Summary 200

Appendix B: Code Qualities 201

Christmas-Tree Lights: An Analogy 201

Cohesion 204

Coupling 205

Redundancy 207

Encapsulation 208

Appendix C: Encapsulating Primitives 211

Encapsulating Primitives in Abstract Data Types 211

Principles 212

Narrow the Contract 213

Expanding Abstract Data Types 214

Use Text as External Values 215

Enumerations Instead of Magic Values 217

Disadvantages 218

Summary 219

Index 221

Customer Reviews

Most Helpful Customer Reviews

See All Customer Reviews