Something Went Wrong in Software Development
Cite This Article
Siron, E. (2026, October 6). Something Went Wrong in Software Development. Project Runspace, https://projectrunspace.org/something-went-wrong-in-software-development/
Siron. Eric. "Something Went Wrong in Software Development." Project Runspace, 6 Oct. 2026, https://projectrunspace.org/something-went-wrong-in-software-development/. Accessed unknown.
Siron. Eric. "Something Went Wrong in Software Development." Project Runspace. October 6, 2026. https://projectrunspace.org/something-went-wrong-in-software-development/.
Siron, E. (2026), 'Something Went Wrong in Software Development', Project Runspace, 6 October, https://projectrunspace.org/something-went-wrong-in-software-development/ (Accessed: unknown).
How often does a “Something Went Wrong” message bring your work to a frustrating halt? Software has not always behaved that way. It never should have started to behave that way. Let’s talk about how things got here, how it hurts us, and how it could get better.
The Way it Was
I learned the basics of programming by reading others’ code. I advanced by reading books and articles on languages that interested me. I remember early material clearly warning me that its code was not suitable for production. The explanation: professional code should employ rigorous error handling.
Don’t allow me to pretend that period was some sort of panacea for software development. If you go back far enough, most users of software were also developers. Code behavior, including error messaging, was often written for people that knew how computers worked. The user ratio tilted heavily toward non-developers long before typical error messaging became comprehensible to the less technically knowledgeable. Software was difficult to use and difficult to understand whether it succeeded or failed back then, too, but for different reasons.
The Emergence of “User Friendliness”
In those early times, commercial computers carried such a heavy price tag that making them easy to use was not a high priority. Accounting divisions tended to be the most common customers, and a line item for thousands of dollars worth of training on an invoice for a multi-million dollar computing solution was not outrageous. Of course, prices fell relatively quickly, bringing computing systems into reach of individual consumers. They would not tolerate that kind of training cost and time. Selling more software licenses necessarily meant broadening the appeal of software.
The story could sprawl out into multiple volumes at this point. For our purposes, I will skip to the part where developers started thinking about the “user experience”. Sometimes it was little more than a gathering of factoids dropped by advocates for improvement. At the other end, companies hired cognitive psychologists to help design layouts, workflows, and functionality. I don’t know of any measurements taken on the effectiveness of all that. The point I want to get across: developers have thought about how to make software easier to use and understand for a long time, and they found lots of ways to achieve it.
What I Picked Up Along the Way
During all that time, my programming improved. I didn’t pick up a lot on the details of user experience, if for no other reason than because I never wrote anything intended for general user consumption. However, starting from those warnings about what made code “professional”, my programs began to have more code for preventing and handling problems than for implementation. Even today, many of my “simple” scripts have a dozen or more lines of input sanitization and error reporting surrounding one or two lines of procedure.
Outside my work, I thought that professional software was showing what developers learned from previous iterations. It became normal for programs to perform thorough input validation. They would have more guardrails to keep users heading toward success. If software needed to alert a user, it did do so in a useful way. Of course, none of that ever applied universally. However, it did seem as though the industry was trending in a direction of making software fit to its intended audience. And then… things changed again.
Something Went Wrong
In the pattern of so many other good things, “user friendliness” went so far that it stopped fitting the description. It all began quietly enough that I didn’t notice exactly when it started. Eventually, all the effort that had gone into making software messages more comprehensible for non-technical users devolved into saying nothing. At the start of the journey, programs would show arcane, cryptic output that left the user confused. Now, software presents vapid, inane platitudes that leave users confused.
The biggest problem with meaningless error messages like, “Something Went Wrong”, is that they leave the user with no direction. Imagine that you walked into a business to conduct a transaction with a live person providing a service. At some point during the interaction, that person just stops, shrugs, and tells you that it isn’t working. When you try to do any rational thing such as ask what happened or what to do next, the person doesn’t respond or react. The pointless error messages that modern software assaults us with are the digital equivalent of that hypothetical worker.
The Cost of Empty Errors
Hopefully, the mental exercise in the previous section clarified the problem with error “messages” that don’t say anything. When one pops up, it gives you no clue as to what you should do next. You don’t even know if the problem was caused by something that you did or a failure beyond your control. Whatever goal you intended for the software, it failed to achieve it. Furthermore, its refusal to give useful information pushed the burden of solving the problem onto you.
Error messages of any quality cost the user time. Vapid messages demand even more. First, they shrug off all responsibility, leaving the user to embark on a quest to deal with the problem. The user loses time trying to choose a good place to start. Should they retrace their steps through the program to see if they did something wrong? Maybe they could look for an alternative way to achieve their goal. Perhaps they should they to contact someone for help. No matter what they choose, they lose time doing it. If their first choice does not work, then they need to move on to another. All that adds up.
Treating users this way also imposes costs on the software provider. No customer walks away from a frustrating encounter with more goodwill for the company behind it. You can certainly imagine multiple ways that risks revenue. For me, if I am trying to buy something online and I get one of these ridiculous errors, I find another place to buy what I was looking for or skip the purchase altogether. Many users contact support staff, which consumes everyone’s time and resources, including customers waiting in the queue.
Addressing the Excuses
After enduring one too many of these nonsense messages while trying to meet a deadline, I took to LinkedIn to voice my frustration. I suggested that every time a user calls a help line over a tiresome “something went wrong” message, the developer that wrote it, every developer that approved it in peer review, and every manager that signed off on the code should handle all support calls related to that message until they replace it with useful messaging. I was immediately beset by programmers that apparently felt that I was calling them out personally. None of that went well. But, they did give me their “reasons” so that I can explain why they’re no good.
Security Does Not Justify Pointless Error Messages
Like many bad things, using “security” as a reason for this probably came from a good beginning. In the past, it was not uncommon for login forms to report “incorrect password”. While helpful, such a message also gives away valuable information for an attacker: the username is probably correct. For a username/password combination, that means the attacker has half of the credential. However, the correct security improvement was to report something like, “invalid credentials”. That tells a valid user that their data entry was incorrect without giving an attacker any hints. “Something went wrong” does not do that.
Developers need to take care to not leak information. No one denies that. But, that does not excuse developers from their responsibility to shape a positive experience for users. Telling a user that “something went wrong” when the software has enough data to report a condition such as invalid input does nothing to impede an attacker, but it does withhold information that could save the user’s time. Malicious actors hurt users by exploiting software vulnerabilities. Lazy developers hiding behind the excuse of “security” hurt users by exploiting their concerns about software vulnerabilities.
If a programmer cannot find a helpful way to report a problem without leaking information, then that programmer does not understand the application domain well enough to write the software securely, either.
An Error Message Can Say Something Without Saying Nothing
The non-security retorts that I received to my post asked if I expected a stack dump or a stack trace. If you don’t know these terms, they show in-depth data about the state of the machine from the software’s point of view when the problem occurred. To a normal user, either would look like gibberish. Typical systems administrators would have trouble knowing what to do with the information. Even developers might not be able to do anything with it, unless they knew the underlying code.
Stack traces and dumps have value in debugging, but not for much else. A dump shows things such as values stored in variables. A trace walks backward through the series of function calls that led to the error, often showing a message returned by the system or a library. Neither the system nor a library would know what the developer was trying to do in the failing function, so these messages usually mean nothing to anyone except the person that wrote that code. Fortunately, users don’t need debug information when a program doesn’t work as expected. They need to know what to do about it.
If a programmer cannot find any suitable middle ground between regurgitating a stack trace/dump and “something went wrong”, then that programmer does not understand the application domain to write software for it.
Exposing the Hidden Code
Even with open source and easily reverse-engineered software, most users never look at the code. Even if they do, most of them won’t understand it enough to distinguish good code from bad code. More than a few developers take advantage of that. So, let me show you how this happens in an easily digestible way.
Consider a simple routine that saves a file to disk. Many software libraries contain a simple routine for developers to call that handle the detail work of that operation. For the purposes of this section, I will use a fake computer language that reads a lot like English as pseudo-code. The core of a function like I describe would look something like this:
|
|
Of course, such a function call could go wrong many ways. I would write something like this:
|
|
I don’t care for the last of those error messages, but you can’t always anticipate every way that something might fail. For example, something might have corrupted kernel memory. This program could neither prepare for nor deal with that. So, unfortunately, we can’t avoid some amount of useless error messages. However, notice that this message comes after several other problems, each much more likely than corrupted kernel space.
Let’s expand on this example to give a better idea of what developers deal with.
|
|
That “code” only does three things: asks for a file name, asks for a folder name, and saves the file. Look at all that code! And it isn’t a real language! The fake language that I used doesn’t indicate how it would behave after reporting a problem to the user. Does it end the program completely? Does it go back to an earlier point? All that would require more code. Let’s look at something more realistic for just the file save part:
|
|
All that, just for the single act of writing the file to disk. I can think of more exceptions that such a function should handle gracefully. To execute this operation properly in production-grade code, every likely failure point needs this sort of structure. You can imagine how that makes my simple three step example balloon into dozens of lines of code. You can imagine why a programmer might not want to do all that. However, professional software demands it. Unfortunately, some developers choose to do this instead:
|
|
That code is easy to write and easy to read. When the programmer runs it in a debug session, the stack trace and dump information clearly show any problem. However, when the user executes the code, they enjoy no such benefits. Any one of the four lines can encounter a problem. Each of them calls other functions that all have their own myriad ways to fail. No matter what breaks or where, all of them end in the same message. Software companies that release code like this have abdicated their responsibility to make things easier for users in favor of making things easier for the people that should not need it.
Place Blame Cautiously
I was somewhat careful about who I said should take responsibility for this kind of nonsense when I wrote my LinkedIn comment. I want to express myself even more clearly here: we cannot blame every instance on programmers. Yes, many developers are lazy. Many others assume that users are too stupid to understand anything, so there is no value in telling them anything. Such programmers deserve all the derision that we can throw at them. However, many software companies place unreasonable demands on employees. Many managers do the same. Often, programmers submit embarrassingly poor code to meet unrealistic deadlines or arbitrary quantity requirements.
So, we can safely blame the organizations that release this kind of code. If a developer did it, then the company should have made better hiring or managing decisions. If a manager caused a developer to do it, the same conditions apply. If the overall company pushes this, then the company still owns the guilt. As the users of their software, we have no reason to concern ourselves with those companies’ internal problems. It does not matter to us who within the organization needs to make it right. We only care that these companies start delivering professionally written code.
Good News for Developers
We have known about the problems of such code sprawl for a long time. Many practices and idioms exist to reduce it without compromising usability. Developers need to educate themselves on these things and their employees need to enable that learning and enforce it in implementations.
Even better, in this new world of ubiquitous artificial intelligence aids, the computer can do a lot of this for us. I want to make a snarky comment about certain companies that constantly promote AI but fail to use it for producing useful messages, but I will refrain. The point is, the tools can now deal with this kind of thing quickly and easily. Writing thorough error handling was never difficult, only tedious. AI handles simple, boring tasks much better than humans.
What We Should Do
As consumers of software, we should start to push back what this ridiculousness costs to the companies that inflict it. Next time you get one of those obnoxious surveys, tell them that you want to answer, but “something went wrong”. Use that as your reason every time you decide not to do business with a company. Complain about it to your account managers. Companies won’t do better until we force them. Something went wrong with them, not with us. We do not need to accept it.