On code quality: rewrite once

#1

Post by Tihy » Tue, Jan 27, 2009, 2:02 PM UTC

All you have to do is delete your first implementation and rewrite all the code from scratch. The main reason for this is that you can focus on code quality without being constrained by the existing implementation.

On code quality: rewrite once
blog.tetrack.com

Re: On code quality: rewrite once

#2

Post by zepolen » Tue, Jan 27, 2009, 2:32 PM UTC

I use this technique all the time, a quick throwaway prototype to get something working and the basics figured out, then sit back think about how it should be done properly and redo it bearing in mind the possible traps you missed the first time.

Re: On code quality: rewrite once

#3

Post by vivekkhurana » Tue, Jan 27, 2009, 2:53 PM UTC

Isn't this what refactoring is ? As you mature as a coder, you will be able to write good code for certain standards which need not be thrown away. So having a look at the code and fixing the crappy portion will be more productive than throwing away the whole implementation. I think whole rewrite rule is useful when you start working on a new technology... but if you are using a stack for considerable amount of time, then refactoring is the way to improve the code quality.

Re: On code quality: rewrite once

#4

Post by Tihy » Tue, Jan 27, 2009, 3:07 PM UTC

vivekkhurana wrote: post #3

Isn't this what refactoring is ? As you mature as a coder, you will be able to write good code for certain standards which need not be thrown away. So having a look at the code and fixing the crappy portion will be more productive than throwing away the whole implementation. I think whole rewrite rule is useful when you start working on a new technology... but if you are using a stack for considerable amount of time,…

You are right. Refactoring can be "the way" to improve existing code. This technique is meant to improve the quality of the first implementation. Think about the first source control submit.

Re: On code quality: rewrite once

#5

Post by leftnode » Tue, Jan 27, 2009, 3:16 PM UTC

Yes, I entirely agree with doing this, especially if you get requirements while you're working. In college, I was working on a site that I received piecewise requirements, and one requirement would cause me to rewrite one module that would cause conflicts with others. Once I was satisfied that I had all of the requirements, I simply rewrote everything almost entirely from scratch.

So yes, its best to try to write it correctly the first time, but its ok to rewrite it a second. After that, you should probably look as to what you're doing wrong.

Re: On code quality: rewrite once

#6

Post by lallysingh » Tue, Jan 27, 2009, 3:34 PM UTC

IMHO there's some code that deserves more than 1 rewrite.

For example the library Powerplant (Metrowerks' mac equivalent to MFC) was rewritten a dozen times before it was released, as its design patterns needed a lot of fishing out to get them right.

Re: On code quality: rewrite once

#7

Post by bmj » Tue, Jan 27, 2009, 4:13 PM UTC

vivekkhurana wrote: post #3

Isn't this what refactoring is ? As you mature as a coder, you will be able to write good code for certain standards which need not be thrown away. So having a look at the code and fixing the crappy portion will be more productive than throwing away the whole implementation. I think whole rewrite rule is useful when you start working on a new technology... but if you are using a stack for considerable amount of time,…

Well, maybe. I think it depends on the project.

At the moment, I'm working interfacing a handheld device with a networking device. I quickly wrote a prototype to work out implementation details (since connectivity required using a particular protocol). That's not to say I didn't write parts of the prototype to be refactored or pulled out, but given that I had to do a fair amount of exploratory programming to determine the best implementation, much of the prototype code will be thrown away.

Re: On code quality: rewrite once

#8

Post by ken » Tue, Jan 27, 2009, 4:53 PM UTC

I find rewriting is more necessary in some languages than others. In Java, a rewrite was common. In Lisp, I don't think I've ever rewritten: the first dumbest prototype is just one continuous refactoring away from the final product. Python and Ruby were somewhere in between.

I kind of have a vague feeling for why this would be true, but I can't quite put it into words. Maybe it has to do with how much structural stuff I have to write, or how directly I can express my program in the first place. Thoughts?

Re: On code quality: rewrite once

#9

Post by s3b » Tue, Jan 27, 2009, 5:44 PM UTC

I think its best to write once to get the tests done right and to make sure the design works, then rewrite to get the code more readable. That way the tests will save you if you screw up the rewrite.

Re: On code quality: rewrite once

#10

Post by lgriffith » Tue, Jan 27, 2009, 6:33 PM UTC

Beware of the dreaded Second System Effect. As in your second system is assured to be a disaster because you think you know enough but never really do. The practice of rewriting everything once assures that you will eternally experience the Second System Effect.

OK to rewrite the really bad stuff that has a high density of bugs. OK to adapt your architecture if it really doesn't fit the problem domain you are discovering and you really can make it simpler. OK to clean up basically ugly code that neither you nor others can easily understand. The important thing is to have a good reason to rewrite besides "I always do it that way."

Always rewrite from scratch on principle? This is the path to madness, failure, project overruns, and downright disasters. That is unless you are very very lucky. Luck helps but good software is not produced by luck.