O'Reilly logo

Stay ahead with the world's most comprehensive technology and business learning platform.

With Safari, you learn the way you learn best. Get unlimited access to videos, live online training, learning paths, books, tutorials, and more.

Start Free Trial

No credit card required

The Art of Lean Software Development

Book Description

This succinct book explains how you can apply the practices of Lean software development to dramatically increase productivity and quality. Based on techniques that revolutionized Japanese manufacturing, Lean principles are being applied successfully to product design, engineering, the supply chain, and now software development. With The Art of Lean Software Development, you'll learn how to adopt Lean practices one at a time rather than taking on the entire methodology at once. As you master each practice, you'll see significant, measurable results. With this book, you will:

  • Understand Lean's origins from Japanese industries and how it applies to software development
  • Learn the Lean software development principles and the five most important practices in detail
  • Distinguish between the Lean and Agile methodologies and understand their similarities and differences
  • Determine which Lean principles you should adopt first, and how you can gradually incorporate more of the methodology into your process
  • Review hands-on practices, including descriptions, benefits, trade-offs, and roadblocks
  • Learn how to sell these principles to management

The Art of Lean Software Development is ideal for busy people who want to improve the development process but can't afford the disruption of a sudden and complete transformation. The Lean approach has been yielding dramatic results for decades, and with this book, you can make incremental changes that will produce immediate benefits.

"This book presents Lean practices in a clear and concise manner so readers are motivated to make their software more reliable and less costly to maintain. I recommend it to anyone looking for an easy-to-follow guide to transform how the developer views the process of writing good software."-- Bryan Wells, Boeing Intelligence & Security Sytems Mission System

"If you're new to Lean software development and you're not quite sure where to start, this book will help get your development process going in the right direction, one step at a time."-- John McClenning, software development lead, Aclara

