PEP scepticism

[Martijn Faassen]

Guido van Rossum <guido at python.org> wrote:
> m.faassen at vet.uu.nl (Martijn Faassen) writes:

>> Which is why a system more or less *forcing* core developers to look
>> at these issues *only* for a while may be good.

> As the main core developer, I object to this idea and your previous
> post on this.  Most of the needed library modules simply cannot be
> written by me or other core developers because they require specific
> application area knowledge that I don't have.  (E.g. XML.)

But isn't there the role of integration and approval of library
additions and changes to the core library? What about other infrastructure?
It would seem to me there is more to this than just implementation
by itself.

> On the other hand, very few folks have the knowledge, understanding
> and vision to make changes to the language without breaking it.

> So let's all do what we do best: the core developers (e.g. PythonLabs)
> improve the language, and the community improves the library.

(Note that with 'core developers' I meant everybody (presumably on
python-dev mostly) actively working on changes to the core language.)

It strikes me then that there appears to be no real team dealing with
improvements to the standard library then. Of course there are groups of people
such as the XML-SIG which deal with specific issues, but the
important supportive role of integrators seems to be partially
unfilled. Such integrators would actively evaluate new modules for
adoption to the standard library, integrate changes to existing modules,
and look to improving the overal architecture of the library.
(how the parts hang together)

Integration of changes to the standard library happens right now, but
appears to have a lesser priority (due to less interest, surely
not due to lack of expertise) in the minds of the developers of the core 
language. Or did I understand you incorrectly?

Would the explicit formation of such a group of people be a good idea?

Such moves might addresses a concern, but only half of the two
concerns my proposal was trying to address.

The other worry is about these continuous changes to the core language.
My idea tried to address is to put some deliberate pause in the development
of core language features. Even though most of us like new features
and I certainly like to talk about them (idly and waving lots of hands,
too), the concern exists, among apparently quite a few people, that 
eventually this pattern may lead to a language that doesn't fit in
people's minds comfortably anymore. Of course, we grow with the language,
but we'd also like Python to be easy to understand for beginners
(and to be able to read our own code half a year into the future).

[I really like new features; I generally enjoy thinking about them,
and learning about them and playing with them. Generators, microthreads,
coroutines, optional type annotations, the works! But I might certainly
have been overwhelmed by them as a beginner. Still could be, 
especially when reading other people's code that uses them.]

I realize the core developers don't want to stop developing the core
language. It's what they do and like to do. So I proposed something
that could address two possible problems in one go, while still continuing
the language development, albeit at a slower rate.

Another way to address this concern could be by simply taking longer at 
releasing new versions of Python (with new features). This is unlikely to
happen, as fortunately the Python core developers have had more time to
focus on developing Python in recent time.

But, how can the concern be addressed then? Should it be? Is the concern
invalid, do you think, and if so, for what reason? Is this a genuine 
risk or not?

The issue is of course not an urgent one. But overcomplexity creeping
on us slowly is still overcomplexity; better do something about it
before it hurts, if it is indeed something to worry about.

So-Tim-was-channeling-correctly-ly yours,

Martijn
-- 
History of the 20th Century: WW1, WW2, WW3?
No, WWW -- Could we be going in the right direction?