Today at work, I saw the following pattern in python:
class Base(object):
@classmethod
def Spam(cls):
raise NotImplementedError()
class Derived(Base):
@classmethod
def Spam(cls):
return 'Eggs'
After thinking it over and looking at the alternatives, I didn’t have an objection. I asked for some verbose documentation explaining the decision and contract, as this is really not good OOP and, some (me) would say, polymorphism through convention- which in dynamically typed languages like python, is how polymorphism works. But it is unfamiliar and generally considered bad practice, especially in statically typed languages.
Of course this sparked some disagreement, but fortunately, this is a topic I’ve read deeply into a number of times- first, when I was thinking about how to implement the pattern and realized the error of my ways. Second, when I was working in another codebase that was a case study in antipatterns where this was used quite heavily. I read into it yet again today so I could write this blog post and send it to the persons who disagreed with my judgement of the pattern in statically typed compiled languages. So read on.
Let me reiterate- I’m not opposed to this pattern per-se in python or other dynamically typed languages. I think it is a sure sign of code smell, but there are legitimate reasons, especially if you’re working on, say, a Maya plugin and have some restricted design choices, and this can smell better than the alternative, which is a bunch of other shitty code to deal with it. In fact, it @abc.abstractstaticmethod was added to the abstract base class module in python 3.2, with Guido’s consent. Which doesn’t mean it is right, and I’d still avoid it, but it’s not terrible.
My problem is with the pattern in statically typed languages. When you make a method abstract or virtual on an interface of class, you are saying, ‘you can pass around instances of me or derived from me and they will have a method named Foo.’ Instance methods are bound to the instance. When you define a method as static, you are binding it to the class. So there are two reasons this doesn’t work- one technical/semantic, the other conceptual.
The technical/semantic cause is that virtual and static are opposite! Virtual tells the compiler, ‘look up what method to call from the vtable of the object at runtime.’ Static tells it, ‘use this method at this address.’ Virtual can only be known at runtime, while static must be known at compile time. I mean, you need a class to invoke the static method on! The only way around this is through either dynamic typing, or some sort of reflection/introspection/codegen- in which case, you aren’t working with static typing, you’re emulating a dynamically typed environment in a statically typed one!
So, clearly the concept of ‘virtual static’ is impossible in static languages like C#, C++, and Java. It doesn’t stop people from trying! However, does the fact that the languages don’t support the feature make it a bad idea (the same way that just because python 3 supports it doesn’t necessarily make it a good idea)?
Yes, yes, a thousand times yes. Let me restate the above: in order for ‘static virtual’ to be supported in a statically typed language, you need to use its dynamic typing faculties. Look, I’m all for ‘multi-paradigm’ languages (even though some artard on Reddit berated an article I wrote because that phrase doesn’t actually make sense), but we need to be very careful when we start using patterns that go against the foundation of our languages. Like I said- I’m not fundamentally opposed to the pattern, I am just opposed to using it in statically typed languages.
But that’s like saying, I prefer tomato juice to evolution. I don’t even know what that means. You cannot have virtual static methods in a statically typed language. They are incompatible.
So much for the technical (vtable)/semantic (dynamic) reason (were those 2 reasons, or one reason?). What about the conceptual one?
Well like I said earlier, virtual or abstract methods are part of a contract that says, I or a subclass will provide an implementation of this method. Classes and interfaces define contracts, and at their core, nothing else (especially not how they’re laid out in memory!). So if you’re passing around a type, and you’re saying, this type will have these methods- well, what does that look like? I can hardly fathom what the class declaration would look like:
class Base {
public virtual static Base Spam() { return Base(); }
public virtual string Ham() { return "Base Ham"; }
}
class Derived : staticimplements Base {
public override static Base Spam() { return Derived(); }
}
Well, shit. We’re saying here that Derived’s type implements the contract of Base’s type- well, Base has a ‘regular’ instance contract, the Ham method. What happens to this on Derived? Is Ham part of Base’s contract? It must be, because otherwise I have no idea what the Spam() method is going to return for Derived. Alright, so if you ‘staticimplements’ something, you get get all static and instance methods as part of your contract (and this is how python works, too).
So how do we use this?
void Frob(Base obj) { ... }
Wait. Shit. This says we’re passing in an instance of Base, whereas we want to pass in the Type of an object that staticimplements Base. So:
void Frob(BaseType obj) { ... }
So now let’s jump back to our class definitions:
class BaseType : Type { public virtual static Base Spam() { return Base(); }
class Base : staticimplements BaseType { public virtual string Ham() { return "Base Ham"; } }
class Derived : staticimplements Base { public override static Base Spam() { return Derived(); } }
Now we’re getting somewhere. We can define types that inherit from the Type object (that is some class like .NET’s Type class), and we can staticimplements those (and if you staticimplements, that implies you also get all instance methods).
Well shit, wait. If Base inherits from Type, then instances of Base will also get all instance methods from the Type object? Well ok, I can deal with that, we don’t have to use Type- what if Type inherits from RootType, and BaseType inherits from RootType, and RootType is just an empty definition so instances of objects that inherit from BaseType don’t have all of Type’s instance methods?
void Frob(BaseType baseType) {
Base obj = baseType.Spam();
//Well, how do we get an instance of BaseType from an instance of Base? We can't.
//RootType rt = obj.GetType(); //What good is RootType here?
//BaseType bt = obj.GetBaseType(); //Wait, so we put a method on the instance that needs
//to be overridden on the subclass to return an instance of the actual type?
}
I’m not going to go any further because I doubt anyone has even read this far. The question of virtual static functions in statically typed languages is pointless- much easier, then, to just throw up your hands and hack together whatever using reflection, dynamic, templating, or any other form of introspection. You can, for sure, come up with workarounds that are often quite specific and span hundreds of lines. I’ve read and gagged at a hundred of them. But given that it is currently not just technically impossible, but conceptually brain-melting, why would you?
The problem at its core is, I think, that people learn a golden hammer in one language (in this case, python, Delphi, etc.) and try to apply it to another (C#, Java, C++), as well as people coming up with a design and then figuring out how to shoehorn the idea into the language. Well guess what- not every language can execute any arbitrary patterns or designs well. Learning python made this patently clear. The language is so concise, each line (and character!) so meaningful, it is patently clear when I am doing something unpythonic- the meaningless lines of code, the extra characters, the redundant patterns in the code, the roundabout way to achieve something. Static languages don’t have this concision, they don’t have the same economy, or flexibility. There is too often a legitimate workaround or over-engineering, so when illegitimate workarounds are devised- well, who even considers it? I certainly didn’t (hello, class Blah<T> where T : Blah<T>!).
So what are your choices here? If you really think that this is your only option, your design stinks. Stinks in that it has a foul code smell. You have a few options:
- Singletons, which is a pretty big copout because you’re really just creating a static class by another name (but to be clear, are still a potential solution),
- Just create a new instance and call an instance method. Suck it up, it really isn’t a big deal, though you basically require generics and a new() constraint for it, or the conceptual opposite:
- Dependency injection. My guess is, if you’ve made it this far (congrats and thanks!), and you disagree, you’re not familiar with the idea of Dependency Injection or Inversion of Control. I’d encourage you to read up on it, and realize it isn’t nearly as complicated as you may think it is, but far too interesting to get into here.
Good luck!
I’d encourage you to do your own googling and reading about this problem. It’s quite interesting and really highlights conceptual differences between languages, and understanding the problems or benefits to the approach will make you a better programmer and designer in your preferred language.