On Fri, 28 Jan 2000, Mark Guzdial wrote:

> I do believe that types lead to better compiler output -- I agree, no 
> need to rationalize that.  The "value" that I'm questioning is that 
> types lead to more bug-free code, that types "catch errors at compile 
> time."  That claim seems untested yet, and I'm not even sure where it 
> came from.  Is it a rationalization, e.g., "Well, we have to have 
> types to make the code better -- let's claim that it's good for the 
> programmer to use types! Improves their thinking, let's say!"  Well, 
> maybe...

I was just thinking about this today while talking to someone about Squeak
(something I mentioned I was excited about) and Eiffel (something he was
excited about).  That discussion reminded me of Dylan, which I hadn't
thought about in months.  I pulled up the website for Gwydion Dylan (a
free implementation originally from CMU) and found this:

http://www.gwydiondylan.org/about-dylan.phtml

"...Efficiency and flexibility. Dylan can be used as a dynamic prototyping
language (like SmallTalk) or an efficient compiled language. Functional
Developer, Functional Objects' Dylan compiler generates code as good as
that of most C compilers, but still provides an interactive prototyping
environment like those found in SmallTalk or Tcl/Tk..."

The rest of the page is also worth reading if you're at all interested in
hearing about a language which tried to one-up Smalltalk (and might have
succeeded if it hadn't come so late to the game and been abandoned by its
original inventor, Apple [ironic, considering Squeak's origins!]). But the
reason I mention it here is the idea that you can run Dylan in two modes: 
a dynamic, interactive, prototyping mode for development, and an
efficiently compiled, static mode for delivery.  Now for the $400,000
question:  how difficult would it be to add that sort of capability to
Squeak?  :) 

-Jake