The Code Reuse Myth

The post “The Code Reuse Myth” by James Sugrue got me thinking.

The main problem with code reuse is that our programming languages don’t support it. We sacrificed this to the gods of efficiency four decades ago and, while a few people dared to question the practice, all of them were struck down by unexpected lightning out of the blue, so far.

As James said, “context” is the keyword. What we’d need is a programming language where you can adapt concepts to a context that goes beyond “object instance” or “class” or “application”. What we need is an efficient way to say “collect all objects and sort them by ID” where the context defines what “ID” is. What we need is an efficient way to describe a model (relations of basic data types) and then have some tool map that efficiently to reality so we can reuse parts or fragments of the model in different contexts.

OO can’t do that because it’s limited to factories and inheritance. Traditional preprocessors can’t do it, because they can’t see the AST. Having closures in a programming language is the first, tiny step in the direction to be able to push external context into existing code. This allows us to put the code to access the database into a library and influence what it does per row of the result with a closure.

But to be a real new paradigm, we need “closures” in data types as well. This means being able to reuse fragments of code and data structure definitions in a new context. These fragments need to pull along all the algorithms and structures they need without the developer having to pay close attention what is going on until the point where the result needs peep hole optimization because of performance issues.


fragment Named {
    String name

    String toString () {
        return "name=${name}"

class File : Named {...}

class Directory : Named, File {...}

Looks simple but with OO, this will get you in a lot of trouble: Directory gets a name from the class File and from the fragment Named (this is an artificial example, bear with me). Which one should the compiler chose? In OO, I can’t say “I don’t care” or “Merge them”.

With real fragments, you could say “Directory is a File in the sense that it supports a lot of the operations of a file (like rename, delete, get last modification time) but not all (you can’t execute a directory or open it for reading).” So the example would look like this:

class File : Named { 
    void delete () {...}
    Reader openForReading () {...}

class Directory : Named, File.delete {...}

Now, a Directory has a name and it “copies” the method “delete” from File along with anything this method would need. Internally, the compiler could create an invisible File delegate or it could clone the source or byte code of the File class, or whatever. Or, even better, we could say “give me a copy of File.delete() but replace all references to the field File.path with Directory.path.”

The main goal would be to allow to use the compiler as a cut’n’paste tool which checks the syntax and allows me to say “copy that method over there and replace xxx with yyy”. Because that’s why we think that code reuse could work: We see the same code over and over and over again and each time, the difference is just a tiny little bit of code which we can’t “patch” because the language just doesn’t allow it.

Leave a Reply

Fill in your details below or click an icon to log in: Logo

You are commenting using your account. Log Out /  Change )

Facebook photo

You are commenting using your Facebook account. Log Out /  Change )

Connecting to %s

This site uses Akismet to reduce spam. Learn how your comment data is processed.

%d bloggers like this: