On Lists and Iterables

[Colin Watson]

On Sun, Dec 17, 2017 at 11:02:48AM +0100, Xen wrote:
> My topic was that Ubuntu obviously never opposed any of the changes, and
> most replying here pretty much evidence that they are in favour of them.
> 
> Now, they claim that they can do nothing against upstream and that they have
> to follow the developments, that they are defending at every moment
> themselves!!!!
> 
> It's playing the victim while you are playing a leading role in making it
> happen.

Observing that something is out of scope is not playing the victim.

Ubuntu exists, in part, to get recent versions of free software into the
hands of users as straightforwardly as possible.  For the most part we
aren't programming language designers, and running a campaign against
how the custodians of the Python language have chosen to design the
latest version of that language is simply out of scope in this project.

The economics are obvious in any case.  Enough people want to use the
latest version of the language that it's a clear requirement for us to
provide it.  In general we want to avoid shipping multiple versions of
things where possible, because that's a maintenance burden.  The Python
2-to-3 transition has been such that we've had no choice but to do so in
this case, but the maintenance burden for us is only going to get worse
once Python 2 stops being supported upstream.  Thus it's clearly in our
long-term interest to put effort into moving things over to Python 3 in
ways that fall within the remit of a distribution.  The Python packaging
teams within most other major distributions have made much the same
obvious decision, explicitly or implicitly.  We are absolutely taking a
role in making it happen as smoothly as possible (though you give us too
much credit by saying that it's a leading role), and I don't think
anyone involved is ashamed of this.

This is not the same as saying that we're powerless victims.  When we
have issues with Python, we take them to the appropriate places, rather
than posting long screeds to inappropriate mailing lists.  Several
Ubuntu developers over the years have been active contributors to Python
upstream.  Many of the changes in Python 3 releases have been the result
of people working on updating their code to the latest version of the
language, finding rough edges in the process, and discussing those in
the right place so that they could be smoothed out.  (For example,
Python 3.3 reintroduced the u'...' syntax for Unicode strings even
though it's strictly redundant, to make things easier for people
forward-porting code; 3.5 restored "bytes % args", as mentioned
recently; and so on.)  These wouldn't have happened if people had stuck
their heads in the sand and decided that they were going to hold on to
Python 2 for dear life; they happened because people decided that it was
better for the world if they collaborated to help build a better
language.

And when you actually want many of the changes involved, that's the very
opposite of playing the victim!  I want to use Python 3 for the large
codebases I help to maintain (when they aren't using Python 3 already,
as several of them are).  A few things I positively want to use are:

 * async/await syntax for coroutines; we do the best we can at the
   moment with things like @defer.inlineCallbacks in Twisted, but it's
   fiddly and ugly;

 * many improvements to the standard library's subprocess module; as one
   example, I filed https://bugs.python.org/issue1652, and while I can
   work around it or use a backport, the whole point was to make the
   improved behaviour available to everyone since the old behaviour was
   a nasty gotcha;

 * much more sensible behaviour related to inheritance of file
   descriptors across forks;

 * the enum module;

 * contextlib.ExitStack, which allows replacing some very cumbersome
   constructions in Python 2;

 * much more flexible/programmable access to module importing.

I mean, this is just off the top of my head, but hopefully it makes the
point: sure, there are some stumbling blocks involved in porting to
Python 3 (typically fewer of them in newer versions), but there are more
than enough good things for it to be worthwhile in my opinion.  I can
get some of these with backported libraries, but not all, and in any
case that sort of thing gets very cumbersome.

Based on what you've said about how long it'd take to port all your
code, it seems that you have rather little investment in Python; in
fact, to be honest it sounds like you've spent more time in total
writing inflammatory emails about it here than actually writing Python
code.  So why not spend some time listening to the views of people here
who spend a lot of time writing Python code, as well as just the
negative posts you found on the internet (some of which have since fed
into improving the language anyway)?

> No one here has evidenced being opposed to the forced nature of its
> discontinuation, except for mr. Watson in saying that he would have
> preferred a 'legacy' mode for the interpreter.

I've explained already why I don't think it's particularly forced, and
I'd also add that I do recognise that such a "legacy" mode would have
been extremely difficult to build - retaining the ability to execute
Python 2 code is one thing, but in practice you'd need to be able to
pass data between the two worlds and to say the least it's not at all
obvious how that could work (Perl 5 vs. 6 doesn't have this problem).
Anyway, it's the nature of things that older versions of software are
rarely maintained in perpetuity, so I find it pretty hard to get worked
up about it.

(Incidentally, I find it pretty weird when anyone who isn't, say, my
bank manager or something refers to me using a title.  You don't seem to
do that for other people in general, so I assume you're trying to make
some kind of point, but I'm afraid it escapes me.)

-- 
Colin Watson                                       [cjwatson at ubuntu.com]