Acrimony in c.l.p.

[Tim Peters]

[Terry Hancock]
>> Python, I find, is> consistently frustrating to any such impulses
>> I might have.  Most newbies can figure out even fairly clever code
>> by reading the source alone.  There are exceptions, but, IMHO, not
>> as many.

[dsavitsk]
> This seems to me to be a bit of a myth which was more true in 1.5.2
> days.

I don't think so.  If, for example, you dig into the actual archives, even
in Python 1.0 days you're sure to find threads between me and Steven
Majewski that even today nobody else would understand.

Because Python strives to expose pieces of its implementation, both for
introspection and for the extremely knowledgeable to alter, Deep Magic has
always been possible, and has always been deeply obscure.

Most Python users shouldn't bother with any of that, though.  People, e.g.,
writing Python debuggers, or automating C generation (etc -- system tasks),
have to bother with it.  Indeed, I'd lump metaclasses almost entirely into
this category:  even 2.2's flavor are deeper magic than 99% of users should
ever worry about.  If you wonder whether you need them, you don't (the
people who actually need them know with certainty that they need them, and
don't need an explanation about why).

> It is not to say that many of the additions to the language are
> not welcome, but only that they seem to deal with topics and
> practices which are complicated.

I expect you're mostly thinking of features here that fell out of type/class
unification, but TCU was primarily for the benefit of authors of C extension
packages, not for Python end users (although they got some cool features out
of it too).  Writing extensions in C, and especially writing classes in C,
has always bristled with subtleties, and the TCU work actually made that
substantially easier.

> While the developers of the language have done a good job of
> implementing new features in a reasonable way, the additional
> complexities to reading other's code often puts it beyond
> the realm of newbies -- perhaps including some of us who feel
> like perpetual newbies.

Here's the plan:  When someone uses a feature you don't understand, simply
shoot them.  This is easier than learning something new, and before too long
the only living coders will be writing in an easily understood, tiny subset
of Python 0.9.6 <wink>.