So, Brian beat me to the punch: he’s posted about The Second Derivative of Programming, which is an idea that we’ve been kicking around for a while over the phone. It’s a good post, and I highly suggest tackling it.
(Note to self #1:…

Duck typing, aka structural type equivelence, is also a big feature helping code reuse. [...] It doesn’t matter if the class can quack and waddle, if the programmer didn’t say you could use it as a duck, you can’t use it as a duck. At least, not without a lot of work.

For more on this, see the 2nd and 3rd paragraph of my “Implementation Exposure Through Inheritance” post.

Because, by the definition I’ve laid out above, refactoring is not reuse. Refactoring is the process of adding uses cases to the set of uses cases a peice of code is designed to be used with. You can tell this by the fact that “rearchitect” and “redesign” are commonly used as synonyms for refactor.

Another synonym for refactor is “rewrite”. And herein lies the rub.

That’s not refactoring like I would use the term.

Wikipedia (the real-life The Guide) has a better definition: A code refactoring is any change to a computer program’s code which improves its readability or simplifies its structure without changing its results.

The purpose of refactoring a piece of code is not to tack on additional use cases — it’s to make maintenance of the code easier. This is why you don’t have to write or change test cases while you’re refactoring: the API is staying stable.

map f (map g lst)

What the Haskell compiler does (well, the GHC compiler with the right options turned on, anyways) is convert the above code to:

map (f . g) lst

where the period is the composition operator ((f . g) x = f (g x)).

Now, what’s important about this is that the original nested maps are not something programmers tend to write straight up (although maybe we should)- code like that doesn’t tend to show up in the use cases programmers tend to think about. But they are a common pattern that shows up when you’re reusing code.

A common excuse programmers give when breaking reuse is performance. It’s important for the compiler to eliminate that excuse as much as possible, and that encourages reuse. Deforrestation is one of the many reasons Haskell is a powerfull language.