Software Engineering Stack Exchange is a question and answer site for professionals, academics, and students working within the systems development life cycle. It only takes a minute to sign up.
Sign up to join this community
I heard (from Robert C. Martin) an assertion that since dynamic languages don't have static typechecking, people should write unit tests to prevent us from type errors.
I'm not sure if I'm following the thinking here. Could anyone exaplain HOW? Could you give me one concrete example?
Unit tests don't actively prevent type errors, but they do provide you a mechanism to execute the code you have written before the entire application is complete.
If you try to do something silly, like mistyping calculateInterest as claculateinterest, then that will be caught early on if you use a statically typed, compiled language like Java because the compiler will complain loudly.
If you do the same in a dynamically typed language, the error will not be noticed until that line of code actually gets executed.
If you don't write unit tests, then it can be weeks before the application is finished far enough that your feature can be executed and tested in the complete application. That is a very long turn-around time for finding such silly mistakes.
On the other hand, if you do write unit tests, then it is mere minutes between writing a module and executing it. This has the huge advantage that the code is still fresh in your mind and that you are not yet fully occupied with writing other modules.
A good example for this comes from code I have seen recently:
if foo
bar == baz
# should be bar = baz
In python expressions like this work totally fine but they don't do what you intended.
Another typo in the same code:
class foo:
...
def bar(self):
...
def foo_bar:
...
...
foo.bar()
# They meant to use foo_bar()
Sure this is caused by bad naming but the bug could have been spottet using tests. Simple tests could have uncovered that the if statement simply does nothing.
