On Sun, Mar 31, 2002 at 03:57:50PM -0500, David Chase wrote:
> I've written a number of compilers, looked at many more.  I've
> written a fair amount of code in Lisp and BCPL, and had quite
> good luck with some untyped C code that I wrote long ago (all
> roads lead to void *).  I spent a good long time playing with
> functional languages (wrote an FP84 interpreter in BCPL, even).
> I'm not stupid, I'm not inexperienced.
> 
> The compilers I was thinking of, and I should have made myself
> clear, seem to take at least 8 person-years to complete, and are
> commensurately large.  It would be a tremendous win to write one
> of these in less time, but it would also be an expensive experiment.
> I don't know if they are large because they must be large, or if
> they are large because the use of a stupid language makes them
> large, or if static checking makes it possible for them to become
> large.  Again, an expensive experiment to determine what's really
> going on, and I'm not really interested in ridiculous dogmatic
> answers from people who haven't even done it in the "wrong" language.
> You probably think I'm a neanderthal for using sucky Java, but
> most places I know of that are writing compilers, are using C
> or C++ -- they're not even using language with garbage
> collection.  (Gcc, astoundingly, is written in K&R C.)  They
> are not even willing to risk that minimal a change.
> 
    From my experimentation with Squeampiler (which was originally
actually a design for a Common Lisp compiler), I can whole-heartedly
say that despite missing some features like multiple dispatch or macros,
that Squeak has undoubtedly made a lot of parts of the compiler writing
simpler, among them being it's thorough system of collection classes,
the simplicity of the language itself, etc. 
    With respect to compilers that take 8 person-years to complete, I
can't help but feeling this perspective really isn't valid anymore. With
all the revolutions going on with SSA, control dependence graphs,
scheduling and register allocation, loop analysis, etc., there is
literally a wealth of techniques out there that reduce the amount of
code you have to write by *staggering* amounts. In a mere *week*, I
had written a great deal of functionality (and it even surprises me how
much I got done when I look back on it) that GCC does with a lot more
code than I ever used (undoubtedly from the adhoc, crusty old algorithms
they use) ... YMMV, though. :)

> David Chase
> 

    Lee