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

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

Scott McKay wrote:
> 
>  - 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,

Up to here, I don't believe there is any real difference to CL.  Not
that you are comparing...


>     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.

This I simply no longer agree with.  Well, for all I know _you_ do
feel "butt-naked" w/o static typing, but I don't believe there is any
significant objective reality to the proposition that it really helps
find errors or helps clear up design issues, or whatever.

I used to believe that it _did_ help a lot with errors (well, more or
less), and it is certainly true that you can give some pretty good
arguments that static typing _should_ make a difference here, but in
practice it turns out to mean more or less nothing.  At least in our
experience.  Having built some large (and more importantly, _complex_)
stuff in statically typed languages (Ada95, Java) as well as Common
Lisp, Common Lisp turns out to be significantly better wrt catching
and eliminating errors.  This is even more true wrt "real" bugs -
logic errors.  I actually kept a log on the number of errors that a
statically typed language would have saved me from at runtime (note:
this is the only real difference - it is important to realize that the
error _will_ be caught with dynamic typing just as well as with static
typing)..  This currently amounts to 3 simple typos in 2MB of source.

If you are working on true safety critical and/or mission critical
control software, then the very small potential advantage of static
typing preventing a runtime error is clearly still worth it.  However,
in anything else it is more than made up for by the true dynamicism,
flexibility, and inherently easier to test (and thus more likely to be
fully tested) approach provided by environments like Common Lisp.


>  - 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,

I don't think this has anything to do with "infix syntax".

>  - 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,

Presumably this means these would allow complete use of the entire
language and any user defined functions and macros for processing at
compile time.  However, that didn't happen and (even though you try to
claim otherwise) it is likely that the effort to make this all work
smoothly with the significantly more difficult syntax had a lot to do
with this.


>    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 haven't, and you'd be wrong.  If there is any inherent problem here
it is that people use OO for things for which it shouldn't be.



/Jon

-- 
Jon Anthony
Synquiry Technologies, Ltd. Belmont, MA 02478, 617.484.3383
"Nightmares - Ha!  The way my life's been going lately,
 Who'd notice?"  -- Londo Mollari
Follow-Ups: References: