Organization ROI: Eliminate bugs arising from database changes, while allowing you to fix database problems.
Engineer ROI: Make arbitrary design changes to your schema in simple ways that never generate bugs, no matter how many programs use it.
Habit: Schema Update 3 — Refactor Databases
Habit: Bugs Have Causes
Organization ROI: Reduce bugs that arise from team-specific causes.
Engineer ROI: Reduce blame around bugs. Address whatever problems impact your team most, with organizational support.
Habit: Checklist Automation
Organization ROI: Manual processes can be automated, even ones with missing information.
Engineer ROI: Automate everything. Incrementally address inconsistencies. Match your investment to the time savings.
Habit: Always Ship on Time
Organization ROI: Code can be shipped at any time, both on scheduled and at-will releases. Isolate ship date from development risks.
Engineer ROI: Commit every day, no matter what. Always work from a clean slate.
Habit: Whole Values 1 — Fix Primitive Obsession
Organization ROI: Reduce bugs that arise from miscommunciation. Create classes to unwind many common design problems.
Engineer ROI: Create missing classes by following existing code.
Habit: Start Refactoring Safely
Organization ROI: Code changes become cheaper and less bug-prone. Improves intra-team learning.
Engineer ROI: Code reviews are much easier. Gaining permission to refactor is easier. Make fewer mistakes.
Habit: Shell System
Organization ROI: Always remain shippable, reduce risk from partially-done work.
Engineer ROI: Migrate each feature into a working system, so you are done-done with a feature when you finish.
Habit: Names Expose Duplication
Organization ROI: Find opportunities to reduce duplication without introducing coupling bugs.
Engineer ROI: Honest names distinguish intentional from accidental near-duplication.
Habit: Split Services 1 — Ports and Adapters
Organization ROI: Reduce cost of ownership related to both 1st and 3rd party dependencies.
Engineer ROI: Isolate and micro-test interactions between any two components. Get informed when 3rd party components change underneath you in production.
Habit: Healthy Unit Tests 1 — Readable Tests
Organization ROI: Communication between developers and product owners become easier.
Engineer ROI: Instantly know why each test exists and what code to change when requirements change.
Habit: Code is Cheap
Organization ROI: Reduce blocking between developers in the same team.
Engineer ROI: Retype a full day of work in 30 min. If you have a problem or a merge, revert! Do code previews and faster reviews.
Habit: Read Fragmented Code
Organization ROI: Reduce story cost in code that has a large number of independent parts.
Engineer ROI: Gain insights about related code chunks that are scattered across the old system.
Habit: Explicit Dependencies
Organization ROI: Allow migrating features in any order, regardless of how entwined the code is with other features.
Engineer ROI: Dependencies in the old system become obvious so they can be handled differently in the new system.
Habit: Make Methods Simple
Organization ROI: Reuse code more.
Engineer ROI: Separate parts of a method, unwinding their dependencies and testing each part separately.
Habit: Split Services 2 — Complex Adapters
Organization ROI: Reduce cost of ownership for depending on complex or highly-shared services.
Engineer ROI: Adapt services that do what you need but are hard to work with into exactly what you need.
Habit: Naming as a Process
Organization ROI: Reduces cost and bugs for any story that touches existing code.
Engineer ROI: Trust your names. Finish stories faster. Reduce impact of interruptions.
Habit: Whole Values 2 — Collect Behaviors
Organization ROI: Decrease duplicate code and God Classes, reducing testing, implementation, and bug costs.
Engineer ROI: Move code onto whole value classes from procedures that use God Classes.
Habit: Safeguarding 1 — Better Safeguards
Organization ROI: Learn from each issue, preventing similar issues in the future.
Engineer ROI: Reduce overhead cost for process improvement. Spend less time finding and fixing bugs.
Habit: In-Storage Data Adapters
Organization ROI: Support multiple applications with different data expectations off the same data source.
Engineer ROI: Allow shipping data stores updates and application updates asyncronously, and update even if there is a legacy system you can't change.
Habit: Split Services 3 — Testable Services
Organization ROI: Reduce cost of integrating with 1st party services, such as databases.
Engineer ROI: Know when changes to your service would impact others without running full-system tests.
Habit: Whole Values 4 — Use in Procedural Code
Organization ROI: Leverage prior technical investments to improve broad swaths of your code base.
Engineer ROI: Change the code base to use the objects you extracted from the utility class.
Habit: Safeguarding 2 — Better Demos
Organization ROI: Understand which teams are improving how much. Know where to intervene and where to support.
Engineer ROI: Gain organizational support for the work you do to improve all product elements beyond features.
Habit: Healthy Unit Tests 2 — Stop Testing Internals
Organization ROI: Tests tell you where you will pay costs on future stories.
Engineer ROI: Refactoring never requires updating tests.
Habit: Whole Values 3 — Relax Design Stresses
Organization ROI: Reduce implementation costs and bugs that arise from complex methods or God Classes
Engineer ROI: Remove duplication in code that uses God Classes.
Habit: Undo Layers
Organization ROI: Teams code and ship more independently.
Engineer ROI: Reduce the number of different parts of the system you have to update for each story.
Habit: Dual-Home Features
Organization ROI: Continue shipping new features without delaying the legacy rewrite.
Engineer ROI: Write new features once, in ways that work in both old and new systems.
Habit: Ship Easily
Organization ROI: Shorten your process between code complete and general release.
Engineer ROI: Reduce per-release overhead.
Habit: Names Guide Design
Organization ROI: Prevent bugs that arise from differences between CS concepts and domain concepts.
Engineer ROI: Use your honest names to guide design for your system.
Habit: Know When to Stop
Organization ROI: Trust devs to do just the right amount of refactoring in each story. Minimize cost of each story.
Engineer ROI: Be trusted to decide when to refactor. Know when to stop.
Habit: Independent Data
Organization ROI: Reduce unintended reactions with the rest of the system.
Engineer ROI: Each service manages its own data, making it easier to extract.
Habit: Stop Inheriting
Organization ROI: Reduce cost for unexpected features.
Engineer ROI: Code is more re-usable and easier to extend in novel ways.
Habit: Healthy Unit Tests 3 — Test Long Methods
Organization ROI: Begin automatically verifying your most important chunks of code. Reduce the cost of future changes.
Engineer ROI: Test responsibilities independently, even when they are in the same method.
Habit: Schema Updates 1 — Deterministic Migrations
Organization ROI: Prevent bugs that occur due to subtle differences between databases.
Engineer ROI: Update local, test, and production databases easily and consistently, no matter how long a database has been not updated.
Habit: Incremental Isolation
Organization ROI: Extract a service without ever blocking release or anyone else's commits.
Engineer ROI: Break out your service as a part of normal story development, without slowing anything down or scheduling technical stories.
Habit: Separate Commands and Queries
Organization ROI: Improve reusability and complexity by reducing complexity.
Engineer ROI: Code becomes much easier to test.
Habit: Cross-System Sharing
Organization ROI: Reuse the good parts of your existing system even while creating a new system to replace the bad parts.
Engineer ROI: Re-use code between old and new systems.
Habit: Split God Classes 1 — Extract One Purpose
Organization ROI: Prevent bugs due to data sharing between adjacent parts of the code. Improve one technical debt without having to fix it all at once.
Engineer ROI: Reduce God Classes without waiting for full-system analysis.
Habit: Test User Interactions
Organization ROI: Reduce cost of ownership for tests that verify response to user behavior.
Engineer ROI: Test user interfaces and user behaviors without running the UI.
Habit: Test as Design Preview
Organization ROI: Tests indicate design flaws before you write the code.
Engineer ROI: Stop testing around existing designs. Re-invent design ideas without having to know the whole literature. The tests show you what to solve.
Habit: Healthy Unit Tests 4 — Decoupling and Microtesting
Organization ROI: Tests speed up, have fewer false positives, and cover more of the code.
Engineer ROI: Every test passes 100% of the time when the code is right, fails 100% of the time when it is wrong, and executes in <1ms, in parallel with any other tests.
Habit: Split God Classes 2 — Pull Out Concepts
Organization ROI: Detangle one set of use cases from the God Class cost overhead. Reduce bugs arising from multiple pieces of code sharing a God Class.
Engineer ROI: Get one God Class responsibility off the God Class.
Habit: Schema Updates 2 — Range-Versioned Databases and Multi-Phase Migrations
Organization ROI: Upgrade applications independently even if they share the same database. Perform zero-downtime database updates.
Engineer ROI: Easily manage any number of distinct applications using any number of distinct data sources, including data sharing, with zero-downtime, deterministic updates.
Habit: Backwards Compatibility
Organization ROI: Allows shipping new service and monolith independently.
Engineer ROI: Add capabilities to your independent service without having to update the monolith at the same time. Update the monolith only as stories require.
Habit: Feature Flag Migration
Organization ROI: Bugs can be rolled back without disruption to others.
Engineer ROI: Implement structure and functionality changes without impacting others, even if you make a mistake.
Habit: Add Domain Concepts
Organization ROI: Prevent bugs that arise from working around missing concepts.
Engineer ROI: Use your code to find missing concepts, then use those concepts to organize the code in ways that will be easy to extend.
Habit: Communicative Tests 2 — Test as Spec
Organization ROI: Eliminate the disagreements between coders and non-coders for what the system should do.
Engineer ROI: Not using cucumber/fit/fitnesse! Use the native language to agree with your PO/manager, because the code is written so well that you can.
Habit: No More Mocking
Organization ROI: Tests tell you where stories will cause non-local interaction bugs.
Engineer ROI: When the product is broken a test will fail. No longer have 2 parts of the code have different expectations.
Habit: Healthy Unit Tests 5 — No Squeezable Tests
Organization ROI: Each test verifies something important, without locking in details you might want to change later.
Engineer ROI: Start with any high-level test and squeeze it down to its essence.
Habit: Split God Classes 3 — Break Inbound Dependencies
Organization ROI: Prevent bugs due to data sharing between remote parts of the code. Update remote parts of the code separately.
Engineer ROI: Split one set of code that works with the God Class to use something simpler.
Habit: Test Temporal Dependencies
Organization ROI: Prevent timing-related bugs.
Engineer ROI: Know when code will behave differently under delays, timeouts, and parallelism, even when you can't test all cases.
