Habit: Schema Update 3 — Refactor Databases

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: 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.

« » page 1 / 2