Kill It with Fire

Book description

“Kill it with fire,” the typical first reaction to a legacy system falling into obsolescence, is a knee-jerk approach that often burns through tons of money and time only to result in a less efficient solution. This book offers a far more forgiving modernization framework, laying out smart value-add strategies and proven incremental techniques that work equally well for ancient systems and brand-new ones.

Internationally known for restoring some of the world’s oldest, messiest computer networks to operational excellence, software engineering expert Marianne Bellotti distills key lessons and insights from her experience into practical, research-backed guidance on topics from “chaos” testing solutions to building momentum-driven teams and effective communication structures. Using clear explanations and simple exercises, she’ll help you determine when to modernize, how to organize, what migrations will add the most value, and where to focus your maintenance efforts for maximum impact. With witty, engaging prose, Bellotti explains why new doesn’t always mean better, weaving in illuminating case studies and jaw-dropping anecdotes from her work in the field.

You’ll learn:

•Tips and best practices for assessing architecture and testing assumptions
•How to avoid trends and pick the right modernization solutions for your specific needs
•How to determine whether your migrations will add value before you invest in them
•Critical considerations every organization should weigh before moving data to the cloud
•Team-based strategies and motivational tricks for keeping modernization plans on track
•Key outcomes and checklists for determining when a project is finished

Packed with resources, exercises, and flexible frameworks for organizations of all ages and sizes, Kill It with Fire will give you a vested interest in your technology’s future.

Table of contents

  1. Introduction
  2. Chapter 1: Time Is a Flat Circle
    1. Leveraging What Came Before
    2. The User as the Market Co-Creator
    3. The Mainframe and the Cloud
    4. The Flat-Rate Internet
    5. Migrating for Value, Not for Trends
  3. Chapter 2: Cannibal Code
    1. Alignable Differences and User Interfaces
    2. Unix Eats the World
    3. Inheritance Paths
    4. Leveraging Interfaces When Approaching Legacy Systems
    5. Beware Artificial Consistency
  4. Chapter 3: Evaluating Your Architecture
    1. Problem 1: Technical Debt
    2. Example: The General Ledger
    3. Problem 2: Performance Issues
    4. Example: Case Flow Management
    5. Problem 3: Stability Issues
    6. Example: Custom Configuration
    7. Stages of a Modernization Plan
    8. No Silver Bullets
    9. Full Rewrite
    10. Iteration in Place
    11. Split in Place
    12. Blue-Green
    13. The Hard Cutoff
    14. Putting It Together
  5. Chapter 4: Why Is It Hard?
    1. The Curse of Hindsight
    2. Easy and Also Impossible
    3. Overgrowth: The Application and Its Dependencies
      1. Shifting Vertically: Moving from One Abstraction Layer to Another
      2. Shifting Horizontally: Moving from One Application to Another
      3. Shifting from Client to Server
      4. Shifting Down the Dependency Tree
    4. Cutting Back the Overgrowth
    5. Automation and Conversion
      1. Transpiling Code
      2. Static Analysis
    6. A Guide to Not Making Things Harder
  6. Chapter 5: Building and Protecting Momentum
    1. Momentum Builder: The Bliss of Measurable Problems
      1. Anatomy of the Measurable Problem
    2. Momentum Killer: The Team Cannot Agree
      1. Step 1: Define a Scope
      2. Step 2: Check for Conflicting Optimization Strategies
      3. Step 3: Perform Time-Boxed Experiments
    3. Momentum Killer: A History of Failure
    4. Momentum Builder: Inspiring Urgency
    5. Protecting Momentum: A Quota on Big Decisions
    6. Protecting Momentum: Calculating Opportunity Costs
      1. The Cost of Not Adding New Features
      2. The Cost of Not Fixing Something Else
      3. The Cost of Not Deprecating in Favor of a Different Solution
  7. Chapter 6: Coming in Midstream
    1. Finding the Bleed
    2. Mess: Fixing Things That Are Not Broken
      1. Figuring Out Whether Something Needs to Be Fixed
      2. But . . . What About Conventions?
      3. When Does Breaking Up Add Value?
    3. The Compounding Problem: Diminishing Trust
    4. Solution: Formal Methods
    5. Mess: Forgotten and Lost Systems
    6. The Compounding Problem: Crippling Risk Avoidance
    7. Solution: Chaos Testing
    8. Mess: Institutional Failures
    9. The Compounding Problem: No Owners
    10. Solution: Code Yellow
      1. Calling a Code Yellow
      2. Running a Code Yellow
    11. Mess: Leadership Has Lost the Room
    12. The Compounding Problem: Self-Sabotaging Teams
    13. Solution: Murder Boards
    14. Stopping the Bleed
  8. Chapter 7: Design as Destiny
    1. Designing Technical Conversations
    2. How to Run a Design Exercise
    3. More About Follow-ups: Why vs. How
    4. Some Useful Design Exercises for Engineering Teams
      1. Exercise: Critical Factors3
      2. Exercise: The Saboteur4
      3. Exercise: Shared Uncertainties5
      4. Exercise: The 15 Percent6
    5. Exercises Specifically for Decisions
      1. Exercise: Probabilistic Outcome-Based Decision-Making
      2. Exercise: Affinity Mapping
    6. Team Structure, Organization Structure, and Incentives
    7. Individual Incentives
    8. Minor Adjustments as Uncertainty
    9. Organization Size and Communication
    10. Manager Incentives
    11. Designing a Team: Applications of Conway’s Law
    12. Reorgs Are Traumatic
    13. Finding the Right Leadership
      1. Exercise: The Smallest Testable Unit
    14. Structuring the Team to Account for Past Failure
      1. Exercise: In-Group/Out-Group
    15. Takeaways
  9. Chapter 8: Breaking Changes
    1. Being Seen
    2. Who Draws the Line?
    3. Building Trust Through Failure
    4. Breaking Change vs. Breaking
    5. Why Break Things on Purpose?
    6. Projecting Impact
    7. The Kill Switch
    8. Communicating Failure
    9. Failure Is a Best Practice
  10. Chapter 9: How to Finish
    1. Revealing Assumptions
    2. Approach 1: Success Criteria
      1. Example: Adding Continuous Integration/Continuous Deploy
    3. Approach 2: Diagnosis-Policy-Actions
      1. Example: Upgrading a Database
    4. Comparison
    5. Marking Time
    6. Postmortems on Success
      1. Postmortem vs. Retrospective
      2. Running Postmortems
    7. The Tale of Two War Rooms
    8. Working Groups vs. Committees
    9. Success Is Not Obvious If Undefined
  11. Chapter 10: Future-Proofing
    1. Time
    2. Unescapable Migrations
    3. Failing Gracefully
    4. Less Time Between Upgrades, Not More
    5. A Word of Caution About Automation
    6. Building Something Wrong the Correct Way
    7. Feedback Loops
    8. Don’t Stop the Bus
  12. Conclusion
  13. Index

Product information

  • Title: Kill It with Fire
  • Author(s): Marianne Bellotti
  • Release date: April 2021
  • Publisher(s): No Starch Press
  • ISBN: 9781718501188