Weak versus strong languages, who wins the fight?

With all the buzz in scripting languages (again 🙂 often programming languages are divided into weak versus strong typed or dynamic versus static typed languages. I don't know how often some of us have seen this discussion, the first time for me was when I had to argue with C++ developers because I wanted to use Python (and then did) for web/database development nearly ten years ago.

Static versus dynamic

What does weak versus strong mean? This is based on the type system of the programming language. Languages where the type of references can change are usually called dynamic (weak), languages where the type of a reference is fixed are called static (strong). Take these two examples:

   String name = "stephan";


   def name = "stephan"

The first one is in Java and the second one is in Groovy. In the Java example a reference (variable) name is created. Then a data structure which contains stephan is created and assigned to the reference.

In the second example the same is done in Groovy. Where is the difference? Consider this:

   String name = "stephan";
   name = new Name("stephan");


   def name = "stephan"
   name = new Name("stephan")

The first example doesn't work, but the second does. This is because Java is statically typed which means the reference is statically typed. A reference possesses a type, in this case String. A reference with type String can only point to data structures which contain data of type String. In Groovy the reference is dynamically typed. So the type of the reference can change from String to Name when the data which it points to changes.

Another example in Groovy:

   String name = "stephan"

Hey, this is Java right? Didn't I say, Groovy is dynamic not static typed? Yes, you're right. But Groovy is more than this. Groovy is both dynamic and static. So the developer can choose a reference to be dynamic or static, just as needed.

Although categorizing languages into dynamic versus static (which the dynamic camp uses) describes languages better than weak versus strong (which the static camp uses), those categorizations are too simple to be useful, as seen already in the case of Groovy.

And there are at least two dimensions for typing, reference typing and data structure typing. In programming languages both references and data structures can be typed. This matrix divides languages between dynamic and static typed languages for references and for data structures.


Ruby, Python, Smalltalk and Java have all statically typed data structures (you could argue Ruby has dynamically typed data structures). But Ruby and Python use dynamic references while Java uses static references.

In the bottom right, there is C which has typed references but untyped data structures. And C doesn't enforce that typed references point to the correct data structures (because those are not typed). C data structures can be typed by adding a type field to the structure and checking the type before any operations on the data structure. Some C developers did this for more reference safety.

Other languages are even more free. Javascript for example uses prototyping for object creation, not classes in the traditional way. Maps and objects do not differ in Javascript and are essentially the same. Javascript does not know methods but executable attributes are used as methods. Libraries like Prototype or Base extend Javascript with an inheritance based class system.

Some languages can change the data structures although the data structures are typed. In languages with Meta support (Ruby, Groovy, ...) data structures can be changed, fields and methods can be added at runtime.

Scripting languages

I think there is more to this than the simple 2Ã—2 matrix from above. Sometimes people use the terms dynamic and static, but mean scripting and compiled. What is scripting? Traditionally scripting languages were interpreted languages. In web devlopment scripting languages like Ruby and PHP make development easier. No compilation is needed and after changing your programm you can hit reload in the browser and see the new result. This way turn around times are minimized and development is speed up. But the line gets blurred. Scripting languages get virtual machines and are compiled to byte code for better performance. Java compiles to byte code which is interpreted. New Java VMs then don't interpret all byte code but compile the byte code to native code on the fly and as needed. Also compiled languages like Java get new classloaders and containers which compile new source code to byte code on the fly. And VMs like the Java VM run new languages like Groovy which can be compiled on the fly. For example in the excellent Grails framework.

Functional languages

Some people use dynamic versus static and mean object oriented versus functional. Consider these two examples (taken from Cedric Beust):

List result = new ArrayList();
File f = new File(directory);
for (String fileName : f.list()) {
  if (fileName.endsWith(".gz")) {
Collections.sort(result, new Comparator() {
  public int compare(String o1, String o2) {
    return o2.compareTo(o1);
  public boolean equals(Object o) {
    return super.equals(o);


zippedFiles = Dir.new(dir).
  entries.sort.reverse.delete_if { |x| ! (x =~ /gz$/) }

Both code fragments do the same thing which is sorting all zipped files in a directory.
The first is Java style object oriented (though this could be written shorter) and the second
is Ruby functional style. As can be seen, the second is easier to write, understand and
maintain. Especially in applications which have to deal with lots of lists functional programming makes code considerably shorter. Web applications often use lists (customers, projects, todo items) and so profit from languages which support functional style programming.


The whole discussion about dynamic and static languages is senseless. There are more dimensions which characterize a language than dynamic versus static. Scripting/compiled and functional/OO are other important things to consider. Languages like Groovy support object oriented and functional programming styles, can be used as a scripting language and compiled to byte code, support both dynamic and static typing of references and with meta programming capabilites support modifying static typed data structures.

I think there is still more to say about dynamic versus static. But this post needs to end here.

Who wins the fight? The is no fight, know your tools and use the best tool for the job. But at least the static/dynamic dimension is less usefull than it seams at first.