Dynamic Languages

The language I really miss is alike Ruby: very usable with nice default
library. The success of Perl/Python/Ruby is partly due to their data
structures, especially lists/arrays, hashes and strings.
Alas, they miss static checks, Ruby being a dynamically typed languages, very
few checks are done at compile-time, making medium to big programs hard to
maintain.

As far as I know, few dynamically typed languages try to achieve compile-time
type checks on the overall program. The typical orientation is adding type
annotations (mainly for speedups and run-time checks). Dylan is an example of
mixing dynamic typing and explicit typing (or in Scheme,
bigloo)

Soft Typing
designates the effort of using type inference for dynamic languages.
Alas dynamic languages have a lot of features making it hard to infere types:

no string interpolation (like perl "foo is $foo" or ruby "foo is #{foo}")

uncommon syntax (especially for imperative programming and OO)

no data inheritance (only interface inheritance)

elusive syntax error messages

bad polymorphic variants error messages

Most bad points above do not need changing the language, or only a few
extensions. For example
G'Caml gets rid of
the lack of overloading. Camlp4
brings some solution to the syntax problems.
But I think OCaml is already too big a language to add new features.

Innovations

try to fill the expressivity gap between the static typing world and the
dynamic typing world.