Subject: Re: On nil qua false [was: Re: On conditionals]
From: Erik Naggum <>
Date: Fri, 30 Nov 2001 08:11:00 GMT
Newsgroups: comp.lang.lisp
Message-ID: <>

* Kent M Pitman
| Is the reason that people focus so much on static type checking that it's
| so hard to get a program to RUN in those languages?  In CL, you can run a
| partial program immediately upon writing it, and we often do.  So in
| those other programs, one runs the compiler to find errors on the basis
| of "static" info.  Whereas in CL you often also run a program fragment.
| In a language that makes you wait longer to test your code, perhaps the
| sense of need for static typechecking is higher, since that's all you can
| get for a long time...

  Interesting perspective.  If a CL program omits a function definition,
  the debugger is invoked when it is called, and one may usually define it
  and try the calling form again, even when the caller is compiled.  If a
  function in a static language program is omitted, there has traditionally
  _not_ been a debugger to invoke because the debugger or any other part of
  the development environment are not part of the "executable", so what do
  you do?  You could just terminate with a linking error, but that would
  only be marginally more useful than having the compiler gripe about it --
  and it is easy enough to write your own "stub function" that signals the
  absence of a real function body.  How useful would a debugger be for a
  language that forces the programmer to recompile a large number of its
  source files if you made changes?

  The choice to use as much as possible of the available information from
  the compilation process in the _caller_, instead of in the _callee_, may
  account for more of the difference between languages than the static vs
  dynamic nature of its type system, since that appears to be the fall-out
  of the former choice, not fundamental to it, as the more you (want to)
  optimize the _user_ of any object, the more static the whole language has
  to be.  However, as more and more information becomes available and is
  known to be static, more and more of it _may_ be used in the caller.
  This is probably also why declarations in static languages are promises
  that are required, yet expected to be broken, so the compiler punishes
  you when you do have lied (the IRS model of honesty), while they are
  (optional) promises that are expected to be kept in Common Lisp (the
  family model of honesty).

  The past is not more important than the future, despite what your culture
  has taught you.  Your future observations, conclusions, and beliefs are
  more important to you than those in your past ever will be.  The world is
  changing so fast the balance between the past and the future has shifted.