At this rate, never.

I have no incentive to do it. Perhaps I’m a strange old fogie, but I found the *language* nearly perfect back around 2.2… I never use list comprehensions in my code (I find them hard to read, so I don’t write them), nor do I use iterators or any other of the new syntax. Certainly, the semantics were impure, but they were *simple*, and I’m a bear of little brain. I far prefer a language I can hold entirely within my head to one I have to strain to read. If I were the other way around, I’d write Perl.

I do understand the motivations for the changes in 3.0, though I disagree with some of them; but what I have never understood is the farkling of the language, adding semantics borrowed from elsewhere to do things we can *already do just fine without them.*

(A “farkle” is a shiny bit you add to a motorcycle, sports car, etc. A luggage rack or a spoiler, for instance. Things not really needed, but which are “cool” to have.)

This isn’t just my natural reactionism. I truly believe that a simpler language breaks in simpler ways, just as any simpler system tends to break in simpler ways, so that the programmer can better understand why things go wrong (and more importantly, can more easily write error-free code the first time, an experience I never had before Python).

But doesn’t the “nonlocal” statement in 3.0 allow just that?

http://docs.python.org/dev/3.0/reference/simple_stmts.html#nonlocal

(since in a strict single-assignment language like Haskell you can’t rebind any variable once you’ve assigned something to it, the analogy holds up; also, I find it curious that people who complain about Python lacking “real closures” never extend their complaint to single-assignment languages, but that’s a story for another day…)

Well… yes and no. Entirely too much attention is being focused upon 3.0.

The big news in the Python world is really 2.6. And that is what new users should target. New users targeting 3.0 in the next year or so are in for a disappointment. The comprehensive library support will just not be there for them. And top level projects, like web frameworks, are planning on taking their time… maybe one or two years… to transition. A lot of projects want to maintain 2.3 and 2.4 compatibility a while longer, and 2.3 to 3.x is just a bit of a stretch.

Some of the “old hands” with large code-bases which are their responsibility are panicking. But they shouldn’t be. 2.x will be around, and even dominant, for a long while.

The 3.0 release represents something new appearing on the horizon. And that’s all. Pick up a book on 2.x for now; 3.x is really *not* that different, unless you already have a zillion lines of code that you feel that you have to convert right now for some reason.

As an outsider, of course, I’m predisposed to these opinions.

I suspect we are in the realm of personal tastes here. I don’t think it keeps very much language crap. The only thing I don’t like in python 3 is that there *still* is no “Until” statement, for what I find dogmatic reasons. And I really don’t like comprehensions, although admittedly I use them all the time, so I’m a hypocrite on that part.

Other than that, it is pretty damn close to perfection, and if I was asked to design my perfect language, it would more or less be python 3.

Yes, this is correct. For any python version. Obvously, for Python 3, it will take much longer before most libraries are available, and for the nearest 1-2 years, if you wnat to use Python 3 you will have to make more checks to see if the libraries are available or not before the project starts. If you don’t want to do that, stay with Python 2 for the time being.

I can’t shake the feeling that you are basically upset with Python 3 because you can’t use it NOW, IMMEDIATELY, because the libraries aren’t ready. That somehow you are miffed that you can’t use the latest (and greatest) version of Python because its incompatibiliets means it will take a while for libraries to catch up.

This is true, and understandable, but you have to also remember that the version hadn’t been as great if it was compatible.

The alternative would have been to introduce incompatibilities step by step, in a series of new releases. But that would just prolong the pain, so I’m not sure that is a good idea.

Since Python 3K is breaking backwards compatibility anyways.

Why keep *so much* language crap?

It was time to fix the syntax (get rid of this underscore nonsense), add some nice things as real closures, etc…

Instead we just get a fix for Unicode (ok, this is big, but almost all modern languages have this by now (Ruby 2, Groovy, the .NET scripting languages, Perl), it’s not like it would be a huge differentiator in the future) and some restructuring of the libraries…