[ruby-talk:03471] Re: [Ron Jeffries <[e-mail]>] Re: [XP] What's wrong with strict typing?

Dave Thomas wrote:
>    ... snip ...
> Bottom line: There's nothing "wrong" with strict typing languages. It
> happens that they don't provide the most productive development environment
> - arguably for many things, and certainly for XP practices like refactoring
> and test-first design.
> 
> Just my opinion, of course ... but I believe a fairly expert one. And
> semi-official to boot.
> 
> Ronald E. Jeffries
> http://www.XProgramming.com
> "This path has been placed before you, the choice is yours alone."

That's one of the bottom lines.  Static typing
generally allows a compiler to produce smaller,
faster code, or, alternatively, to conduct extra
safety inspections.  Occasionally both.  I've seen
arguments that this advantage tends to disappear as
the size of the program approaches the size of the
dynamic language's interpreter, but I rarely write
code that size.  

On the other hand, if the nature of the problem
requires a dynamic description, then either the
language or the programmer will need to specify how
to handle the dynamic bindings, and I would truely
prefer that it be the language.

On the other hand, most problems only require the
dynamic specifications in a small part of the
problem, but if the language is dynamic one is
forced to carry the overhead of an extra indirect
address for every reference, and if the language is
static, then one is forced to implement the dynamic
binding for the section where it's needed, and
neither choice is optimal.

On the gripping hand (a four handed motie?),
languages that can choose the optimal binding are
few to none.  The two that I can think of that come
close are Dylan and Neon.  I believe that Dylan
requires that the choice be made at the module
level, and Neon (an old dialect of Forth on the
Macintosh by Kyria Software) hasn't been sold or
maintained for over a decade.

The solution that I favor is default choices of
dynamic binding, and compiler hints to indicate,
e.g., that, e.g., the compiler can assume & demand
that a particular variable be a particular type.  If
the compiler is smart enough to not need the hint,
then it should do no harm.  If the compiler isn't
smart enough to use the hint, then it should do no
harm.  Rather like the register or virtual commands
in C, or the Rragma's in Ada.



-- Charles Hixson
-- [e-mail]