When conditional logic silence the critical signals
Tl; DR: Sapping the state reports in the conditional branches causes silent delays and racing conditions.
Problems 😔
- User delays
- Bad experience
- Unpredictable dead time
- Incomplete initialization
- Hidden dependencies
- Mismanagement
- Silent failures
- Back compatibility breaks
Solutions 😃
- Validate all code paths
- Use default ratio mechanisms
- Testing the edge rigorously
- Refactor policy checks
- Perform
- Move conditional external relationships
Context 💬
When you add conditional logic (for example, group policies) to the initialization code, jumping critical steps such as preparation reports causes system -scale delays.
Board are exceptional conditions that occur outside the normal operating parameters.
When you do not properly manage these cases, your code can behave unpredictably.
This Microsoft blog post highlights a classic example where the missing dash manipulation made that Windows 7 had slower connection times when users chose a united background instead of a wallpaper image.
The code responsible for loading office wallpapers said “ready” only when it has managed to load a wallpaper image.
But when users have selected a united background (a on-board), this code path has never triggered the “ready” notification.
Consequently, the system waited for the complete expiration time of 30 seconds before proceeding with the connection sequence.
This problem shows how small, apparently small on -board case can have a significant impact on the user experience.
This should have been a 5 -second connection process has become a frustrating period of 30 seconds for users who have chosen a simple configuration option.
Multiply this innocent delay of 30 seconds by each user who had the version. What a waste of human time!
A good software design forces you to consider all possible paths through your code, not just the commons.
When you ignore cutting -edge cases, you create a technical debt that manifests itself as mysterious performance problems, waiting times and bad user experiences.
Code example 📖
Bad ❌
public static class WallpaperInitializer
{
private static bool wallpaperWasDefined = false;
public static void InitializeWallpaper()
{
if (wallpaperWasDefined)
// Assume this was defined previously
// and PLEASE DON'T use NULLs in case you hadn't
{
LoadWallpaperBitmap();
Report(WallpaperReady); // Missed if wallpaper is undefined
}
// No default report, causing delays
}
private static void LoadWallpaperBitmap()
{
}
private static void Report(string status)
{
// The Asynchronous loading keeps on
}
}
Right 👉
public static class WallpaperInitializer
{
private static bool wallpaperWasDefined = false;
public static void InitializeWallpaper()
{
if (wallpaperWasDefined)
{
LoadWallpaperBitmap();
}
Report(WallpaperReady);
// Always report, regardless of condition
}
private static void LoadWallpaperBitmap()
{
}
}
Detection 🔍
Use static analysis tools to report conditions that keep critical reports.
Code revisions must verify that all initialization paths are supplemented by the signal.
Level 🔋
Why the bijection is important 🗺️
The real behavior of the system (for example, connection speed) depends on the precise modeling of the preparation states.
Software must maintain individual correspondence between real world states and program states.
When users select a solid color background in Windows, this choice represents a valid real state of the real world.
(My personal choice at the time)
The program must properly model this choice with a corresponding program which behaves correctly.
When you break this bijection by not managing the cases, you introduce disconnections between user expectations and system behavior. In this example, users expected their powerful color background choice to work normally, but instead, they have experienced mysterious delays.
The missing bijection creates a cognitive dissonance: “I made a simple choice, why does my computer behave strangely?” This disconnects the confidence and satisfaction of users a shame.
Each broken bijection introduces a crack in the system of reliability of the system, which makes it more and more unpredictable over time.
The rupture of this link causes offsets between user expectations and the execution of software, leading to unpredictable delays and a mapping to the violations of the real world.
Generation ai 🤖
AI generators can create this smell by naively wrapping the inherited code in conditions of the conditions without validating all paths.
IA 🥃 detection
Inviting the AI to “ensure that the reports of state run in all branches”, and it will indicate or correct this odor by moving the external conditions of ratio ().
Try them! 🛠
Remember: AI assistants make a lot of mistakes
Suggest prompt: finding other missing relationships
Conclusion 🏁
Always report unconditionally completion in the initialization code.
Conditional logic must modify the behavior, and not silence the stages of critical report.
Relations 👩❤️iar
More information 📕
Warning 📘
Code odors are my opinion.
The tests lead to failure and failure leads to understanding.
Burt Rutan
This article is part of the Codemell series.
