
My perspective on the recent language changes to Python - coleifer
http://charlesleifer.com/blog/what-happened/
======
jasonpeacock
The article presents a blatant strawman argument against Python 3's language
by using advanced language features to claim it's no longer simple nor
suitable for beginners.

Just don't use the advanced features if you don't need them, the core language
is the same as Python 2 which the author lauds as being wonderful.

~~~
coleifer
See my response to your "blatant" strawman (ignore the language changes):
[https://news.ycombinator.com/item?id=13671609](https://news.ycombinator.com/item?id=13671609)

------
notacoward
This is similar to how I feel. Sometimes I tell people I'm a Python 1.5 guy,
because that's the version I started with. I've since familiarized myself with
list comprehensions, generators, etc. I even use decorators, though I'm still
at the point where I have to find a howto and refresh some of the details each
time. The print and string changes I find annoying, and I haven't gotten to
async/await yet. It's not that I don't understand or appreciate these things,
but they do take away a lot from Python's simplicity and intuitive
readability. Those were _massive_ strengths, so I'm not sure the tradeoff is
worth it. There are already plenty of languages for those who prefer code
which some would call elegant and others (including me) would call obtuse. I
find myself looking more and more at Lua, which seems to embody more of the
early Python spirit than modern Python itself does.

------
gizmo
This article is a little light on substance. Aside from the now mandatory
brackets around print() you can write Python 3 code that is indistinguishable
from Python 2 code. Sure, Python has become more complex and the standard
library has grown substantially, but using Python for one-off scripts is as
easy as it has ever been.

------
amyjess
If you don't want to deal with async stuff... then just don't use it. In the
last week or two, I started a new personal project in Python, one where I
decided from the outset to take full advantage of 3.6, and I don't have a
single async, await, import asyncio, or @asyncio.coroutine anywhere in my
code. It's not the kind of code I want to write, so I don't write it. Instead,
I'm happy with f-strings and the ability to union dicts together [0].

I do agree though that the type annotations hurt the overall austere
laconicity of Python code. I don't use them myself, and I'm lucky that I don't
have to read through anyone else's code that uses them, so it's not quite a
big deal (yet).

f-strings alone have made me not want to go back to any older version.

    
    
        [0] {**foo, **bar} # where foo and bar are both dicts; introduced in Python 3.5

~~~
coleifer
I use a lot of software written by other people. I need to, in many cases,
read and understand that software. So pretending it doesn't exist is fine for
personal, small projects, but doesn't seem as realistic in my day-to-day work.

Also, this post wasn't about every little feature in Python 3. It was about 2
features that, I feel, make python as a language less pythonic.

~~~
polotics
this article is not good. in particular the way type annotations are lambasted
is very weak

~~~
coleifer
Fair enough

------
lotsoflumens
I think that I'll have to agree mostly with article.

At first I thought async/await would be a good feature, but after studying it
a bit more and trying to use it in a real project, I've become very
disappointed. There was really no need to add new keywords to the language. It
could have been more transparent like generators (it's a generator if it has a
yield).

And, the implementation of coroutines as a syntactic sugar on top of
generators is like buying an SUV and finding out later that it's a minivan
chassis with bigger wheels.

