Hey all,

On the typing issues, it seems that the third axis of declarative vs
inferred typing has been missed.

For example, in Java/C# etc. you have to declare the type of any and
every variable you create.  In languages like ML / Haskell, the
compiler is able to infer the types of your variables (you may
optionally expicitly declare the type of them yourself if you want).
If you want a language that mixes the whole
dynamic/static/optional/inferred system there's Boo sitting on codehaus
that (the last time I looked) does all of those, which was quite neat.
[Tho .NET based]

Of course in the dynamic languages where the checks are done at
runtime, it doesn't make sense to declare the types yourself.   Of
course some level of static typing / static analysis in a language like
ruby is still useful (e.g. for accurate IDE code completions)

> I forgot what I wrote, but what I meant was "static typing is wrong".
I'd disagree, static typing is right, forced declaritive typing is
wrong.  The computer should be able to infer the types of most things.

I'll admit that actually writing the algorithms to do the inference for
something as dynamic as ruby would be hard (and probably provably
"impossible") to cover every case, but if you're coding in the sane
90%ish of the language that doesn't use eval or equivalent to redefine
every method call to something else, then you should be able to have
the computer check that you are doing something right, or at least not
somethign that is impossibly wrong.

> Hacks like generics are attempts to put "a little" dynamic typing into static
> typing languages.
Actually, (java) generics adds a small layer of static safety to what
would other-wise would only be a dynamic operation.  (Tho in java the
dynamic check is still made).

> Static typing should be optional,
Declaritive typing should be optional.  Static typing should be used
for whatever can be analysed, and dynamic typing the rest.

> and it should not be an excuse not to write unit tests. They make static typing less important for robustness.
Absolutly, stepping back into context, type errors are just a small
subset of all the kinds of programming errors that tests (in all
guises) should be used to pick up on.

My .02

Tris