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.
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.
Author(s): David Scott Bernstein
Edition: 1
Publisher: Pragmatic Bookshelf
Year: 2015
Language: English
Commentary: Publisher PDF
Pages: 276
Tags: Legacy Code; Code Maintenance; Agile; Code Refactoring; Software Development
Cover
Table of Contents
Foreword
Legacy
Agility
Work
Acknowledgments
Introduction
How to Use This Book
Online Resources
Part I—The Legacy Code Crisis
1. 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
2. Out of CHAOS
The CHAOS Report
Refuting Standish
Why Projects Fail
The Cost of Failure
Retrospective
3. Smart People, New Ideas
Enter Agile
Smaller Is Better
Implementing Agile
Balancing Art and Craft
Agile Crosses the Chasm
Demand Technical Excellence
Retrospective
Part II—Nine Practices to Extend the Life (and Value) of Your Software
4. The Nine Practices
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
5. Practice 1: Say What, Why, and for Whom Before How
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
6. 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
7. 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
8. 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
9. 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 Nonredundant
Code Qualities Guide Us
Increase Quality Today to Increase Velocity Tomorrow
Let’s Get Practical
Retrospective
10. 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
11. 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
12. 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
13. Practice 9: Refactor Legacy Code
Investment or Debt?
Become a “Deadbeat”
When Code Needs to Change
Refactoring Techniques
Refactor to Accommodate Change
Refactor to the Open-Closed
Refactor to Support Changeability
Do It Right the Second Time
Let’s Get Practical
Retrospective
14. 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
Bibliography
Index
– A –
– B –
– C –
– D –
– E –
– F –
– G –
– H –
– I –
– J –
– K –
– L –
– M –
– N –
– O –
– P –
– Q –
– R –
– S –
– T –
– U –
– V –
– W –
– X –
– Z –
