[Prev][Next][Index][Thread]

Re: Results: finished teaching one Dylan course

And Scott McKay writes:
 - The commercial community ignores functional languages like ML 
 - or Haskell, too; [...]

Add the interesting re-thinking of logic languages in Oz (Mozart),
slim-binary research in Oberon, ...

 - Or languages like Self, or more recently Cecil, which takes 
 - the efficient compilation of dynamically typed languages even 
 - farther than Dylan.

Here's something that will make you laugh (cry?), something I 
happened to learn at the same conference:  Self was originally 
a Sun project, right?  Then it came time to evaluate it...  Sun 
didn't see its value, and spun that research group off as a 
separate company.  Then came s-l-o-w Java.  After a JVM _implemented_
in_Self_ beat the pants off of Sun's, they bought the company _back_.  

Hotspot is really the core of Self with some lessons from Cecil, 
although much more limited in application.  So a prototype-based 
language more dynamic than Dylan (although single-dispatch, which 
changes lots), was turned into the monstrosity.

(Even more off-topic: Anyone used Cecil's predicate types for real
work?  Are they sane, or just pushing too hard on the type system?)

 - Suppose a Java designer had paid attention to some of
 - the papers that had been available early on, [...]

BTW, the Java designers _wrote_ some of those papers.  Steele and
Gosling are MIT Lisp machine folks.  There must be more going on 
than meets the eye.  They aren't dumb, and they've used or helped 
design some of the systems to which we're both referring.

The slow but steady accretion of features has made me wonder if
they're not sneaking in a single-dispatch, inline version of
Common Lisp...

 - C++ is history repeated as tragedy.  Java is history repeated
 - as farce.

To be fair, C++ originally was quite advanced.  But it was developed
before people had a good understanding of the difference between
subtyping and implementation inheretance.  And now it's stuck with
that mess, leading to all sorts of too-clever hacks pretending to
be advances.  There's a wonderful write-up somewhere of how most of
the design patterns in the GoF book simply aren't necessary in Common
Lisp, and it all carries directly over to Dylan.

Java is just a joke.  However, it is serving to convince people that
garbage collection and dynamic dispatch are a _good_ things, even 
with Sun's impl.  For how many decades have we heard that they are too
slow for real life?  I still hear that, but I'm in scientific computing 
(Fortran).  There's a window of opportunity here; you can see some of it
in the ressurection of the Smalltalk community.

So, what's to be done?  Personally, I really think that a quality,
free dynamic compilation environment that can be shared between 
languages would be a _huge_ boon.  FLINT's kinda in that direction
(flint.cs.yale.edu), but it's in ML, so people will summarily ignore 
it.  If someone could construct such an environment 1) with a core 
of C, 2) that runs Perl and Python, 3) that can parse and handle 
already compiled code, and 4) with fully integrated dynamic profiling 
and debugging...  Naturally, something a lot like Dylan would be 
perfectly reasonable to include.

sigh.  I have ideas, but no time, organization, or work ethic (it
seems sometimes).

But this is why I'm wondering how natural multiple dispatch, etc. is 
to beginners.  To me now, this type of object system is sensible, but
the objects-are-packages-of-stuff made much more sense than the
CLOS/Dylan way when I was first learning.  Of course, I came at it
from the Scheme CLOS wanna-bes, which are idiosyncratic to say the
least.  If the benefits can't be explained well and easily, there's
no chance for Dylan to catch this wave (imho).  And I'm having a hard
time articulating them when I try...  Orthogonality of concerns just
isn't a winning catch-phrase, I'm afraid.  ;)

Jason
Follow-Ups: References: