On 30 April 2015 at 02:52, Nick Coghlan firstname.lastname@example.org wrote:
This request isn't about understanding the implementation details, it's about understanding what Python *users* will gain from the PEP without *needing* to understand the implementation details.
For that, I'd like to see some not-completely-trivial example code in (or at least linked from) the PEP written using:
- trollius (no "yield from", Python 2 compatible, akin to Twisted's
- asyncio/tulip ("yield from", Python 3.3+ compatible)
- PEP 492 (async/await, Python 3.5+ only)
The *intent* of PEP 492, like PEP 380 and PEP 342 before it, is "make asynchronous programming in Python easier". I think it will actually succeed in that goal, but I don't think it currently does an especially job of explaining that to folks that aren't both already deeply invested in the explicitly asynchronous programming model *and* thoroughly aware of the fact that most of us need asynchronous programming to look as much like synchronous programming as possible in order for it to fit our brains.
I agree 100% on this. As things stand, it feels as though asyncio feels frighteningly complex for anyone who isn't deeply involved with it (it certainly does to me). The current PEP feels to an outsider as if it is solving problems that are specialist and to the average (non-asyncio) programmer add language complexity with no real benefit.
It's not specific to PEP 492, but what I would like to see is:
1. More tutorial level examples of how to use asyncio. Specifically *not* examples of how to write web services, or how to do async web requests in your existing async program. Instead, how to integrate asyncio into generally non-async code. For example, looking at pip, I see a few places where I can anticipate asyncio might be useful - the link-chasing code, the package download code, and the code to run setup.py in a subprocess, seem like places where we could do stuff in an async manner (it's not a big enough deal that we've ever used threads, so I doubt we'd want to use asyncio either in practice, but they are certainly the *types* of code I see as benefitting from async).
2. Following on from this, how do I isolate async code from the rest of my program (i.e. I don't want to have to rewrite my whole program around an event loop just to run a bunch of background programs in parallel)?
3. Clarification on the roles of async/await vs yield from/generator.send. Are they both useful, and if so in what contexts (ignoring "if you want to support Python 3.4" compatibility cases)? How should a programmer choose which is appropriate?
4. A much better explanation of *when* any of the async constructs are appropriate at all. The name "asyncio" implies IO, and all of the examples further tend to imply "sockets". So the immediate impression is that only socket programmers and people writing network protocols should care.
Of course, if asyncio and the PEP *are* only really relevant to network protocols, then my impressions are actually correct and I should drop out of the discussion. But if that's the case, it seems like a lot of language change for a relatively specialist use case.