large class hierarchies in python

[Alex Martelli]

"Justin Dubs" <jtdubs at eos.ncsu.edu> wrote in message
news:9ni3p0$rkn$1 at uni00nw.unity.ncsu.edu...
> Thank you.  Great ideas.  I'll pass on Miranda for now then.
>
> Dylan looks mediocre.  Nothing that shook my world.  Interesting though.

I think you should give it more of a try (they used to sell the
books on it at a very good price) -- pin down what you find wrong
with it.  Multi-dispatching IS powerful, after all; and the
argument about advantages of optional static typing is heard
VERY often -- well, Dylan HAS that, so, why doesn't it 'click'...?


> OCaml for some reason just doesn't "do it for me."  Not sure why.  I'll
> check out it's feature-set though.

Doesn't do much for me either, and I *DO* know why: it strikes
me as the present-day equivalent of C++.  Lots of paradigms more
or less jumbled together, lots of power (and speed!), syntax
somewhat haphazard.  SML (and even more Haskell) strike me as
way more elegant.

And a very different way to merge OO with FP is O'Haskell, see
http://www.cs.chalmers.se/~nordland/ohaskell/ -- haven't really
used it, but, it DOES seem interesting.


> Mozart on the other hand, look interesting.  As does Haskell.  I've always
> thought about learning SML, maybe I'll check that one out too.

For completeness, I should mention Erlang -- it has a lot of
emphasis on distributed/concurrent programming, FP (single-
assignment), dynamic typing -- an interesting combination, and
I believe it's _the_ FP language on which most money is being
invested and made these days (both in Ericsson development,
and in other companies, such as one which was acquired by
Nortel about a year ago and whose name now escapes me).


> Oh, and as an aside, I've decided that I'm not thrilled with Eiffel
either.

Me neither.  Sather used to be an interesting variation, pity it's
now "stabilized" (for which, read: "dead":-).

> It seems like it has lots of interesting features, but that they would
take
> so much effort to use well that most programmers wouldn't bother.  And if
> you don't bother with the pre/post-conditions then why bother with Eiffel.
> But maybe I'll change my mind.

Pre/post conditions are the *GOOD* part (well, those and invariants:-).

For that you pay with the most rigid of typesystems (Haskell shows
what a completely compile-time safe, static typesystem should be --
Eiffel shows what it _shouldn't_ be:-), Meyers' many hobby-horses (any
function that returns a result must not have side effects), "impure"
generics (mixing signature-based AND type-based considerations -- pooh,
give me pure signature-based generics any day!-).

> Thank you all for the great advice.  If anyone else knows of some
languages
> with anything radical about them, let me know.  Thanks guys,

Thinking again of concurrency-centered languages, Occam used to be pretty
radical back in its time (I do believe it was also first to introduce
"whitespace as the only way to group statements" which we love so much
in Python:-).  But I'm not sure where one would find a compiler and
interpreter today, or, for that matter, a transputer PC board:-).


Alex