Table of Contents

  1. Preface
    1. Who Should Read This Book?
    2. Conventions Used in This Book
    3. Using Code Examples
    4. Safari® Books Online
    5. Comments and Questions
    6. Acknowledgments
  2. 1. Why Lean?
    1. The Problem with Software Development
      1. The CHAOS Study
      2. The Waterfall Method
        1. A historical accident
    2. The Agile Success Story
      1. The Agile Manifesto
      2. Agile Methodologies
    3. The Lean Success Story
      1. A Whirlwind History of Lean
        1. Just-In-Time
        2. Autonomation (Jidoka)
        3. Waste (Muda)
    4. Lean Principles
  3. 2. Applying Lean to Software Development
    1. Lean Software Development
      1. Eliminate Waste
        1. Defects → defects
        2. Overproduction → extra features
        3. Transportation → handoffs
        4. Waiting → delays
        5. Inventory → partially completed work
        6. Motion → task switching
        7. (Over) processing → unneeded processes
      2. Build Quality in
      3. Create Knowledge
      4. Defer Commitment
      5. Deliver Fast
      6. Respect People
      7. Optimize the Whole
    2. Lean Versus Agile
    3. Getting Started
      1. The Good News
  4. 3. Practice 0: Source Code Management and Scripted Builds
    1. About Zero Practices
    2. Source Code Management
      1. Benefits
      2. Centralized SCM
        1. Command line versus GUI tool
      3. Distributed SCM
      4. If You Don’t Know Where to Start
    3. Scripted Builds
    4. Discipline in an Integrated Environment
      1. Share
      2. Coordinate
    5. Summary
  5. 4. Practice 1: Automated Testing
    1. Why Test?
    2. What Is Automated Testing?
      1. The Test Harness and Test Suites
      2. Running Automated Tests
    3. Kinds of Tests
      1. Unit Tests
      2. Mocks and Stubs
      3. Integration Tests
      4. Behavior Tests
      5. Executable Specifications
      6. Nonfunctional Testing
      7. User Interface Testing
    4. Approaches to Testing
      1. Using Setup and Teardown
      2. Testing with Databases
      3. Test-Driven Development
      4. Red, Green, Refactor
      5. Legacy Code
      6. Behavior-Driven Development
    5. Summary
  6. 5. Practice 2: Continuous Integration
    1. End-to-End Automated Builds
      1. Building from Scratch
      2. End-to-End Builds
      3. Reporting Results
    2. Dedicated Build Servers
      1. Dedicated Build Servers Isolate Build Activities
      2. Dedicated Build Servers Provide a Well-Known Build Environment Configuration
      3. Dedicated Build Servers Require Extra Hardware
    3. Continuous Integration Software
      1. CI Servers Detect Changes in the SCM Repository
      2. CI Servers Invoke Build Scripts
      3. CI Servers Report Build Results
      4. CI Servers Can Schedule Builds
    4. Implementing Continuous Integration
      1. Developers and the CI Process
    5. Continuous Integration Builds Quality in
      1. Aid Debugging by Limiting the Scope of Errors
      2. Provide Immediate Feedback for Changes
      3. Minimize Integration Effort
      4. Minimize Propagation of Defects
      5. Create a Safety Net for Developers
      6. Ensure the Latest and Greatest Software Is Always Available
      7. Provide a Snapshot of the Current State of the Project
    6. Resistance to Implementing CI
      1. CI Requires Extra Hardware
      2. CI Requires New Software
      3. CI Adds Maintenance Tasks
      4. CI for Legacy Code Is Expensive
    7. Summary
  7. 6. Practice 3: Less Code
    1. Leaning out the Codebase
      1. Eliminate Unnecessary Code
      2. Employ Good Coding Practices
      3. Justify All New Code
    2. Developing Less Code
      1. Prioritize Requirements
      2. Develop in Short Iterations
      3. Develop Only for the Current Iteration
      4. Avoid Unnecessary Complexity
      5. Reuse Existing Software
      6. Use Coding Standards and Best Practices
      7. Use Design Patterns
      8. Refactor Code and Design
    3. Resistance to “Less Code”
    4. Summary
  8. 7. Practice 4: Short Iterations
    1. Short Iterations Generate Customer Value
      1. Increase Feedback Opportunities
      2. Make Course Corrections
    2. Developing with Short Iterations
      1. Work to Prioritized Requirements
      2. Set an Iteration Length and Stick to It
      3. End Each Iteration with a Demo
      4. Deliver the Iteration’s Product to the Customer
    3. The Fallacy of Iterative Development
    4. Big Tasks in Little Pieces
    5. Summary
  9. 8. Practice 5: Customer Participation
    1. Customer Participation Is a Two-Way Street
      1. Involve the Customer Throughout the Development Process
      2. Keep the Customer Informed
      3. Act on Customer Feedback
    2. Paving the Street
      1. Designate a Product Owner
      2. Engage the Customer in Writing Requirements and Acceptance Tests
      3. Provide Project Status
      4. Provide Access to the Product
      5. Create a Feedback Path
      6. Find CRACK Customer Representatives
    3. An All-Too-Common Problem
    4. Summary
  10. 9. What Next?
    1. Lean Thinking and the Analysis Practices
    2. Kaizen
    3. Kaizen Workshops
    4. Value Stream Maps
    5. Other Lean Techniques
      1. Root Cause Analysis (Five Whys)
      2. Kanban
      3. Make It Visible
    6. Other Complementary Approaches
      1. Theory of Constraints
      2. Six Sigma
      3. Capability Maturity Model Integration
    7. Where to Go from Here
  11. A. Resources
    1. Chapter 1: Why Lean?
    2. Chapter 2: Applying Lean to Software Development
    3. Chapter 3: Practice 0: Source Code Management and Scripted Builds
    4. Chapter 4: Practice 1: Automated Testing
    5. Chapter 5: Practice 2: Continuous Integration
    6. Chapter 6: Practice 3: Less Code
    7. Chapter 7: Practice 4: Short Iterations
    8. Chapter 8: Practice 5: Customer Participation
    9. Chapter 9: What Next?
    10. Other
  12. Index
  13. About the Authors
  14. Colophon
  15. Copyright