Microsoft Word OpenIssuesInOO. doc

4.5 

Dynamic typing versus static typing 

One of the classical discussions within (object-oriented) programming languages is the issue 

of static versus dynamic typing. The arguments in favour of dynamically typed languages 

are: 

•  The programming environments available for these languages are in general more 

advanced, especially in their support for incremental compilation and execution. 

• 

Static typing hinders code reuse [SU95]. 

The arguments for statically-typed languages are: 

---

• 

Strong typing is an advantage when developing production software since it improves 

the readability of the code and makes it possible to to catch more errors at compile-

time. 

• 

Compilers for statically-typed languages in general generate more efficient code. 

It should be obvious that static typing makes it possible to catch more errors at compile-

time. Type inference [APS93] may help in catching some of these errors before the program 

is run, but it cannot completely compensate for the lack of type information. 

It is true that it requires more work to implement an incremental environment for a 

statically-typed language. However, as demonstrated by the Mjølner ORM System 

[Mag94b] it is possible to develop efficient incremental environments for statically-typed 

languages. 

The dynamically-typed languages have the opposite problem: it is easy to implement 

incremental environments for such languages, but it requires more work to develop 

compilers that can produce efficient code. In the literature, there is a large collection of 

articles describing implementation techniques for dynamically-typed languages [DS84, 

Ung86, HCU91, HU94, AH95]. Some of the compilation techniques developed for 

dynamically typed languages are also relevant for statically typed languages, especially the 

ones allowing inlining of virtual function calls.  

State-of-the-art research has thus shown that it is possible to implement incremental 

environments for statically-typed languages and to have efficient implementations of 

dynamically-typed languages.  

The remaining issue thus seems to be whether or not static typing hinders code reuse and 

whether or not static typing improves readability of code. Since most pros and cons in this 

discussion are considered well know, this issues will not be further discussed in this paper.