feat: include async intro

Signed-off-by: Henry Schreiner <henryschreineriii@gmail.com>

Author: henryiii

content/week11/concepts.md

@@ -148,3 +148,35 @@ Then you may need "shared" memory. This might be the default for
 threading/async, but is required for multiprocessing and subinterpreters. This
 is not an option if you are running on multiple machines; then you must transfer
 serialized objects instead. See the examples in the distributed section.
+
+## Event loop
+
+One common design for a reactive program is an event loop, where the program is
+designed around a central loop, and it reacts to input. This is common with
+async programming, but is also used by things like older GUI toolkits without
+async, as well. Let's try creating our own from scratch using generators:
+
+```{literalinclude} conceptsexample/eventloop.py
+
+```
+
+In this example, we start with tasks, and loop over them. Each task returns an
+estimate of how long it will take. If you were to use one task within another
+task, you would need `yield from` for the inner task. The loop waits for the
+shortest task to be ready, then tries again. It's basic, but the idea is there.
+
+We are using the generator system in Python (asyncio was built originally using
+it), but we could have implemented it with the async special methods instead; it
+would have been more verbose (since those weren't really designed to be hand
+implemented simply), but is quite doable.
+
+Let's try the same thing with asyncio:
+
+```{literalinclude} conceptsexample/asyncloop.py
+
+```
+
+We don't sort the output here, but otherwise, it runs about the same, and takes
+the same total amount of time. The difference here is we using a pre-existing
+awaitable (sleep), so we have to use `await`, which is really just `yield from`
+but using the async-named special methods.

content/week11/conceptsexample/asyncloop.py

@@ -0,0 +1,14 @@
+import asyncio
+
+
+async def sleep(t):
+    await asyncio.sleep(t)
+    return f"Sleep {t} over"
+
+
+async def main():
+    results = await asyncio.gather(sleep(3), sleep(2), sleep(1), sleep(4))
+    print(results)
+
+
+asyncio.run(main())

content/week11/conceptsexample/eventloop.py

@@ -0,0 +1,31 @@
+import time
+
+
+class NotReady(float):
+    pass
+
+
+def event_loop(tasks):
+    while tasks:  # Stops when all tasks are done
+        waits = []
+        for task in tasks:
+            try:
+                res = task.send(None)  # async function runs here
+                if isinstance(res, NotReady):
+                    waits.append(res)  # Build up all the requested waits
+                else:
+                    yield res  # Produce result
+            except StopIteration:
+                tasks.remove(task)  # Task done, remove from tasks
+        if waits:
+            time.sleep(min(waits))  # Wait for the shortest requested wait
+
+
+def sleep(t):
+    endtime = time.time() + t
+    while time.time() < endtime:
+        yield NotReady(endtime - time.time())
+    yield f"Sleep {t} over"
+
+
+print(*event_loop([sleep(3), sleep(2), sleep(1), sleep(4)]), sep="\n")