Cover image for The Art of Lean Software Development

Book description

This succinct book explains how you can apply the practices of Leansoftware development to dramatically increase productivity andquality. Based on techniques that revolutionized Japanesemanufacturing, Lean principles are being applied successfully toproduct design, engineering, the supply chain, and now softwaredevelopment. With The Art of Lean Software Development,you'll learn how to adopt Lean practices one at a time rather thantaking on the entire methodology at once. As you master eachpractice, you'll see significant, measurable results. With thisbook, you will:

  • Understand Lean's origins from Japanese industries and how itapplies to software development

  • Learn the Lean software development principles and the fivemost important practices in detail

  • Distinguish between the Lean and Agile methodologies andunderstand their similarities and differences

  • Determine which Lean principles you should adopt first, and howyou can gradually incorporate more of the methodology into yourprocess

  • 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 busypeople who want to improve the development process but can't affordthe disruption of a sudden and complete transformation. The Leanapproach has been yielding dramatic results for decades, and withthis book, you can make incremental changes that will produceimmediate benefits."This book presents Lean practices in a clear and concise manner soreaders are motivated to make their software more reliable and lesscostly to maintain. I recommend it to anyone looking for aneasy-to-follow guide to transform how the developer views theprocess of writing good software." -- Bryan Wells, BoeingIntelligence & Security Sytems Mission System"If you're new to Lean software development and you're not quitesure where to start, this book will help get your developmentprocess going in the right direction, one step at a time." -- JohnMcClenning, software development lead, Aclara

    Table of Contents

    1. The Art of Lean Software Development
      1. SPECIAL OFFER: Upgrade this ebook with O’Reilly
      2. 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
      3. 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
      4. 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
      5. 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
      6. 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
      7. 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
      8. 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
      9. 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
      10. 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
      11. 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
      12. 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
      13. Index
      14. About the Authors
      15. Colophon
      16. SPECIAL OFFER: Upgrade this ebook with O’Reilly