I'm digging deeper into the concept of software correctness. I understand that correctness means whether a program behaves as specified, with specifications coming from various sources like users or developers. Testing involves checking the actual output against expected results for given inputs, and bugs represent unexpected behaviors that should ideally be caught in tests.
However, I'm curious about behaviors that occur outside the specified use cases. For instance, suppose I create a program to compute Fibonacci numbers with the clear specification that valid input is a nonnegative integer. While my program might inadvertently work for certain positive floats due to a different implementation method, users begin reporting issues when they input those floats.
What should we label these reported issues? I struggle to categorize them as bugs since the specification only addresses nonnegative integers. I've seen terms like 'unspecified behavior' or 'undefined behavior' in the context of compilers, but they focus more on programming languages and not final program functionality. It feels like there must be a specific term for this phenomenon, akin to how medications may have 'off-label' uses. Any ideas?
5 Answers
Honestly, why is your program allowing floats if it's meant strictly for integers? I'd refer to these cases as 'unsupported use.' You basically have three options: adapt the program to accommodate this new input type, restrict it to just nonnegative integers, or leave things as they are and treat the user reports as user errors instead.
In my workplace, we call issues where the software works perfectly per specs but a user isn't happy a "design query." This distinction helps since any fixes needed here may involve billing the customer differently than for traditional bugs.
I'd just say this falls under a 'desire path.' Users often find unique ways to use software that might not align with designers' intentions, but listening to their feedback can spotlight areas where your software could improve.
It sounds like you're describing scenarios that are "beyond the scope" of your software. Users are effectively creating 'feature requests' instead of typical bug reports. Often, it helps to design the API or user interface in a way that guides users towards the intended behavior, or at least clarify in the documentation that certain uses aren't supported.
Any time there's a possibility of a user inputting something that isn't in the spec and it leads to failure, I’d still categorize that as a bug. It indicates a failure to understand potential user interactions. You might spend a lot of time debating semantics, but at the end of the day, clarifying what changes were made and why is what really matters.
Related Questions
How To: Running Codex CLI on Windows with Azure OpenAI
Set Wordpress Featured Image Using Javascript
How To Fix PHP Random Being The Same
Why no WebP Support with Wordpress
Replace Wordpress Cron With Linux Cron
Customize Yoast Canonical URL Programmatically