It didn't stop IE from being robbed of momentum.
I think this is more a case study of what happens when fundamental assumptions that a technology ecosystem is based upon change. Things like string & collection types, async mechanisms, interface/protocol definitions, package managers, programming paradigms, developer preferences, and hardware performance characteristics are foundational to a language's definition. After all, the network effect that binds a language ecosystem together is all based upon being able to share code between multiple unrelated developers.
In Python's case, unicode happened. A lot of old Python code was written on the assumption that everything was a sequence of ASCII bytes; it was just plain broken in the presence of unicode characters. There's little you can do here other than accept that much of your ecosystem's strength is gone anyway and build for the future.
I suspect we'll see similar problems crop up in other languages in the near future; in particular, promisification in ES7 is a big threat to the existing Node ecosystem, which is all based upon callbacks. A language that jumps on the promise bandwagon early (Rust? Go? Elixir?) could rob Node of much of its momentum. Similarly, if Android & iOS win out over the web, that could lead to a big resurgence in Java or rise of Swift over server-side technologies like Node or Go.
Take a look at the PyPI stats for Python3 packages vs. the Hex stats for Erlang packages:
https://python3wos.appspot.com/
The vast majority of common packages are compatible with Python3. Moreover, a common Python package gets about 100x the downloads of a common Erlang package. Even with only 20% of Python users on Python3, that's still about 20x the users that Erlang has.
Python3 adoption only sucks compared to the installed base of Python2. Compared to any niche language - Haskell, Erlang, Rust, Swift - it's massive, and you're much more likely to find a battle-tested library in Python3 than in your niche language.
(The bulk of my work is actually in Node and Swift these days. Node has a mammoth package library, but that's because its culture encourages many small modules and lots of code re-use. In my experience, I've found that the chance of finding a robust, well-supported Node module is roughly equal to the chance of finding a robust, well-supported Python2 library, and is maybe 20-30% greater than the chance of finding a robust, well-supported Python3 library. The Swift library situation is much, much worse than Python3.)
On the other hand, when it finally works it is absolutely bullet proof and that's a feeling I have with very few other languages and eco systems.
The degree of isolation between subsystems and the reliability are absolutely un-matched. Neither is the learning curve :(
IE actually handled the transition very well, because backwards compatibility was the thing that kept it in the game. When it lost it was because this feature no longer mattered (that much).
Actually, C++ has an even bigger claim to the title, because it now has "modern" versions that are much better, more standards-compliant, and have language features borrowed from newer languages...but a number of enterprises are stuck with no-exceptions, no-STL, no-move-semantics subsets because that's how all the existing code is written.
I don't know about PHP, but C++ (and I suspect Java too) is backwards compatible and doesn't belong in the same class with Python. One can still compile older code and start using new features as they see fit, there is no hard break.
I suspect your perception depends a lot on which part of the community you are observing. As far as I can tell, the Python community is as vibrant and fast-growing as ever, with continuing huge crowds at Pycon, brisk sales in Python books, active meetup groups around the world, hundreds of python bloggers, several very active mailing lists, etc.
Most of the change I’ve seen is the rise in other language communities (Clojure, node / server-side Javascript, Go, Swift, ...) which share certain cultural priorities or programming niches with python, and have caused some number of Pythonistas to switch to something else. I suspect this would have happened about as much with or without the Python 3 project though.
That could be, of course for me the lens I'm looking through is very much a personal one. Backwards compatibility is a very important concept to me and I really dislike breaking changes, especially when there is no graceful intermediate phase with deprecation and warnings and ample time to move. It's what completely turned me off drupal and python more or less did the exact same thing. I'm sure that for newcomers to python the result is a much improved experience but from my point of view this was an un-necessary hardship.
The real gem in the rough with Python2 is PyPy4. You don't have to rewrite anything, while gaining CPU performance as a feature and dropping the GIL.
If you're not gaining that, I would probably switch to another language too. Elixir, Go, Swift, among others are definitely worth porting too.
Ruby and Python were always going to have problems with computing's concurrent future, but holy damn did Python just tie its shoelaces together and completely unsurprisingly fall on its face.
The fact no one is doing a "Ruby 2, 20% of rubyists finally reaching acceptance" blog post is a testament to how to move a language forward properly. And ffs is Ruby 2.x not more of an upgrade from 1.8 than Python 3 is from 2?
Ruby f-cked up with 1.8 to 1.9 transition (notice that it was also a minor version change) yet people migrated without a problem because they knew that if they stay on 1.8 soon their programs will stop working everywhere.
Python did everything they could do to help migrate (it even allows you to install all versions (I know there are no problem with anything between 2.4 - 3.5) and have them run without conflicts side by side.
The only mistake they made is to give too large window for migration. People just now started working on migrating to 3.x because development on 2.7 stopped in 2015 (even though 3.x was available for 7 years now). And there are still people who will wait until 2020 (once security patches will stop being provided) until they will decide to move.
There's so much FUD with Python 3, and goes as far as people wondering which version to use to learn it. I mean learning all the difference is at most as couple hours (and I'm being conservative here). For a beginner the only major difference is that the print is a function and not a statement, the whole unicode is barely noticeable unless you are writing code that should work on 2.x which shows it was needed, because wringing correct unicode code in 2.x is hard.
The migration window was extended because the core development team didn't want to lose control of Python(2). Someone else would've taken control for sure, and for myself, I've already ported to PyPy4 instead of Python3.
A much easier transition than going to Python3 and nets you CPU performance and GIL-free Python.
As for PyPy4, majority of people don't chose python for performance. Even PyPy will perform worse than statically compiled languages. If performance is the goal, you should probably look into golang or even C.
Personally, I prefer to write Python over Go or C. No reason to not have your cake and eat it too.
Why would the development team make replacement packages rather than fixing underlying implementation, for example imp and importlib.
There was also no sugar added to support this mangled jungle gym of package replacements. Backwards compatibility is a thing of dreams for the python developer.
This is only one of many of the problems with the change.
That should be past tense, "got" as the Python community has certainly learned its lesson. Luckily it wasn't as bad a mistake as the Perl folks made.
Evidence of that to me would be a proposed fix and maybe I'm too out of touch with what's happening in the python world but from what I see the two main version still co-exist rather than that any attempt at unification has been made. Am I missing something major here? My understanding is that you migrate your project to 3.x or you're stuck in the past.
> Luckily it wasn't as bad a mistake as the Perl folks made.
That's up for debate.
I loved the way I could use python to quickly prototype some GUI based program, but I don't love it that much over that I can't write the same program in a wide choice of different languages with other ideas about long term stability.
-----------------------------------------
On the final technical destination implied by Unicode:
The final technical destination implied by the Unicode standard is correct handling of "grapheme clusters".[1]
-----------------------------------------
On the half way point at which we've arrived:
In the 80s, there were a bazillion incompatible "character" sets and encodings of those "character" sets. Unicode was a response to this.
The half way point envisaged by the original Unicode design was to firmly establish a single overall "character set" view with a handful of encodings.
Imo we've arrived at this half way point.
-----------------------------------------
On the string types of languages:
Programming languages designed before Unicode emerged adopted the "byte=character" view to determine the character unit of their default string type, leaving higher level views to library code and functions. This is the level Python began at. But the more established Unicode becomes, the more important the higher level views become.
Newer languages have mostly been designed to optimize for Unicode's half way point (but not the eventual destination). They typically support the byte view in some form but adopt the "codepoint=character" view to determine the character unit of their default string type. Aiui, this is where Python 3 is at.
A handful of newer languages continue to support the byte and codepoint views in some form but have adopted the highest level "grapheme=character" view for the character unit of their default string type. I think the most visible new language that's been forward-thinking enough to adopt the final destination view (grapheme=character) is Swift.
-----------------------------------------
[1] Folks trying to understand this point should find it helpful to start with the deceptively brief hint inherent in http://www.unicode.org/glossary/#Grapheme which defines "what a user thinks of as a character".
Next, I'll quote the perluniintro[2] document:
> A Unicode logical "character" can actually consist of more than one internal actual "character" or code point. For Western languages, this is adequately modelled by a base character (like LATIN CAPITAL LETTER A ) followed by one or more modifiers (like COMBINING ACUTE ACCENT ). This sequence of base character and modifiers is called a combining character sequence. Some non-western languages require more complicated models, so Unicode created the grapheme cluster concept, which was later further refined into the extended grapheme cluster.
The present mess will - if not resolved in a much more drastic fashion - cause more and more teams to switch away from python. It's a real waste of the potential that python had (and still has).
I never even bothered porting my code, I'm 'stuck' on 2.7 and anything new gets written in another language. Even bloody PHP, the language everybody loves to hate on, gets deprecation and backwards compatibility better than python.