[ruby-talk:03463] Re: Static Typing( Was: Waffling between Python and Ruby)

Sorry, this isn't about the joke, but this seems the best place.

Static vs. dynamic is a false dichotomy.  In any individual language there
will be several things that can be done.  Some of them can be fully described
ahead of time.  These are possible candidates for static typing.  Others of
them cannot be fully described ahead of time.  They require that either the
programmer or the language implement dynamic binding, e.g., in C it is
sometimes appropriate to use pointers to functions to implement some
operations.

Operations that can be statically typed have certain efficiencies and checks
that can be applied to them that dynamically type operations can't have/use.
Ideally a language would allow the problem to be fully specified in the
dynamic form, and then allow preconditions, postconditions, etc. to be
specified to the extent that knowledge was available, and the compiler would
make use of these declarations as aids to writing safe, efficient code.  Note
that safe and efficient here would require different compile time flags
(possibly implemented as Pragmas?) as array boundary checking, e.g., is safe,
but not efficient.  So compiler markings around sections of code seem like the
appropriate way to supply the info to allow different pieces of code to be
optimized differently e.g., "{$ BoundsCheck ioVar $}".