small medium large xlarge

Beyond Legacy Code: Nine Practices to Extend the Life (and Value) of Your Software


Cover image for Beyond Legacy Code

Beyond Legacy Code

Nine Practices to Extend the Life (and Value) of Your Software


We’re losing tens of billions of dollars a year on broken software, and great new ideas such as agile development and Scrum don’t always pay off. But there’s hope. The nine software development practices in Beyond Legacy Code are designed to solve the problems facing our industry. Discover why these practices work, not just how they work, and dramatically increase the quality and maintainability of any software project.

Customer Reviews

Beyond Legacy Code presents a fresh perspective on the modern software development
process. Engineers will find solutions to their day-to-day challenges. Nonengineers
will gain an appreciation for the challenges and difficulties of making

- Stas Zvinyatskovsky

Senior Principal Software Architect, Yahoo

David helps us see how we got where we are. He gives us things to do that will
help us. He gives us deep matters to think about. This book is a gift to people
who care about software. Take advantage of it.

- Ron Jeffries

If you feel stuck and powerless to improve your software delivery process, this
book will offer years of experience distilled in just a few core ideas. This is a great
book for anyone starting on a journey toward frequent iterative delivery, and for
those people who tried adopting an agile process and failed to get the big benefits.

- Gojko Adzic

Partner, Neuri Consulting LLP

This book provides great discussion on what things I can do to make customers
happy and also to keep them happy as their needs change.

- David Weiser

Software Engineer, Moz

It’s a good read for any developer or manager, working on any type of code in any

- Troy Magennis

Author of "Forecasting and Simulating Software Development Projects" , CEO Focused Objective

David’s explanations are so clear I am hopeful even managers of development
teams and leaders running companies who build custom software will pick up
this book and understand these practices that allow us to build software that is
economical to own, maintain, and enhance.

- Jim Fiolek

Software Architect, Black Knight Financial Services

Throughout the book there were points that gave me a sense of relief—where I
would think if only we could get people to follow these few principles our life, and
software, would be so much easier and less stressful.

- Nick Capito

Director of Software Engineering, Unboxed Technology

We fight to make every line of code we write part of a real live product. Find out
how that fight sometimes leads us astray. Find out how to make you and your
team much more productive in building real live products that customers want
now AND tomorrow.

- Michael Hunter

Geek, Hacker, Principal Engineer, Architect

See All Reviews

Choose Your Format(s)

  • $26.00 In Stock
  • Ebooks are DRM free.

  • Ebook delivery options.

About this Title

Pages: 274
Published: 2015-07-31
Release: P1.0 (2015-07-31)
ISBN: 978-1-68050-079-0

These nine practices could save the software industry. Beyond Legacy Code is filled with practical, hands-on advice and a common-sense exploration of why technical practices such as refactoring and test-first development are critical to building maintainable software. Discover how to avoid the pitfalls teams encounter when adopting these practices, and how to dramatically reduce the risk associated with building software—realizing significant savings in both the short and long term. With a deeper understanding of the principles behind the practices, you’ll build software that’s easier and less costly to maintain and extend.

By adopting these nine key technical practices, you’ll learn to say what, why, and for whom before how; build in small batches; integrate continuously; collaborate; create CLEAN code; write the test first; specify behaviors with tests; implement the design last; and refactor legacy code.

Software developers will find hands-on, pragmatic advice for writing higher quality, more maintainable, and bug-free code. Managers, customers, and product owners will gain deeper insight into vital processes. By moving beyond the old-fashioned procedural thinking of the Industrial Revolution, and working together to embrace standards and practices that will advance software development, we can turn the legacy code crisis into a true Information Revolution.

What You Need

(Not applicable)

