Image created with Midjourney. Image prompt:
Image created with Midjourney. Image prompt: 2d minimal style illustration of An unwavering chess player, steadfastly sticking to their strategic plan despite a few missed opportunities on the board

In the world of software development, it's easy to get caught up in the game of instant results. Code is written, tests are run, and if something goes wrong, panic often ensues. This reactive approach can lead to hasty decisions and a constant shifting of strategies. However, the principle of "non-Resulting," a term that originated from the poker world, offers a different perspective.

Resulting warns against the temptation to change strategy just because a few outcomes didn’t turn out as expected in the short run1. It reminds us that success is not always immediate, and that a few setbacks don't necessarily imply a flawed strategy. Here are three examples of how the principle of non-Resulting can be applied to the creation of digital software products:

  1. Iterative Development Process: Imagine a software development team using an agile methodology. They plan a sprint, estimating tasks and assigning them to team members. At the end of the sprint, they find that some tasks are incomplete. An immediate reaction might be to change the estimation process or even switch to a different development methodology. However, adhering to the principle of Resulting, the team should resist this temptation. It's important to remember that development is an iterative process. Some sprints will be more successful than others, and a few incomplete tasks don't necessarily mean the entire process is flawed.
  2. Product Launch: Consider a company launching a new software product. Despite extensive market research and beta testing, the product does not initially meet the expected user engagement metrics. Instead of immediately changing the product strategy or doubting the viability of the product, the company should be patient. It can take time for users to adopt and engage with a new product. This doesn't mean ignoring the metrics, but rather investigating them in depth and not drawing conclusions from a limited set of data.
  3. Code Refactoring: In another scenario, a development team decides to refactor a section of the codebase to improve its maintainability and efficiency. The initial results show a temporary decrease in productivity as developers adjust to the changes. However, Resulting would advise against reverting the refactor based on these initial results. Instead, the team should stick to their strategy, understanding that the long-term benefits of maintainable and efficient code will outweigh the short-term productivity drop.

In conclusion, the principle of Resulting encourages persistence and a long-term view in software development. It reminds us that the path to successful digital products isn't always linear, and that temporary setbacks are part of the journey. So the next time you face an unexpected outcome, remember: Resist the temptation to change strategy just because of a few short-term results. The long game is where true success lies.