#software errors

My most important guiding principle for errors produced by code: look at what you know, and only put into the error everything the caller can't already know from how they called your code.

For example, you have a function which takes one file name, opens it, and does something with it. If the file-opening function gave you an error, then I would say the error from your function should look something like this:

opening file: <error>

Notice that

the file name is missing, because the caller knows the file name they passed into the call of your function that gave them this error,

but if your function took multiple file names, then you should include the file name, so the caller can tell which file caused the error,

the error from the underlying open call is included, because if you swallow that, then the caller can't know what happened, and

$ cdexec foo

but `foo` doesn't exist. What should the error message be?

cdexec: error changing directory: foo: No such file or directory

cdexec: error changing directory: foo: ENOENT: No such file or directory

cdexec: error changing directory: foo: ENOENT

More abstractly, which way is best for reporting errors from the system?

...: <perror output>

...: <errno name>: <perror output>

...: <errno name>

Personally, I prefer the last one, because:

Including the errno name is very important for one of the biggest users of command-line tools: other programs such as scripts. ENOENT is the standard, international name for the error. The error is ENOENT. The output from perror is a localized human-friendly hint.

Ditto for human users who have grown familiar with the underlying system enough - I've seen developers complain about having to try to figure out what error code a `perror` string maps back to. I have a good enough memory that this doesn't trouble me most of the time, but I still waste a memorized lookup table on it.

The human-friendly error string is misleading in the edge-cases. See, when I see "no such file or directory", I know that there might not be any file or directory involved at all. Did you? For example, some APIs in the Linux network stack report ENOENT for things that aren't in the file system - because of course to a kernel developer living in a world which has missed the value of exposing all things on the "file" system, it makes sense that ENOENT means "no such entity" rather than specifically "no such file or directory". So you run an `ip route ...` command and get your time and energy wasted trying to figure out what file could possibly be missing.

To be clear, this is orthogonal to "should my source code just call `perror` or should I consider adding something like `errnoname`?" Because your libc could easily be made to extend or change the perror output to include errno names, based on either a compile-time flag or for example by setting some environment variable. You could also compile with `perror` renamed or relinked to something else. So we could in principle achieve any of these alternatives while still just calling `perror` in your source.

This is also orthogonal to "but for many users (at least in the vast majority of cases), the human-readable error message is helpful". Just because something is good to have, doesn't mean every single program should contain the code to do it. Turning an error into human-friendly guidance sure looks to me like a composable piece of functionality that can be implemented separately and then composed on top of all programs. I'd rather have a shell that can automatically pipe the standard error of my programs through a helper tool which can detect names like `ENOENT` and do whatever helpfulness the user wants and the usecase demands. Meanwhile, the error strings which perror produces don't even do a great job of being human-friendly guidance - new users, and even just busy non-experts in a hurry, benefit from detailed hints, typo-checking, alternative suggestions, and so on.

So when I think about the external error string as an API first, the `errno` name seems essential, and then the `perror` output seems superfluous and worse for parsing.

But I do recognize that the perror output can always be stripped off - if you know the format enough to unambiguously isolate the perror noise from the rest of the error, then yes it's annoying, but it's very surmountable.

I also recognize that in the world we live in right now, users aren't going to run my programs in a shell that automatically translates their errors into something more helpful in a user-configurable way. That doesn't exist yet, I haven't written it yet nor spread the vision, and when we do write it, adoption will lag behind a lot. So when a new user runs a program directly, sees `ENOENT`, and has no idea what it means, it doesn't do them much good for me to say "well this wouldn't be a problem if the rest of your system was set up how I envision". At best I can hope that the error code, combined with my carefully chosen prefixes like "error changing directory", do a good job of getting them to the right answer through Google.

A living list as I figure it out. An ideal error in a programming language:

tells you what the problem was,

tells you what you can't already know,

names and lets you easily get any separate piece of information about the error,

lets you add separate pieces of information that your caller can't already know,

does not let you accidentally miss it,

does let you decide how to handle it - suppress it, modify it, or just propagate it,

does not let you do anything your caller has good reason to not give you privileges for,

can be replaced or wrapped with an error that says what the bigger picture problem was,

can be composed into a list of errors, to indicate that there were multiple errors,

keeps error code paths as free as possible of operations and allocations that can fail, and

is compatible with code paths for handling similar errors, but at the same time

If your errors are returned or thrown, then "your caller" is either your actual immediate caller, or at least the caller of the nearest public interface on the way to you in the call tree. Basically, in those cases, "your caller" is either your own code, or someone who directly invoked your code.

But if for example you're down deep in the call tree and you just spew something onto `stderr` and exit the whole process, then "your caller" is now the whole program's caller.

OPERATIONS SUPPORT SYSTEMS, IMPLICATION OF SOFTWARE ERRORS IN GSM NETWORK PERFORMANCE

OPERATIONS SUPPORT SYSTEMS, IMPLICATION OF SOFTWARE ERRORS IN GSM NETWORK PERFORMANCE

Abstract:

One of the most important requirements to be addressed by a general purpose Fault Management (FM) system is the ability to quickly identify the root cause of network errors and fix them as soon as possible. This informs the maintenance of an accurate model of the mobile network error logs for the FM…

- Software Troubleshooting and Errors Resolution 🗔 | Scrapers〘N〙Bots

Antivirus Prevents Downloading and/or Running and/or Deletes File Download (how to whitelist software).

I Double Click the Software exe but Nothing Happens.

Most Common Software Issues and Fixing them Quickly and Easily

This page covers the most common errors or issues you may encounter with our software. Most of them are related to anti-virus and anti-malware programs false flagging our software as malicious. This occurs because of two main reasons:

Our software is no install software. In other words, most software programs have an installer that installs the needed files on different parts of the computer such as in the registry and program files. Our software does not require this. We purposely coded the software this way to keep things neat and clean and file sizes small. Since viruses and trojans are the same way, this can raise a red flag with some security programs.

Our software is highly compressed (up to 70%) to reduce download time and hard drive disk usage. This makes it hard for anti-virus programs to read and scan the software. This alone can raise a red flag.

Many of our software programs make alterations to certain websites and send keystrokes. This is another red flag for anti-virus programs.