brool

I was just reminded of one of the horrible anti-patterns I’ve seen
in working with a template library that will remain nameless.

At a previous company we called it “text subclassing.” It’s what
we called it when you had to copy huge pieces of text out of a
superclass and paste it into your subclass.

Admittedly, sometimes this is just the programmer being lazy and
not wanting to think at all, but more frequently it shows a problem in
the underlying architecture that needs to be fixed. For example, in
the template library I was working with, there was this class:

class EventHandler:
    # define all events that need to be overridden here

    def createHeader(self):
        ...

    def createFooter(self):
        ...

You’d think that it would be really straightforward to override
certain pieces of the template generation, would you not?
Unfortunately, the EventHandler was used in this context:

class Compiler:
    def Compile(self, filename = sourceFile):
        # elide 100s of lines here
        self.setHandler(EventHandler())
        # elide 100s of lines here

Yup, the EventHandler was nicely designed, but it was in the middle
of 100s of lines of code. Can’t change the base class — it
wasn’t mine. So the only recourse is to do a “text subclass,” and in
the process I added the factory
pattern that should have been there in the first place:

class MyCompiler:
    def createEventHandler(self):
        "Here's the factory method."
        return MyEventHandler()

    def doCompile(self, filename = sourceFile):
        # same 100s of lines that I don't understand here
        self.setHandler(self.createEventHandler())
        # more 100s of lines that I don't understand here

Text subclassing: All of the speed of subclassing without that
extra pesky method call!

Trackback URI | Comments RSS