Contents & Extracts

  • Introduction
  • The Legacy Code Crisis
    • Something’s Wrong
      • What is Legacy Code?
      • Down the Waterfall
      • Playing All or Nothing
      • Why Waterfall Doesn’t Work
      • When “Process” Becomes “Busy Work”
      • Concrete Management
      • Here Be Dragons
      • Estimating Unknowns
      • An Industry of Amateurs
      • Retrospective
    • Out of CHAOS
      • The CHAOS Report
      • Refuting Standish
      • Why Projects Fail
      • The Cost of Failure
      • Retrospective
    • Smart People, New Ideas
      • Enter Agile
      • Smaller is Better
      • Implementing Agile
      • Balancing Art and Craft
      • Agile Crosses the Chasm
      • Demand Technical Excellence
      • Retrospective
  • Nine Practices to Extend the Life (and Value) of Your Software
    • The Nine Practices excerpt
      • What Experts Know
      • Shu-Ha-Ri
      • First Principles
      • To Be a Principle
      • To Be a Practice
      • Principles Guide Practices
      • Anticipate or Accommodate
      • Defining “Good” in Software
      • Why Nine Practices
      • Retrospective
    • Practice 1: Say What, Why, and for Whom Before How excerpt
      • Don’t Say How
      • Turn “How” Into “What”
      • Have a Product Owner
      • Stories Tell What, Why, and for Whom
      • Set Clear Criteria for Acceptance Tests
      • Automate Acceptance Criteria
      • Let’s Get Practical
      • Retrospective
    • Practice 2: Build in Small Batches
      • Tell Smaller Lies
      • Be Willing to Flex
      • Cadence Dictates Process
      • Smaller is Better
      • Divide and Conquer
      • Shorten Feedback Cycles
      • Speed Up the Build
      • Respond to Feedback
      • Build a Backlog
      • Break Stories Into Tasks
      • Think Outside the Time Box
      • Manage Scope
      • Let’s Get Practical
      • Retrospective
    • Practice 3: Integrate Continuously
      • Establish the Heartbeat of a Project
      • Know the Difference Between Done, Done-Done, and Done-Done-Done
      • Practice Continuous Deployability
      • Automate the Build
      • Integrate Early and Often
      • Take the First Step
      • Let’s Get Practical
      • Retrospective
    • Practice 4: Collaborate
      • Extreme Programming
      • Communication and Collaboration
      • Pair Program
      • Buddy Program
      • Spike, Swarm, and Mob
      • Research Unknowns in Time Boxes
      • Schedule Code Reviews and Retrospectives
      • Amplify Learning and Spread Knowledge
      • Always Strive to be Mentoring and Mentored
      • Let’s Get Practical
      • Retrospective
    • Practice 5: Create CLEAN Code
      • Quality Code is Cohesive
      • Quality Code is Loosely Coupled
      • Quality Code is Encapsulated
      • Quality Code is Assertive
      • Quality Code is Non-Redundant
      • Code Qualities Guide Us
      • Increase Quality Today to Increase Velocity Tomorrow
      • Let’s Get Practical
      • Retrospective
    • Practice 6: Write the Test First
      • The Things We Call Tests
      • Quality Assurance
      • Write Good Tests
      • TDD Gives Rapid Feedback
      • TDD Supports Refactoring
      • Write Testable Code
      • TDD Can Fail
      • Introduce TDD to a Team
      • Become Test Infected
      • Let’s Get Practical
      • Retrospective
    • Practice 7: Specify Behaviors with Tests
      • Red Bar/Green Bar/Refactor
      • An Example of Specifying Behaviors Test-First
      • Introducing Constraints
      • What I Created
      • Tests are Specifications
      • Be Complete
      • Make Each Test Unique
      • Cover Code with Tests
      • Bugs are Missing Tests
      • Test Workflows with Mocks
      • Create a Safety Net
      • Let’s Get Practical
      • Retrospective
    • Practice 8: Implement the Design Last
      • Impediments to Changeability
      • Sustainable Development
      • Coding vs. Cleaning
      • Software is Read More Than It’s Written
      • Program by Intention
      • Reduce Cyclomatic Complexity
      • Separate Use from Creation
      • Emergent Design
      • Let’s Get Practical
      • Retrospective
    • Practice 9: Refactor Legacy Code excerpt
      • Investment or Debt?
      • Become a “Deadbeat”
      • When Code Needs to Change
      • Refactoring Techniques
      • Refactor to Accomodate Change
      • Refactor to the Open-Closed
      • Refactor to Support Changeability
      • Do It Right the Second Time
      • Let’s Get Practical
      • Retrospective
    • Learning from our Legacy
      • Better, Faster, Cheaper
      • Don’t Spend Money You Don’t Have To
      • Walk the Straight and Narrow
      • Improve the Software Profession
      • Beyond Agile
      • Embody Understanding
      • The Courage to Grow


David Scott Bernstein has shared his passion for building software with thousands of developers at hundreds of companies around the world including IBM, Microsoft, and Yahoo. His firm, To Be Agile, helps teams adopt Extreme Programming practices such as test-first development, pair programming, and refactoring.