0%

“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
    4. Shifting Vertically: Moving from One Abstraction Layer to Another
    5. Shifting Horizontally: Moving from One Application to Another
    6. Shifting from Client to Server
    7. Shifting Down the Dependency Tree
    8. Cutting Back the Overgrowth
    9. Automation and Conversion
    10. Transpiling Code
    11. Static Analysis
    12. A Guide to Not Making Things Harder
  6. Chapter 5: Building and Protecting Momentum
    1. Momentum Builder: The Bliss of Measurable Problems
    2. Anatomy of the Measurable Problem
    3. Momentum Killer: The Team Cannot Agree
    4. Step 1: Define a Scope
    5. Step 2: Check for Conflicting Optimization Strategies
    6. Step 3: Perform Time-Boxed Experiments
    7. Momentum Killer: A History of Failure
    8. Momentum Builder: Inspiring Urgency
    9. Protecting Momentum: A Quota on Big Decisions
    10. Protecting Momentum: Calculating Opportunity Costs
    11. The Cost of Not Adding New Features
    12. The Cost of Not Fixing Something Else
    13. 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
    3. Figuring Out Whether Something Needs to Be Fixed
    4. But . . . What About Conventions?
    5. When Does Breaking Up Add Value?
    6. The Compounding Problem: Diminishing Trust
    7. Solution: Formal Methods
    8. Mess: Forgotten and Lost Systems
    9. The Compounding Problem: Crippling Risk Avoidance
    10. Solution: Chaos Testing
    11. Mess: Institutional Failures
    12. The Compounding Problem: No Owners
    13. Solution: Code Yellow
    14. Calling a Code Yellow
    15. Running a Code Yellow
    16. Mess: Leadership Has Lost the Room
    17. The Compounding Problem: Self-Sabotaging Teams
    18. Solution: Murder Boards
    19. 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
    5. Exercise: Critical Factors3
    6. Exercise: The Saboteur4
    7. Exercise: Shared Uncertainties5
    8. Exercise: The 15 Percent6
    9. Exercises Specifically for Decisions
    10. Exercise: Probabilistic Outcome-Based Decision-Making
    11. Exercise: Affinity Mapping
    12. Team Structure, Organization Structure, and Incentives
    13. Individual Incentives
    14. Minor Adjustments as Uncertainty
    15. Organization Size and Communication
    16. Manager Incentives
    17. Designing a Team: Applications of Conway’s Law
    18. Reorgs Are Traumatic
    19. Finding the Right Leadership
    20. Exercise: The Smallest Testable Unit
    21. Structuring the Team to Account for Past Failure
    22. Exercise: In-Group/Out-Group
    23. 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
    3. Example: Adding Continuous Integration/Continuous Deploy
    4. Approach 2: Diagnosis-Policy-Actions
    5. Example: Upgrading a Database
    6. Comparison
    7. Marking Time
    8. Postmortems on Success
    9. Postmortem vs. Retrospective
    10. Running Postmortems
    11. The Tale of Two War Rooms
    12. Working Groups vs. Committees
    13. 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
54.236.245.71