Warning
Sometimes the only way to get a development tool installed is to compile it from source. In fact, many Open Source projects will assume this is how you intend to install. Some nice people out there might actually compile it for you and make the binaries available, but unless you have 100% trust in whoever is supplying these, compiling from source might be the best route. Perl, my Swiss Army Knife of choice, has many contributors offering modules that go through an elaborate compile/configure/test routine. Such installation processes can take a few minutes to complete, which is often a good excuse to go get a coffee.
The build scripts accompanying such from-source resources often include liberal dollops of commentary that appears briefly on screen before scrolling out of view. Since these are from tried-and-tested supplies, we expect such messages to be generally reassuring. After all, if there were problems then surely this material would not have been recommended for me to use.
During development it would be normal for the developer to be verbose in the commentary. Error messages in particular, especially as such a message may be the only one you will see before the whole build grinds to a halt, and so you’ll probably need a lot of precise information to help solve the problem that caused the error.
Warnings, on the other hand, don’t slam on the brakes. They just let you plough on through, hopefully leaving the developer with a hint regarding some possible problem that just might need to be examined before letting this material loose on an unsuspecting world. Of course, tests that are performed later in the build might confirm that the earlier warning was not really a problem after all. Good. One warning that can be ignored.
Usually what happens is the developer lets the warning continue, knowing that it’s not really a problem. A warning about loss of accuracy when assigning a floating point number to data type with less decimal places is not a problem when the developer knows that the data in question is only accurate to one decimal place anyway. A warning about an API call being an unofficial internal method is not a bother to a developer who is in fact an insider responsible for the API. Yes, the parameter’s documentation is missing, but it’s already explained in detail in the preamble. Sure that method is deprecated but there are solid reasons for using it in this case. Possible fall-through to default case? But of course, I intended it that way!
And on it goes. Warning after warning. Each being left in place with not even a cursory attempt to mollify the compiler. In most cases there are simple actions that can be taken, such as a small code adjustment or (at worst) inserting of a directive to tell the compiler not to complain about it. (Such adjustments should always be accompanied by developer comments to justify them.)
During development, a newly generated warning could get lost in a sea of existing warnings and thus lead to a later bug that could easily have been avoided.
Finally, the material lands in my lap. Or more correctly, cloned to my system from the master repository. To install it, I must run the build. The developers have already done their tests and the results show that all those warnings are not a problem. When building on my system, if there are problems specific to my context that warrants a warning, then I want to see if. Being told that a certain font is missing from my computer and may lead to garbled messages is the kind of warning that should attract my attention, though if the message is in Japanese then the font is the least of my problems. Sadly, instead of only seeing warnings that might be of use to me, as the user, I invariably get hundreds, perhaps thousands, of warnings that only make sense to the developer.
Why am I mentioning this now? Today I cloned and built Netbeans 10 from source. It’s a massive project with 100s of contributing developers. The build process took nearly an hour. I compiled it from within N8.2. The build log contains over 22,000 warnings (based on a quick grep and count). I tried skimming the log to see if any of these warnings might need my attention. Checking over 22,000? No chance. I gave up.
Warning: number of warnings has exceeded user tolerance.
Categorised as: Coding