Introduction
become a software engineer, then there is a good chance you have come across the term “duck
typing” but had no clue what it was and what it meant. So what is duck
typing? It’s actually easier to understand than you think! Let’s dive
in.
What Is Duck Typing?
Many explanations of Duck Typing start with the same quote, “If it walks
like a duck and it quacks like a duck, then it must be a duck” but what
exactly does that mean?
Well, this explanation is creating an analogy between an object and its
properties and methods to a duck and its features. The object being the
duck and the properties or methods of the object being the duck’s
features (it can quack, fly, swim, etc).
Here is my terrible interpretation of this duck in python so you can
understand the similarities between the object and the physical duck.
I know, it’s beautiful.
In many languages, being able to pass around objects depend on whether
or not that object is the correct type to be passed around. If it is
not, the type system will throw an error.
However, languages that support duck typing take a much lazier approach.
Instead of checking if the object type is correct, the interpreter will
simply check if the necessary methods are the same. If so, allow the
code to be executed anyways.
After all, if the methods are the same, with the same types, then there
really is no harm in executing the code. It might as well be the
original object (might as well be a duck). Get the reference?
Duck Typing Explained In Code
If you’re still a little unclear on how duck typing works, hopefully,
this code snippet will help make everything a bit clearer. We have
already seen an object that is used to display our duck analogy.
However, what if we wanted to run some code that behaved just like our
duck object but was actually a different animal? Well, thanks to
Pythons duck typing abilities, that is totally okay! Assuming the other animal is using the same
methods; if not, Python will throw an error.
As you can see above, although we intended to use our loop for a duck, the
code had no problem executing the flys() method for our goose
object as well. However, since our goose can’t quack, python threw an
error.
In other words, since python allows duck typing it assumed that since the
Goose fly’s like a duck, it must be a duck. The language later decides that
since it doesn’t quack like a duck, it can’t be a duck.
This is decided at runtime. Which is why the fly() message will execute
before throwing the error.
Is Duck Typing Bad And When Is It Useful?
So, is duck typing bad? As with everything in programming, it depends. Duck
typing is not inherently good or bad and can be argued on both oppositions.
Disadvantages of Duck Typing
The biggest disadvantage of duck typing is that it leaves the responsibility
of writing clean error-free code in the hands of the developer. This can be a
big issue if working with an inexperienced programmer or when taking on a
project that was passed along to you.
Poorly written duck typing code can lead to long and painful hours debugging a
program that should never have needed debugging to begin with. This can then
lead to costly development time and more working hours.
Additionally, if you had a type system that checked for errors on compile, it
makes it much easier for IDEs to complain as you’re typing. Allowing you to
find bugs faster and making them much easier to fix. With duck typing, errors
are discovered during runtime, which makes it harder to go back and fix past
mistakes.
Advantages of Duck Typing
Alternatively, duck typing has plenty of positives. After all, there is a
reason that so many newer languages allow this functionality. The first
advantage is that it leads to fewer lines of code. This makes it look cleaner;
thus making your code easier to read and faster to write.
It can be hard to see the advantages of duck typing until you have used
languages with and without it. Afterward, you will realize it makes your job a
lot easier when you’re not dealing with interfaces (such as in Java or C#) or
keeping track of what type your object is. Assuming you don’t fall into bad
practices, it really is useful functionality!
