Preventing Customer Frustrations ⚠️😤
Tags: softwareengineering, releaseearlyreleaseoften, rero, customers
Published: 2022-12-30 13:40:31

Hey developers!

There is a constant battle between "Release early, release often" (RERO) and "If it ain't broke, don't fix it" approaches in the dev world.

The question arises whether continuous improvement is always a good thing.

On the other hand, there is an unwritten rule saying "Never fix anything unless it's a problem, and you have evidence showing that the problem really exists."

Let's briefly discuss this!

<h3>World of constant changes</h3>
In today's world of constant change, we must learn to be <a target="_blank" href="https://helloacm.com/planning-cards-agile-poker-game/" rel="noopener">agile</a>. Cyberattackers are constantly looking for vulnerabilities, software providers are constantly releasing bug fixes and new features, and customer competition is fierce.

When nothing changes, the risk increases.

Keeping things the same entails taking on additional risks when systems become obsolete.

However, <a href="https://helloacm.com/agile-development-release-review-checklist/" rel="noopener" target="_blank">agility</a> has its own set of risks. Upgrades are rarely smooth, new versions frequently introduce new flaws, and unstable infrastructure can result in negative press and occasionally even expensive fines.

Today we have multiple layers of complicated software bandages to keep systems compatible with dated procedures and machinery for the sake of stability. However, such alleged stability may only be apparent.

It will eventually fail or cause a disaster.

<h4>Change aversion</h4>
People are mostly change-averse. But what's interesting is that most of them also protest against <a href="https://codingforspeed.com/do-you-need-objectives-and-key-results-okr-or-is-it-just-a-current-fancy/" title="Do you need Objectives and Key Results (OKR), or is it just a current fancy?">bugs</a>, outdated software versions and the like. It's a paradox that shows that people are unaware that the software can not survive without periodic upgrades.

Several conflicting opinions are highlighted below:
<ul>
<li>"If you had to purchase a new refrigerator every 18 months, especially if it doesn't offer you anything new, you would be furious. It's just like that."</li>
<li>"I think the idea of "if it ain't broke, don't fix it" is roughly ridiculous. Even if you don't have any bugs, the environment around you changes so fast that you sooner or later will."</li>
<li>"As a developer using libraries and components, I really hate "release early and often". As a user, I also hate "release early and often"."</li>
</ul>

Opinions are obviously divided, and of course, some advocate change.

Regarding that, you should pay attention to the fact that, whether we like it or not, changes are an integral part of modern life!

"Never "fix" anything unless it's a problem, and you have evidence showing that the problem really exists" is simply out of date!

<h4>"Release early, release often" pros</h4>
The wisdom behind the RERO strategy is that it allows you to include actual user input into your development. It promotes user-centred design.

RERO strategy benefits listed below are undeniable:
<ul>
<li>Rapid feedback loops boost developer output - developers are better equipped to tailor upcoming work to user needs when they receive feedback on each change or a smaller collection of changes.</li>
<li>Shorter cycle for feature and patch releases - releases are more closely related to requests or needs when features and patches are developed and made available fast. Additionally, frequent releases can contribute to the short lifespan of bugs.</li>
<li>Steer clear of heavier releases - longer gaps between releases increase the pressure to deliver substantial releases with numerous significant features.</li>
<li>Enhances the user experience - users are more likely to purchase active products that are constantly and consistently getting better.</li>
</ul>

Better software development flexibility, happy clients, and satisfied developers result from the “Release early, release often” strategy.

<h4>How to prevent failure?</h4>
Up until the point where you have to upgrade, and chaos ensues…

You've been dealing with problems for years. And you'll need to embark on a large project to make the update happen. The argument that you shouldn't update because it isn't broken may appear reasonable.

It was becoming increasingly broken while you were doing nothing; you were simply unaware of it.

Therefore, you should update everything frequently on all projects you control.

If something doesn't work, you want to know as soon as possible and take action rather than wait years to find out something doesn't work.

The incremental effort required for this is minimal if you remain on top of updates like that, and things will generally work.

Make "improvement" a crucial component of daily operations to embrace it. Subject prospective enhancements to automated tests using realistic synthetic workloads as they move through integration stages.

Bugs should be fixed when updates are ready for production because they have undergone a rigorous <a href="https://codingforspeed.com/is-there-such-thing-as-high-quality-code/" title="Is There Such Thing as High-Quality Code?">testing</a> process.

Putting this perspective into practice, issues on both the "release early and often" and "don't fix it if it ain't broke" strategies are resolved.

You can always improve, even if "it ain't broke." Your clients will appreciate it. 

Using standardized development environments is a great way to avoid surprises in production.

Furthermore, a standardized development environment allows you and your colleagues to jump in quickly and make the necessary updates.

Reposted to [Blog](https://codingforspeed.com/preventing-customer-frustrations/)