Something I learned after long nights of coding

I just spent the better part of the period between last Thursday and yesterday rewriting a major project for my “Optimizing Compilers” course. Here’s the lowdown:

• For projects 2 through 6, each project builds upon the previous one. You use the same code and it simply grows from one project to the next.
• The professor never, ever releases solutions to past projects.
• We program in C, which is really really hard.

My partner and I went through the past couple projects (we are on #4 right now) just trying to complete them however possible. We basically ended up doing things the wrong way… our code was very iterative, did not use very many of the functions that the professor provided, and was horribly bloated. Sometime last week I realized that we had serious errors in the results that our compiler was producing, and I decided that there was no way to fix the code other than going back to the start of project 2 and rewriting everything the correct way. At first I tried avoiding this course of action, but I then went with my gut instinct and started fresh from the beginning.

It took at least 20 hours of my partner and I working together to figure out how the professor’s functions worked, develop the algorithms for doing everything recursively where the professor intended for it to be done, and figure out which of our functions could be reused and which had to be discarded. It was really tough… while most Cornell students were out partying Friday and Saturday night, my partner and I were in the Linux lab coding into the following mornings. I guess this is where Cornell has taught me how to really get into my work and grind away until it’s done. Ugh. I don’t care to have skills like that.

As you can probably guess, we did manage to catch up with the current project, and our new code is much cleaner, and more importantly, more correct than what we had before. All the work was worth it. We might even be able to finish project 4 (it’s due Wednesday).

Last night, while walking back to my dorm from the lab at a very late hour, I was thinking about this experience and a similar one in my Computer Architecture course. I realized two things always seem to be true about programming:

• There is always an elegant solution to every problem, one which is clean and simple and works amazingly well.
• When you have lots of bugs and can’t seem to fix your code, it’s usually a good idea to start over, knowing that the knowledge you’ve gained from your hours of work will most likely enable you to correct your mistakes and find those elegant solutions.

Have you observed this in your programming projects? Have you ever started over from scratch and found it to be a wise choice?

Update 11-2-06: Just wanted to let you know that I (sort of) finished the project. It took all of my time in the past week, including staying up all night last night in the lab working on it (I didn’t sleep at all), and in the end I had an implementation that fulfilled the requirements almost entirely. I did, however, have a bug in our code that I was never able to solve, but hopefully it will go unnoticed when the grader tests it. Here’s looking to the next step of the project, due 2 weeks from now