Question

It seems I’ve got to agree with this post when it states that

[…] code in dynamically typed languages follows static-typing conventions

Much dynamic language code I encounter does indeed seem to be quite static (thinking of PHP) whereas dynamic approaches look somewhat clumsy or unnecessary instead.

Most of the time, it’s just about omitting type signatures, which, in the context of type-inference/structural typing, doesn’t even have to imply dynamic typing at all.

So my question (and it’s not meant to be too subjective) is, in which dynamic languages or fields of application are all these more advanced dynamic language features (that couln’t be replicated in static/compiled languages that easily) actually and idomatically used.

Examples:

• Reflection
• First-class continuations
• Runtime object alteration/generation
• Metaprogramming
• Run-time code evaluation
• Non-existent member behaviour

What are useful applications for such techniques?

Answer 1

All features you enumerate are also available in statically typed languages some with constraints.

• Reflection: Present in Java, C# (not type safe).
• First-class continuations: restricted support in Scala (maybe others)
• Runtime object alteration: Changing the type of an object is supported in a restriced form in C# with extension methods (will be in Java 7) and implicit type conversions in Scala. Although open class is not supported most of the use cases are covered by type conversions.
• Metaprogramming: I would say Metaprogramming is the heading for a lot of related features like reflection, type changes at runtime, AOP etc.

So there is not a lot left that is supported only by dynamic languages to discuss. Support for example for Reflection circumvents the type system but it is useful in certain situations where this kind of flexibility is needed. The same is true in dynamic languages.

The open class feature supported by Ruby is something that compiled languages will never support. It is the most flexible form of Metaprogramming possible (with all the implications: security, performance, maintainability.) You can change classes of the platform. It’s used by Ruby on Rails to create methods of domain objects from metadata on the fly. In a statically typed language you have at least to create (or generate the code of) the interface of your domain object.

If you’re looking for the “most dymanic languages” all homoiconic languages like LISP and Prolog are good candidates. Interestingly, C# is somewhat homoiconic with the expression trees in LINQ.