Debugging Error Quotes

We've searched our database for all the quotes and captions related to Debugging Error. Here they are! All 9 of them:

[M]any men have more skill in avoiding errors than in correcting them.
Niccolò Machiavelli (The Prince)
In debugging, errors are seen not as false but as fixable. This is a state of mind that makes it easy to learn from .6 Multiple passes also brought a new feel for the complexity of design decisions.
Sherry Turkle (Simulation and Its Discontents)
Systems Test No parts of the schedule are so thoroughly affected by sequential constraints as component debugging and system test. Furthermore, the time required depends on the number and subtlety of the errors encountered. Theoretically this number should be zero. Because of optimism, we usually expect the number of bugs to be smaller than it turns out to be. Therefore testing is usually the most mis-scheduled part of programming. For some years I have been successfully using the following rule of thumb for scheduling a software task: l /3 planning l/6 coding l/4 component test and early system test l/4 system test, all components in hand.
Anonymous
Use manual sanity checks in data pipelines. When optimizing data processing systems, it’s easy to stay in the “binary mindset” mode, using tight pipelines, efficient binary data formats, and compressed I/O. As the data passes through the system unseen, unchecked (except for perhaps its type), it remains invisible until something outright blows up. Then debugging commences. I advocate sprinkling a few simple log messages throughout the code, showing what the data looks like at various internal points of processing, as good practice — nothing fancy, just an analogy to the Unix head command, picking and visualizing a few data points. Not only does this help during the aforementioned debugging, but seeing the data in a human-readable format leads to “aha!” moments surprisingly often, even when all seems to be going well. Strange tokenization! They promised input would always be encoded in latin1! How did a document in this language get in there? Image files leaked into a pipeline that expects and parses text files! These are often insights that go way beyond those offered by automatic type checking or a fixed unit test, hinting at issues beyond component boundaries. Real-world data is messy. Catch early even things that wouldn’t necessarily lead to exceptions or glaring errors. Err on the side of too much verbosity.
Micha Gorelick (High Performance Python: Practical Performant Programming for Humans)
I often said I wouldn't have pursued programming as a career if I still did drugs. This is probably true, since weed was always immensely crippling for me. I would have weed hangovers for days, and while stoned, was unable to read or do much of anything besides clean and play video games. Whether or not this would have turned out to be true is academic, but it's definitely true that I wouldn't have become a programmer if I hadn't lost my mind, because the recovery process taught me my most valuable skill as a programmer: how to not think. Programming requires the acceptance that you are entering meaningless symbols into a machine that's going to spit out other meaningless symbols, and this can be hard to accept. It requires abandoning all hope for an answer for the existential "why?" in favour of shuffling boolean values ad infinitum. By no interpretation of the concept of understanding does a computer understand what you're telling it or what it's telling you. On top of that, programming as an act is more often hindered than helped by thinking. Despite zero years of training in computer science, I've found I have an edge in debugging because I never look or ask for an explanation. Ninety percent of the computer bugs in a program are tiny, one-line errors, and you just have to find that error. Holding the entire logical structure of a million lines of code in your mind in futile. The task is to find the references and connections and track them back until you hit the problem. If I get an error message, I copy it into Google, because someone somewhere has encountered and solved the problem, probably by tracking down the people who originally wrote the program. In seven years of programming, I've solved exactly two undocumented bugs via pure deductive reasoning.
Peter Welch
I do not believe we will find the magic here. Program verification is a very powerful concept, and it will be very important for such things as secure operating system kernels. The technology does not promise, however, to save labor. Verifications are so much work that only a few substantial programs have ever been verified. Program verification does not mean error-proof programs. There is no magic here, either. Mathematical proofs also can be faulty. So whereas verification might reduce the program-testing load, it cannot eliminate it. More seriously, even perfect program verification can only establish that a program meets its specification. The hardest part of the software task is arriving at a complete and consistent specification, and much of the essence of building a program is in fact the debugging of the specification.
Frederick P. Brooks Jr. (The Mythical Man-Month: Essays on Software Engineering)
Here are the benefits you can expect from using this style of pseudocode: Pseudocode makes reviews easier. You can review detailed designs without examining source code. Pseudocode makes low-level design reviews easier and reduces the need to review the code itself. Pseudocode supports the idea of iterative refinement. You start with a high-level design, refine the design to pseudocode, and then refine the pseudocode to source code. This successive refinement in small steps allows you to check your design as you drive it to lower levels of detail. The result is that you catch high-level errors at the highest level, mid-level errors at the middle level, and low-level errors at the lowest level—before any of them becomes a problem or contaminates work at more detailed levels. Pseudocode makes changes easier. A few lines of pseudocode are easier to change than a page of code. Would you rather change a line on a blueprint or rip out a wall and nail in the two-by-fours somewhere else? The effects aren't as physically dramatic in software, but the principle of changing the product when it's most malleable is the same. One of the keys to the success of a project is to catch errors at the "least-value stage," the stage at which the least effort has been invested. Much less has been invested at the pseudocode stage than after full coding, testing, and debugging, so it makes economic sense to catch the errors early.
Steve McConnell (Code Complete)
Call an error-processing routine/object. Another approach is to centralize error handling in a global error-handling routine or error-handling object. The advantage of this approach is that error-processing responsibility can be centralized, which can make debugging easier. The tradeoff is that the whole program will know about this central capability and will be coupled to it. If you ever want to reuse any of the code from the system in another system, you'll have to drag the error-handling machinery along with the code you reuse.
Steve McConnell (Code Complete)
Rushing to optimize before the bottlenecks are known may be the only error to have ruined more designs than feature creep. From tortured code to incomprehensible data layouts, the results of obsessing about speed or memory or disk usage at the expense of transparency and simplicity are everywhere. They spawn innumerable bugs and cost millions of man-hours—often, just to get marginal gains in the use of some resource much less expensive than debugging time. Disturbingly often, premature local optimization actually hinders global optimization (and hence reduces overall performance). A prematurely optimized portion of a design frequently interferes with changes that would have much higher payoffs across the whole design, so you end up with both inferior performance and excessively complex code.
Eric S. Raymond (Art of UNIX Programming, The (Addison-Wesley Professional Computing Series))