On 2006-08-17, Ted Zlatanov <[EMAIL PROTECTED]> wrote:
>> 'Timebomb' refers to errors related to typing being possible at run
>> time, be this either runtime type errors in strong timebomb typing,
>> or NULL pointer references in weak timebomb typing.
>
> Maybe this is a term I haven't heard before. I have always heard of
> weakly- and strongly-typed languages. It seems to me biased
> regardless, as it infers a "bomb" effect from weak types. Sorry I
> assumed it was your own term.
It _is_ my own term. It not only refers to "weak" typing, but to
dynamic typing as well. It refers to any type system that does
very little at _compile time_ to catch such programmer errors
that can be caught with a type system.
It should be noted that the type systems of Haskell and similar
languages, infact, let many errors pass through that could be caught
in dependently typed languages, such as Epigram. In dependent type
systems, it is possible to indicate the dimensions of a result of a
function dependent on the dimensions of its parameter, and so on. For
example, the type signature of a function that returns the tail of a
finite list of integers, could look like:
tail : forall n:Nat => IntList (suc n) -> IntList n
An error can then be triggered at a compile time, if another function
might pass an empty list to tail. Unfortunately, full type inference
is theoretically impossible with dependent types, IIRC, and these
languages are not very practical... yet.
> Perl enforces types at run time. But it doesn't really enforce them
> in the classic sense - it's very accomodating.
> A Perl program will not crash because of the wrong type.
It just won't work right, and something will crash to an assertion,
hang because of corrupted values, or do something to damage the whole
system, just because the type system didn't guard against programmer
errors. Sounds like a timebomb to me. Actually, perl probably falls
into weak dynamic typing, not strong dynamic typing unlike Lua, Python,
etc. (although these categories are a bit vague).
--
Tuomo
