Python 3.0 changes have been defined “arbitrary and academic“, for no real use for real programmers. Before starting to talk about python changes, I would think about the meaning of “real programmers” in the sentence before.
How would we define a “real programmer”?
- Are hackers “real programmers”?
- Are professors of language theory “real programmers”?
- Are experts in algorithm theory “real programmers”?
- Are people who do coding for a living “real programmers”?
Probably people inside the first definition didn’t mind a lot about how Python 2.x did things and could live with it. They will just be angry because suddenly they tools and scripts will stop working. But those people can also go on with Python 2.x as they don’t tend to have complex software maintainment processes and would probably just be happy having a way to run it.
People inside the second and third definition will probably be happier as Python 3.0 clean up will satisfy their concept of elegance a bit more.
People inside the fourth definition will probably be angry thinking of how many hours they will have to spend porting their code to Python 3.0 as their code probably will have to live for the next 5 years as hundred of customers will have to use it.
This might be right, but I think that we have to go deeper inside the question to really understand the effect of those changes. I actually do code for a living, and inside the majority of our projects we try to refactor often to make long time maintaining of the code as easy as possible. As us, there will probably be hundreds of other companies who often perform refactoring, and all of us do it for one common goal: “Keeping the code as simple as possible to make it clear and obvious even after years”.
Usually this means things like:
- converting strange behaviours to standard one inside the application domain
- converting spread values to constants with a meaning
- removing code duplicates to have only one unit of work
- change function and classes to make their role as simple to understand as possible
- Separate mixed code blocks in methods/classes with a clear scope
- and things like that…
Uhm, wait for a second… isn’t this exactly what Python is doing for the 3.0 release?
- They changed the print keyword to a standard function conforming it to the behaviour of any other function inside the language.
- They removed some of the duplicated modules like urllib and urllib2
- They took care of modules that did the same things trying to localize everything in only one clear place
- They moved things inside more clear namespaces instead of having them all mixed in the global one
- They removed old modules superseded by new one that still where available.
- They renamed some things to make them conformed to python conventions.
In the end they actually forced us to perform refactoring of our own projects refactoring a piece of our projects: “the underlying library and language”. This is just the same thing that happens everyday with self written libraries that you reuse in multiple projects inside your company.
But if thousand of people are performing refactoring everyday on things from which their lives depend on, if Google is accepting Python 3.0 when most of their business uses Python (and they also hired Guido so they could probably influence Python 3.0 development a lot if they wanted) how can it be such a bad thing?
I’m starting to think that people blaming python for its changes are mostly angry because they have been forced to perform refactoring when they didn’t want to or just saw their software stop working. But actually you don’t have to change things, your software didn’t stop working and Python 2.x will be maintained for at least one year. You have the choice to do what you want.
As for me I’ll probably just thank the Python team for refactoring libraries and things that I use everyday without asking me to pay a thing. And I’ll just perform migration to 3.0 of my projects using 2to3 tool and something that I already perform everyday: code refactoring…