Dynamic vs. Static Typing — A Pattern-Based Analysis

This year’s PostJava workshop (2004) has the motto “Back to Dynamicity”, so this is a good opportunity to summarize some of the issues that revolve around the continuous dynamic vs. static typing debates. Of course, according to the workshop motto, this paper will take a pro-dynamicity point of view. This view is presented in the form of three examples in which a statically typed solution is forced to emulate dynamic type checking in order to do “The Right Thing”TM. These examples are presented in the form of patterns. However, since they describe widely applied non-working solutions they are called anti-patterns here. See [1] for some essential pattern-related terminology and concepts. Of course, this can only be a tessera to a broader investigation. This paper mainly focuses on shortcomings in Java (again, because of the workshop theme) which is only one example of a statically typed programming language. There are others that may have different and actually better solutions by default. But I hope this serves as a good starting point for a more objective analysis of an otherwise usually very heatedly discussed topic. In order to avoid misunderstandings, I have added the terminology that I use with regard to type systems in Appendix A.