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

Re: C# is not Dylan (was: Re: C# : The new language from M$)


Phil Stubblefield wrote in message <395D0225.4FFEE339@rpal.rockwell.com>...
>Erik Naggum <erik@naggum.no> wrote:
>>
>> * "Scott McKay" <swm@mediaone.net>
>> |
>> | Translation: I implemented Lisp and Lisp environments for 12 years.
>> | I worked on Dylan for 5 years.  I'm back to using Lisp again.  Guess
>> | what?  I like Dylan better, syntax and all.
>>
>>   Yeah, we need more personal testimonials.
>
>And the alternative is... impersonal ad brochures?
>
>Seriously, I'd love to hear Lisp vs. Dylan comparisons from someone
>with Scott's amount of Lisp experience.  I just browsed the subject
>tree at Amazon.com, and of the three books listed within "Dylan
>Programming," one was a tutorial, one a reference manual, and the
>third had the comment, "Incomplete and riddled with errors."  I'd
>rather trust the judgement of someone like Scott, who I know *gets*
>Lisp.
>
>Scott, I second David Bakhash's interest in more details from you.


OK, I'll tell you some of the things I like about Dylan, and some
of the things I like better in Lisp.  First the likes:

 - I like Dylan's type system.  I like that the "built-in" types fix into
   the type system in a clean and consistent way.  I like that you
   can use it "typeless" but can then clamp down the types to get
   better code, and more importantly, better compile-time error
   detection.  Going back to Lisp makes me fell butt-naked on the
   type safety front; as the static-type people have been saying
   for years, a lot of errors really are type errors, and Dylan does
   a good job catching these.
 - I am surprised to say that I have come to like the infix syntax.
   For one, using type decls in Dylan is a lot easier than in Lisp,
   and a lot more readable, too.  Don't delude yourself into thinking
   Lisp has "no syntax" (as many people claim); it does, but it's
   just harder to see.
 - I like Dylan's hygienic macro system.  If we adopted Keith
   Playford's work on procedural macros, Dylan's macros would
   be very nearly as powerful as Lisp's, and many of Lisp's
   pitfalls would fall away.
 - I like that Dylan has a library compilation model.  I like being
   able to ship reusable components.  I like Dylan's library and
   module system.
 - I like that Dylan is smaller than Common Lisp.  I don't miss most
   of the fat.
 - Believe it or not, I now prefer the simpler method combination
   in Dylan.  It forces you to get your class hierarchy correct, and
   not to patch it up with kludgy method combination.  If you think
   you haven't used kludgy method combination, I bet you're wrong.
   I prided myself on how little I resorted to such kludges, but my
   Dylan experiences truly showed that my pride wenteth before
   a fall.  (I confess that I miss the "namespace" provided by
   daemon method combination, but you get used to it.)
 - I like that all primitive operations are defined as generic functions,
   too, unlike in Lisp.
 - It's partly parental pride, but I like using HD/FD better than almost
   any other programming environment I've used.  Yeah, it's not as
   mature or solid, but it's really good.

Now some dislikes:

 - I don't like that Dylan doesn't have first-class interfaces like Java.
 - I wish Dylan hadn't thrown out so much of the CLOS MOP.  I would
   like some of the introspection reinstated (slot descriptors, e.g.),
   but could live with only compile-time MOP for doing extensions.

Obviously, I like that Dylan is truly a dialect of Lisp (closest to Eulisp,
I think) with all that Lisp gives you: dynamic types, keyword args,
higher order functions, etc.
Follow-Ups: References: