Subject: [boost] A demonstration of why horrendous error messages can destroy usability
From: Gregory Crosswhite (gcrosswhite_at_[hidden])
Date: 2011-12-11 08:29:05
At the unfortunate risk of reopening a poisonous argument, I just wanted to relate an experience I had just earlier today to emphasize a point that I and others tried to make a couple of weeks ago.
For the last couple of days I have been trying to get Digikam to compile on my machine using MacPorts. Getting software written for Linux to compile on OSX is always a bit of a black art, so I wasn't surprised when I started running into hurdles. The first problem that I ran into was that I had set Python 3.1 to be my default rather than Python 2.7, which screwed up the libplist CMake configuration script; fortunately, although I had to scratch my head for a few minutes, it was clear roughly where the error was taking place and that gave me enough information to eventually figure out where the problem was. I also went ahead and filed a bug report to MacPorts to let them know about this problem.
After that it was smooth sailing until I got to the final package, Digikam itself. Unfortunately, it refuses to build. Why is that? For reasons that apparently took an overwhelming *56 kilobytes of error message* to explain. (See attached, if you dare. )
Now, you could argue that this is the fault of the compiler for not being more helpful, the fault of Digikam for using deprecated methods, the fault of MacPorts for creating a bad environment for configuration, or whatever else you want. You could also argue that were I familiar with Boost and/or the Digikam codebase then the implication of this message would be obvious --- heck, maybe it even *is* obvious to many of the people here.
All of this is beside the point, though. I am not an expert in any of these codebases and I really don't care whether it is ultimately the fault of Boost, Digikam, Qt, MacPorts, or the compiler for producing such horrendous error messages. All that matters to me is that these pages of error messages are so overwhelming that they make it very difficult for me to get any sense at all of what kind of thing is going wrong so that I can track down what needs to be done to fix it. Furthermore, the error message is such a mess that it is hard for me to even *motivate* myself to *want* to go through it to figure out where is going on, and seeing the impact that this kind of thing can have on end users really turns me off a bit from the idea of continuing to use Boost libraries in my projects in the future. That is to say, I had heard people in the past say that they actively avoid Boost (and sometimes even C++) because of the way they introduced nasty complexities (like horrible error messages), and I used to (politely :-) ) scoff at them because I figured that they were overstating the problems in practice. Now however, having experienced these problems from the viewpoint of a casual user who just wants to get some darn code to compile so that I can run a program I wanted to try out, I can really appreciate their point.
To be perfectly clear, I am not saying that this has made me never want to use Boost again, for I really hate rolling out my own code to solve a problem when somebody else has already developed and tested a solution for me. :-)
My point is exactly and *only* the following: horrendous error messages are a *big deal* with a *serious impact* on usability not only for the developers using a library, but for end-users who want to compiler and use the software being developed. Most people here fortunately already seem to recognize this, but I have been truly shocked to hear so many arguments that horrendous error messages are *not* a serious problem, either because they are someone else's fault, because they only occur when the code is wrong, or --- worst of all --- because it is ultimately the fault of the user for being ignorant or lazy when he or she cannot quickly figure out what the problem causing the message was. So I just wanted to share this anecdote to provide a real-world example where horrendous error messages have added an incredible cost for a relatively technically experienced end-user to actually use a particular piece of software.
And once more, I am sorry to bring this tired point up again, it's just that the experience I had today really reminded me just how frustrating these kinds of error messages can be, and the absurdity of denying that this is in any way a problem. I feel very strongly that the ultimate goal of writing software is not merely to push the boundaries of what we can do but to provide people with tools that make their lives easier. Horrendous error messages, even when there is no better design to accomplish a particular task (in C++, at least), are *really bad things* and should *not* be dismissed as something not worth fussing about, *especially* when fault is then placed on the *user* (as in some cases it sadly seemed to be) for being too ignorant or lazy to be willing to go to the trouble to decipher them.
I am not claiming to know what the solution is to these kinds of issues, and in many cases there might not even be better solutions given the current design of C++. I was just very concerned to see that in the eyes of many the presence of such error messages are not considered in any way to be a problem (*) with a library, and to hear it claims that if anything users turned off by horrendous messages are simply being lazy by not just sucking them up for the good of the cause.
(*) And let me be clear that by "problem" here I really do mean "less than ideal circumstance" rather than "flaw", because in many cases these libraries are very elegantly designed codes which are probably close to the optimal solution given the limits imposed by the C++ language.
Boost list run by bdawes at acm.org, david.abrahams at rcn.com, gregod at cs.rpi.edu, cpdaniel at pacbell.net, john at johnmaddock.co.uk