While there is a lot of sloppy programmers out there, these are not the only ones that have trouble finishing something. Some programmers strive for perfection in the software they create, and in the process end up spending precious time.

Anything less than perfection feels like it is a waste for such programmers. It is like they cannot move from a task until all possible features have been implemented…

Even if this seems unlikely, a few people operate with a similar mindset: trying to do everything that the software possibly could is similar to strive for perfection.

A simple example of this type of attitude towards programming is designing classes that have all possible methods that a client will ever need. The list of user cases continues to grow, and gets to the point when it becomes unmanageable. Classes that have all possible responsibilities is another symptom of this disease.

Avoiding Perfection

Is not that perfection, or completeness, is bad. The problem is the cost of having “perfect” software.

Software is different from physical materials. While a machine can be designed to look perfect (such as the designs that Apple strives to do), requiring the same from a piece of software would add a lot of functionality that is not essential.

A theoretically perfect software would have a virtually infinite number of features capable of satisfying every need of its users  — even if it is targeted to a specific area. Think of this as an example of combinatorial explosion, or fractal design: the more detail you try to put into an application, the more features it needs to have.

However, from all these features, one can only implement a few in finite time.

There is also a more insidious reason. As the number of features in your application grows, so grows the amount of code you need to implement them. This has two side effects:

• First, you can make more mistakes just because of the enormous surface area for them to appear. This is the classical case of bloat, where more and more features make it difficult to properly maintain the application.
• Second, as the code size increases, your program also becomes sluggish. Eventually, a program with a large number of features is slower and buggier than a more nimble version.

The next time you design an application, think twice about the essential features. Don’t try to make it perfect, make it functional. Your users will thank you.

Debugging code is an activity that shows a lot of the developer’s personality. It is a process that looks a lot like an investigation, leading to the detection of a failure in an application.

During the investigation, a programmer has to employ some techniques, like information gathering, testing of hypothesis, performing quick instrumentation, etc.

When it comes to learning how a program works, though, there are two main “schools” of debugging: the ones that use print statements, and the ones that use a debugger.

Print Statements

From these two techniques, certainly printing is the most “primitive”, in the sense that it is available in almost any programming environment. As long as there is an output device (which doesn’t need to be the screen/stdio), this technique might work.

The advantage of printing statements is that they are easy to use and program. They also don’t require the program to slow down in order to be used. For example, when working with multithreaded code, printing may be more useful than debugging, because it doesn’t require one or more of the threads to slow down.

Interactive Debuggers

Using a debugger, on the other hand, is not a privilege for everyone. There are many platforms these days with very decent debuggers; however there are still lots of environment that don’t have one.

For example, I remember reading somewhere that Linus doesn’t create a debugger for the Linux kernel because he thinks it is not important.

Despite the rant, it is  nice to have a good debugger available. Depending on the quality of the debugger, it can do some things that would be possible only on dynamic languages. Things like changing the value of variables during a debug session, or going up in the call stack and repeating some code path, can be very useful when determining where a bug is hidden.

I personally like debuggers, but agree that they should not be an excuse for sloppy thinking. Some programmers believe that is normal to use debuggers to poke at a program, instead of stopping and thinking about what the application is doing.

I like to keep in mind that debugging is a research exercise, and it works much better when we use our head more than the debugger.

Modern IDEs have very sofisticated interfaces to allow code navigation and editing. Although these facilities are very useful (specially when working with external libraries), there are somethings that are just easier to do in more traditional editors, such as UNIX ed.

One of these things is keeping the context of several parts of your code. I learned this kind of trick a few days ago when working with a large source code file.

Simulating Literate Tools
A similar tactic is used by people who use Literate Programming.

Literate programming is the methodology of software development where documentation and coding are done at the same time. Moreover,
in literate programming documentation drives the development. The main idea is that programming should be similar to writing, in the sense that code should be entered only when we describe how it works.

To make literate programming work, we need a system that can move code from the place where it is written to the place where it needs to be used.
For example, if we define how a variable is used, we might need to define in one place, and write the code in another place, depending on how the language treats the initialization of variables.

One way to do this is using the “tangle” program in the standard TeX distribution. The problem with this solution, though, is that you need to write your code in a completely different format, which is hard to use with other development tools.

An option to this style development method is presented by the use of the ed editor. The great advantage of ed over other editors is that it works with regular expressions, and only the current line is of interest.

Thus, you can mix different lines when working in the same document.

For example, suppose you are writing a function. One way of simplifying the task of writing the program is keeping a marker for the end of variable definitions as well as a marker for the current code position. With ed, you can move between these positions using the quote command (‘).

Thus, if you have markers a and b, you can just do: ‘a to move to the code definition part, and ‘b to move to the coding part. If you are defining some code that will use a variable, you can just move between these markers. It is a very simple operation that makes it much more convenient to write code. This can be used with language such as C++, where member functions have to be listed in a class declaration as well as an in the body of the source file.