Why is the "Dynamic" part of Dynamic languages so good?

Question

Jon Skeet posted this blog post, in which he states that he is going to be asking why the dynamic part of languages are so good. So i thought i'd preemptively ask on his behalf: What makes them so good?

Answer 1

The two fundamentally different approaches to types in programming languages are static types and dynamic types. They enable very different programming paradigms and they each have their own benefits and drawbacks.

I'd highly recommend Chris Smith's excellent article What to Know Before Debating Type Systems for more background on the subject.

From that article:

A static type system is a mechanism by which a compiler examines source code and assigns labels (called "types") to pieces of the syntax, and then uses them to infer something about the program's behavior. A dynamic type system is a mechanism by which a compiler generates code to keep track of the sort of data (coincidentally, also called its "type") used by the program. The use of the same word "type" in each of these two systems is, of course, not really entirely coincidental; yet it is best understood as having a sort of weak historical significance. Great confusion results from trying to find a world view in which "type" really means the same thing in both systems. It doesn't. The better way to approach the issue is to recognize that:

• Much of the time, programmers are trying to solve the same problem with static and dynamic types.
• Nevertheless, static types are not limited to problems solved by dynamic types.
• Nor are dynamic types limited to problems that can be solved with static types.
• At their core, these two techniques are not the same thing at all.

Answer 2

Dynamic programming languages basically do things at runtime that other languages do at Compile time. This includes extension of the program, by adding new code, by extending objects and definitions, or by modifying the type system, all during program execution rather than compilation.

http://en.wikipedia.org/wiki/Dynamic%5Fprogramming%5Flanguage

Here are some common examples

http://en.wikipedia.org/wiki/Category%3ADynamic%5Fprogramming%5Flanguages

And to answer your original question:

They're slow, You need to use a basic text editor to write them - no Intellisense or Code prompts, they tend to be a big pain in the ass to write and maintain. BUT the most famous one (javascript) runs on practically every browser in the world - that's a good thing I guess. Lets call it 'broad compatibility'. I think you could probably get a dynamic language interpretor for most operating systems, but you certainly couldn't get a compiler for non dynamic languages for most operating systems.

Answer 3

The main thing is that you avoid a lot of redundancy that comes from making the programmer "declare" this, that, and the other. A similar advantage could be obtained through type inferencing (boo does that, for example) but not quite as cheaply and flexibly. As I wrote in the past...:

complete type checking or inference requires analysis of the whole program, which may be quite impractical -- and stops what Van Roy and Haridi, in their masterpiece "Concepts, Techniques and Models of Computer Programming", call "totally open programming". Quoting a post of mine from 2004: """ I love the explanations of Van Roy and Haridi, p. 104-106 of their book, though I may or may not agree with their conclusions (which are basically that the intrinsic difference is tiny -- they point to Oz and Alice as interoperable languages without and with static typing, respectively), all the points they make are good. Most importantly, I believe, the way dynamic typing allows real modularity (harder with static typing, since type discipline must be enforced across module boundaries), and "exploratory computing in a computation model that integrates several programming paradigms".

"Dynamic typing is recommended", they conclude, "when programs must be as flexible as possible". I recommend reading the Agile Manifesto to understand why maximal flexibility is crucial in most real-world application programming -- and therefore why, in said real world rather than in the more academic circles Dr. Van Roy and Dr. Hadidi move in, dynamic typing is generally preferable, and not such a tiny issue as they make the difference to be. Still, they at least show more awareness of the issues, in devoting 3 excellent pages of discussion about it, pros and cons, than almost any other book I've seen -- most books have clearly delineated and preformed precedence one way or the other, so the discussion is rarely as balanced as that;).

Answer 4

In statically typed languages, we're supposed to code to interfaces, not specific implementations. If you use

AbstractList data=getList();

getList() { return new LinkedList(); }

All you have to do to change the type of list used by the program is change getList. By expanding the types you can operate on, you have better more reusable code. One of the advantages of Dynamic Languages is they eliminate many restrictions static languages impose on the types.

int multiply(int a,int b) { return a*b; }   /*static language*/ 

def multiply(a,b):                          /*dynamic language (python)*/
    return a*b

The static version can only ever by used on ints. Period. The dynamic version has no specification on what type can be passed in, it simply invokes the * operator with two arguments. This could result in the multiplying of numbers, the repetition of a string, or whatever effect you give the * operator in your built in type. This is infinitely more flexible.

Answer 5

I'd start with recommending reading Steve Yegge's post on Is Weak Typing Strong Enough, then his post on Dynamic Languages Strike Back. That ought to at least get you started!

Answer 6

Let's do a few advantage/disadvantage comparisons:

Dynamic Languages:

• Type decisions can be changed with minimal code impact.
• Code can be written/compiled in isolation. I don't need an implementation or even formal description of the type to write code.
• Have to rely on unit tests to find any type errors.
• Language is more terse. Less typing.
• Types can be modified at runtime.
• Edit and continue is much easier to implement.

Static Languages:

• Compiler tells of all type errors.
• Editors can offer prompts like Intellisense much more richly.
• More strict syntax which can be frustrating.
• More typing is (usually) required.
• Compiler can do better optimization if it knows the types ahead of time.

To complicate things a little more, consider that languages such as C# are going partially dynamic (in feel anyway) with the var construct or languages like Haskell that are statically typed but feel dynamic because of type inference.