Home > Store

Essential Skills for the Agile Developer

Essential Skills for the Agile Developer

eBook (Watermarked)

  • Your Price: $31.99
  • List Price: $39.99
  • Includes EPUB, MOBI, and PDF
  • About eBook Formats
  • This eBook includes the following formats, accessible from your Account page after purchase:

    ePub EPUB The open industry format known for its reflowable content and usability on supported mobile devices.

    MOBI MOBI The eBook format compatible with the Amazon Kindle and Amazon Kindle applications.

    Adobe Reader PDF The popular standard, used most often with the free Adobe® Reader® software.

    This eBook requires no passwords or activation to read. We customize your eBook by discreetly watermarking it with your name, making it uniquely yours.

Also available in other formats.

Register your product to gain access to bonus material or receive a coupon.


  • Copyright 2012
  • Dimensions: 7" x 9-1/8"
  • Edition: 1st
  • eBook (Watermarked)
  • ISBN-10: 0-321-76943-0
  • ISBN-13: 978-0-321-76943-5

Agile has become today’s dominant software development paradigm, but agile methods remain difficult to measure and improve. Essential Skills for the Agile Developer fills this gap from the bottom up, teaching proven techniques for assessing and optimizing both individual and team agile practices.

Written by four principals of Net Objectives—one of the world’s leading agile training and consulting firms—this book reflects their unsurpassed experience helping organizations transition to agile. It focuses on the specific actions and insights that can deliver the greatest design and programming improvements with economical investment.

The authors reveal key factors associated with successful agile projects and offer practical ways to measure them. Through actual examples, they address principles, attitudes, habits, technical practices, and design considerations—and above all, show how to bring all these together to deliver higher-value software. Using the authors’ techniques, managers and teams can optimize the whole organization and the whole product across its entire lifecycle.

Essential Skills for the Agile Developer shows how to

  • Perform programming by intention
  • Separate use from construction
  • Consider testability before writing code
  • Avoid over- and under-design
  • Succeed with Acceptance Test Driven Development (ATDD)
  • Minimize complexity and rework
  • Use encapsulation more effectively and systematically
  • Know when and how to use inheritance
  • Prepare for change more successfully
  • Perform continuous integration more successfully
  • Master powerful best practices for design and refactoring

Sample Content

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


Submit Errata

More Information

Unlimited one-month access with your purchase
Free Safari Membership