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.
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.
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.
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.
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.
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.
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.
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.
Organization ROI: Find opportunities to reduce duplication without introducing coupling bugs.
Engineer ROI: Honest names distinguish intentional from accidental near-duplication.
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.
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.
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.
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.
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.
Organization ROI: Reuse code more.
Engineer ROI: Separate parts of a method, unwinding their dependencies and testing each part separately.
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.
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.
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.
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.
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.
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.
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.
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.
Organization ROI: Tests tell you where you will pay costs on future stories.
Engineer ROI: Refactoring never requires updating tests.
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.
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.
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.
Organization ROI: Shorten your process between code complete and general release.
Engineer ROI: Reduce per-release overhead.
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.
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.
Organization ROI: Reduce unintended reactions with the rest of the system.
Engineer ROI: Each service manages its own data, making it easier to extract.
Organization ROI: Reduce cost for unexpected features.
Engineer ROI: Code is more re-usable and easier to extend in novel ways.
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.
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.
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.
Organization ROI: Improve reusability and complexity by reducing complexity.
Engineer ROI: Code becomes much easier to test.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.