large class hierarchies in python

Justin Dubs jtdubs at
Mon Sep 10 19:19:25 CEST 2001

"Alex Martelli" <aleax at> wrote in message
news:9nieii01k24 at
> "Justin Dubs" <jtdubs at> wrote in message
> news:9ni3p0$rkn$1 at
> > 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'...?

Now, I've only been looking at this language for a little bit now....
but.... it seems to me that Multi-dispatching is just a fancy new word for
polymorphism and more over is rather poorly implemented in Dylan.  Hell, I
even prefer C++ over Dylan as far as polymorphism.  Plus I find the overall
syntax just clunky and unappealing.  The whole var :: <type> thing just
doesn't do it for me.

I'm new to the optional static typing.  I'm familiar with the concept of
dynamic and static typing and suppose I can see the advantage in optional
static typing, but I'm very non-commital at this point.  I'll need to do
some more reading and experimenting with it.

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

I would agree whole-heartedly.

> And a very different way to merge OO with FP is O'Haskell, see
> -- haven't really
> used it, but, it DOES seem interesting.
> > Mozart on the other hand, look interesting.  As does Haskell.  I've
> > 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).

I checked out Erlang.  It looks interested.  I've got it bookmarked and will
do some more reading when I have some more time.  Thanks for the idea.

> > 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
> > you don't bother with the pre/post-conditions then why bother with
> > 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:-).

Heh.  Interesting.  Thanks a lot for the great ideas.

Justin Dubs

More information about the Python-list mailing list