Instead of rehashing the old arguments, I'd like to point out some observations I've made.
The best GUI builder I've encountered is Interface Builder on Mac OS X and it works because Objective-C is a dynamically typed language. It is very to use and yet incredibly powerful.
What you notice from the beginning, is that you are building the GUI by instantiating flexible objects, instead of creating thousands of subclasses like Java would make you do.
IB is one of the few development tools that actually manage to deliver on the concept of object oriented programming as assembly of reusable building blocks.
What makes this possible is the way dynamic typing naturally decouples the system. It is almost like magic.
Another kind of magic made possible by dynamic typing is dynamic message forwarding.
Here is an example, code is in an imagined dynamically typed Java.
Here is a tree class:
Class Tree
{
Map m_values;
public Tree()
{
m_values = new HashMap();
}
public Object methodMissing(Method method,
Object... args)
{
if (args.length == 0)
{
return m_values.get(method.getName());
}
if (args.length == 1
&& isSetterMethod(method.getName()))
{
set(getVariableToSet(method.getName()), args[0]);
}
}
public Object set(String value, Object object)
{
m_values.put(value, object);
}
public Object addBranch(String name)
{
m_values.put(name, new Tree());
}
// return true if the string is a typical
// setter, e.g. "setSomeVariable"
public boolean isSetterMethod(String) { ... }
// return variable name from a setter, e.g.
// "setSomeVariable" returns "someVariable"
public boolean getVariableToSet(String) { ... }
}
We can use it this way:
Tree registry = new Tree();
t.addBranch("settings");
t.settings().setTimeout(100L);
t.settings().setHost("www.google.com");
System.out.println(t.settings().timeout());
// prints "100"
System.out.println(t.settings().host());
// prints "www.google.com"
Although this kind of coding can be misused, it is immensely powerful when it comes to avoiding boilerplate coding. In fact, the whole concept of automatic code generation used by many Java frameworks becomes completely unnecessary in dynamically typed languages.
Without dynamic typing, we deny ourselves a range of tools that does not fit in a statically typed universe. If all you've used is statically typed languages it is hard to understand the kind of freedom dynamic typing really give you, and therefore it's also hard to understand what you are sacrificing.
That said, a statically typed language has the advantage of clarity of intent which can be a substantial win in certain situations.
This is why I think that the next big development language ought to be dynamically typed but with optional static typing: the best of both worlds.
