Hey everyone, I hope this is the right mlist to post my question to. If not, please redirect me to the correct one. I recently tried async for websockets. Here's the question: Looking at the following code, is there a better way to do it? I personally find it much too much code for its purpose. Yet I cannot think of an improvement because I am not used to the usual patterns in async programming. What I find especially annoying is the boilerplate code regarding the renewal of the consumed task object (initializing with None, picking the last one or create a new one, resetting to None, repeat). If, due to the boilerplate, the intent is not clear, there are two endlessly producing coroutines ("queue" & "receive") from which is being read and reacted to, whatever comes first. notify_task = None event_task = None while True: notify_task = notify_task or asyncio.Task(queue.get()) event_task = event_task or asyncio.Task(receive()) done, pending = await asyncio.wait([notify_task, event_task], return_when=asyncio.FIRST_COMPLETED) if notify_task in done: notify = notify_task.result() notify_task = None await handle_notify(scope, send, notify) if event_task in done: event = event_task.result() event_task = None if await handle_ws_default_protocol(scope, send, event, conn, listen_callback): break Why am I asking? Because a friend of mine also was a bit puzzled that this "select.select"-type of programming is so verbose in async or if we were just missing a crucial element. Cheers and thanks you in advance for any answer, Sven PS: What's the history of this code? Reading different tutorials, both queues are discussed and implemented separately (one is websocket, the other one is a message broker). Either code examples were quiet small. But as soon as you want to plug both together, the resulting code suddenly explodes and requires a lot of manual handling as shown above. At least from my perception of "manual". I do not blame these tutorials as they focus on either problem separately. Still in real-world projects, different concepts frequently need to be combined to make the whole idea work. It took me quite some time to find a way to do it. The result above, I find it neither readable nor explainable to other async-noobs like me. Especially "asyncio.wait" was quite hidden in the library (and from google) and it took me many iterations to understand how to interact with it properly (although the obvious API is quite simple).