Last night’s panel discussion “The Language Debate” hosted by OTUG was fun. There was a lot of good discussion both during the panel and after the event. Charles Nutter, Robert Fischer, and Paul Cantrell were all great panelists.

One thing that often comes up in the static vs. dynamic discussion is the question of maintainability: With the lack of static typing, can future programmers look at a piece of code and understand what is happening in order to efficiently maintain that code?

My response (though I’m not sure it came off as clearly when I mentioned it last night) is that “With Power and Flexibility comes Responsibility.” That is, dynamic languages allow you to do many things that static languages typically do not. Whether to use certain features, however, is a different matter. The developer has the responsibility to make sure that the code is readable and understandable. This is why so many developers appreciate good design and the use of design patterns. When it comes to maintainability, this is no different than static languages. I have seen both beautiful and horrific code written in each type of language.

That’s why having good developers matters so much. To build good software, people need to think about what they are doing and why.

Aside from static typing, other features common to many dynamic languages also fall into this category of responsible coding. Metaprogramming is a big one often discussed lately and it wasn’t left out of the discussion last night.

My favorite quote of the night:

Code is an Information Design Problem
- Paul Cantrell discussing code aesthetics after referring to Edward Tufte

My favorite points about static vs. dynamic languages (found from one of the links on the wiki provided by OTUG before the event):

- Many programmers have used very poor statically typed languages.
- Many programmers have used dynamically typed languages very poorly.

Thanks to all at OTUG for pulling this together.