Transcripts complete for async course.

Author: mikeckennedy

transcripts/01-welcome/1-intro-to-the-course.txt

@@ -0,0 +1,34 @@
+00:00 Hello and welcome to Asynchronus
+00:02 Techniques and Examples in Python.
+00:04 In this course, we're going to explore the entire
+00:06 spectrum of asynchronous programming in Python.
+00:09 This means threads, this means subprocesses
+00:13 the fancy new asyncio and the async and await keywords.
+00:17 All of that and much, much more.
+00:19 I hope you're excited about digging into it
+00:21 because I'm super excited to share it with you.
+00:24 Now before we get into the details of what we're going to
+00:25 cover, let's talk really briefly about
+00:27 what asynchronous programming is.
+00:31 If we go and look at Wikipedia it'll say
+00:33 asynchrony and computer programming refers the
+00:35 occurrence of events independent of the main
+00:37 program flow and way of dealing with such events.
+00:41 These may be outside events such as the arrival
+00:44 of signals or actions started by the program
+00:46 without blocking or waiting for results.
+00:49 Now what's really important about this statement
+00:51 is it doesn't say asynchronous programming is
+00:54 you create threads and then you join on them
+00:57 or you create other processes and wait for
+00:59 them to finish or get back to you.
+01:01 It just says stuff happening at the same time.
+01:05 So we're going to look at many different ways
+01:07 in fact we're going to explore three very
+01:09 different approaches that Python can
+01:11 take to this: threads, processes, and asyncio.
+01:16 We're going to explore more than that of course.
+01:18 But there's actually a lot of ways in which
+01:19 asynchrony can be achieved in Python and knowing
+01:23 when to choose one over the other is super important.
+01:25 We're going to talk all about that.

transcripts/01-welcome/2-async-for-hardware.txt

@@ -0,0 +1,47 @@
+00:00 Here's a graph we're going to come back to
+00:01 and analyze at great depth later in the course.
+00:05 It came from a presentation by Jeffrey Funk.
+00:07 You can see the SlideShare link there
+00:09 if you want to go check it out.
+00:10 It's actually 172 slides.
+00:12 I want to just call your attention to this graph around 2005.
+00:16 If you look at, most importantly, the dark blue line
+00:20 that is single-threaded performance over time.
+00:24 Note, it's going up and up and up
+00:25 following Moore's law, that's the top line
+00:27 and then it flattens out
+00:28 and it actually is trending downward.
+00:31 What is going on here?
+00:32 Well, look at the black line.
+00:34 We have the number of cores
+00:35 going from one up to many
+00:38 right around 2005 and continuing on today.
+00:41 To take full advantage of modern hardware
+00:44 you have to target more than one CPU core.
+00:48 The only way to target more than one CPU core
+00:50 is to do stuff in parallel.
+00:52 If we write a regular while loop
+00:54 or some sort of computational thing in regular Python
+00:57 that is serial and it's only going to run on one core
+00:59 and that means it's following that blue downward line.
+01:02 But if we can follow the number
+01:04 of cores growing, well, we can multiply
+01:05 that performance massively, as we'll see.
+01:09 One of the reasons you care about asynchronous programming
+01:12 is if you have anything computational to do
+01:15 that depends on getting done fast
+01:17 not like I'm calling a database
+01:19 or I'm calling a web service and I'm waiting.
+01:20 That's a different type of situation we'll address.
+01:23 But no, I have this math problem
+01:25 or this data analysis problem
+01:26 and I want to do it as fast as possible in modern hardware.
+01:29 You're going to see some of the techniques
+01:31 that we talk about in this course
+01:32 allow us to target the new modern hardware
+01:35 with as much concurrency as needed
+01:37 to take full advantage of all the cores of that hardware.
+01:40 So like I said, we're going to dig way more into this later
+01:43 I just want to set the stage that if you have
+01:45 anything computational and you want to take full advantage
+01:48 of modern hardware, you need asynchronous programming.

transcripts/01-welcome/3-topics-covered.txt

@@ -0,0 +1,117 @@
+00:00 Let's talk about the actual topics
+00:02 that we're going to cover chapter by chapter
+00:04 and how it all fits together.
+00:06 We're going to start digging further into why do we care
+00:09 about async, when should we use it, what are its benefits.
+00:12 So we're going to go way into it so you understand
+00:14 all the ways in which we might use asynchronous programming
+00:16 in Python, and when you might want to do that.
+00:19 Then it's time to start writing some code
+00:21 and making things concrete.
+00:23 We're going to focus first on the new key words introduced
+00:26 in Python 3.5 async and await.
+00:29 Now some courses leave this to the end
+00:31 as the great build-up, but I think you start here.
+00:34 This is the new, powerful way to do threading
+00:37 for anything that is waiting.
+00:39 Are you calling it database?
+00:41 Are you talking to a web service?
+00:42 Are you talking to the file system, things like that?
+00:45 We do these kinds of things all the time in Python
+00:47 and it' really not productive to just block our program
+00:50 while it's happening. We could be doing many other things.
+00:52 And the async and await key words in the asyncio foundation
+00:57 make this super straightforward.
+00:59 It's almost exactly the same programming model
+01:01 as the serial version
+01:03 but it's way more scalable and productive.
+01:06 Next we're going to focus on threads, sticking
+01:08 to making a single process more concurrent
+01:11 doing more at once.
+01:12 We're going to talk about a more traditional way
+01:15 of writing asynchronous code in Python with threads.
+01:18 We'll see sometimes this is super-productive.
+01:21 other times it's not as productive as you might hope
+01:24 especially because of things like the GIL raise its head.
+01:27 And we'll see when and how to deal with that.
+01:29 Some things are well-addressed with threads
+01:31 others not so much.
+01:33 When we start writing multithreaded code
+01:35 or asynchronous code, in general
+01:37 we have to think very carefully
+01:38 about the data structures that we use
+01:41 and making sure that we don't encourage a race conditions
+01:43 or deadlocks.
+01:44 So in this chapter we're going to talk about both of those.
+01:48 How do we prevent race conditions that might allow code
+01:51 to see invalid data or corrupt our data structures?
+01:53 And how do we prevent deadlocks
+01:55 from completely freezing up our program
+01:57 by the improper use of the tools trying
+01:59 to prevent the first?
+02:01 So we're going to talk a lot about thread safety
+02:02 make sure you get that just right.
+02:04 Now Python has two traditional types of parallelism
+02:07 threaded parallelism and process-based parallelism.
+02:10 And the primary reason we have this is because of the GIL.
+02:14 We'll see that threaded-based parallelism
+02:16 is great when you're waiting on things like databases
+02:18 or web calls, things like that.
+02:20 But it's basically useless for computational work.
+02:24 So if you wanta do something computational
+02:27 we're going to have to employ process-based parallelism.
+02:30 We're going to talk about Python's native, multiprocessing
+02:33 process-based parallelism, with tools all around
+02:37 that meant to take a bunch of work
+02:38 and spread it across processes.
+02:40 You'll see that the API for working with threads and the API
+02:43 for working with processes are not the same.
+02:46 But the execution pools are ways to unify these things
+02:50 so that our actual algorithms or actual code depend
+02:53 as little as possible on the APIs
+02:55 for either threads or processes, meaning we can switch
+02:58 between threads or processes depending on what we're doing.
+03:01 So we wanta talk about execution pools
+03:03 and how to unify those two APIs.
+03:07 Then we're going to see two really interesting libraries
+03:11 that take async and await and asyncio and make it better
+03:15 make it easier to fall into the pit of success.
+03:18 You just do the right thing, and it just happens.
+03:21 The way it guides you, things work better.
+03:23 So things like cancellation, parent/child tasks
+03:26 or any mix mode of, say, some IO-boundwork
+03:30 and some CPU boundwork.
+03:32 That can be really tricky, and we'll see some libraries
+03:34 that make it absolutely straightforward and obvious.
+03:37 One of the great places we would like
+03:39 to ply asyncio is on the web.
+03:42 That's a place where we're waiting on databases
+03:44 and other web services all the time.
+03:46 We'll see the traditional, popular frameworks
+03:49 like Django, Flask, Pyramid do not support any form
+03:53 of asynchrony on the web.
+03:55 So we'll take something that is a Flask-like API
+03:58 and adapt it to use asyncio
+04:00 and it's going to be really, really great.
+04:01 We'll see massive performance improvements
+04:03 around our web app there.
+04:05 Finally, we'll see that we can integrate C with Python
+04:09 and, as you know, C can do just about anything.
+04:12 Your operating system is written in C.
+04:14 It can do whatever it wants.
+04:16 So we'll see that C is actually a gateway
+04:18 to a different aspect, different type
+04:21 of parallelism and performance in Python.
+04:23 But we don't wanta write C.
+04:25 Maybe you do, but most people don't want to write C
+04:27 if they're already writing Python.
+04:28 So we'll see that we can use something called Cython
+04:31 to bridge the gap between C and Python
+04:33 and Cython has special key words to unlock C's parallelism
+04:38 in the Python interpreter.
+04:40 It's going to be great.
+04:41 So this is what we're covering during this course
+04:43 and I think it covers the gamut
+04:45 of what Python has to offer for asynchronous programming.
+04:49 There's so much here; I can't wait
+04:51 to get started sharin' it with you.

transcripts/01-welcome/4-student-prereqs.txt

@@ -0,0 +1,19 @@
+00:00 Let's take a moment and just talk really quickly
+00:02 about the prerequisites for this course.
+00:05 What do we assume you know?
+00:06 Well, we basically assume that you know Python.
+00:09 This course is kind of intermediate to advanced course
+00:13 I would say, it's definitely not a beginner course.
+00:15 We run through all sorts of Python constructs
+00:17 classes, functions, keyword arguments, things like that
+00:21 without really explaining them at all.
+00:23 So if you don't know the Python language
+00:25 you're going to find this course a little bit tough.
+00:27 I recommend you take my Python Jumpstart
+00:29 by Building 10 Apps, and then come back
+00:32 and pick this course up.
+00:33 You don't have to be an absolute expert in Python
+00:36 but like I said, if you're brand new to the language
+00:39 take a foundational course first
+00:40 and then come back and dig in
+00:41 to the Asynchronous Programming after that.

transcripts/01-welcome/5-meet-your-instructor.txt

@@ -0,0 +1,21 @@
+00:00 Finally in this chapter, I just want to say hello
+00:02 and thank you for taking my course.
+00:04 My name is Michael Kennedy, find me on Twitter @mkennedy.
+00:08 You may know me from The Talk Python to Me podcast
+00:10 or the Python Bytes podcast.
+00:12 I am the host or co-host on both of those
+00:16 and each of them cover different aspects
+00:18 of asynchronous programming, so for example
+00:20 I've had Nathaniel on to talk about Trio
+00:22 which is one of the libraries we're going to cover.
+00:24 Philip Jones to talk about Quart
+00:26 another thing we're going to use in this course
+00:27 on the Talk Python to Me podcast.
+00:29 You can listen to those interviews.
+00:30 And on the Python Bytes, we highlight all sorts of libraries
+00:33 that are really useful for asynchronous programming.
+00:37 So make sure to check those out if you're interested
+00:38 and I'm also the founder of Talk Python Training.
+00:42 Welcome to my course, it's great to meet you
+00:44 and I'm looking forward to helping you
+00:46 demystify asynchronous programming.

transcripts/09-built-on-asyncio/10-cancellation-with-trio.txt

@@ -0,0 +1,45 @@
+00:00 So we converted from asyncio to Trio
+00:03 and we saw things got simpler this async with block.
+00:06 The nursery concept is quite simple.
+00:08 Let me show you how we can use that
+00:10 for even greater benefit.
+00:11 I talked about cancellation. Now watch this.
+00:14 Let's suppose we want this to run for either
+00:17 five seconds and finish successfully
+00:19 or if it goes past five seconds
+00:20 we're going to cancel all the work.
+00:22 OK, even all the child tasks that maybe
+00:24 those processes themselves kicked off.
+00:27 How'd we do that? It sounds complicated, right?
+00:30 Watch this. With trio.move_on_after, let's say 5.
+00:36 How about that? Let's see what happens here.
+00:39 It should run for a little bit.
+00:40 Do some generating, do some producing, some consuming
+00:43 and then it should cancel.
+00:45 So this line should print out in just about five seconds.
+00:48 Let's find out what happens, it's working, and it's working.
+00:52 Five seconds are past, and boom. We ran out of time. We're done.
+00:57 We canceled them, straight away. How cool is that?
+01:01 So if we make that less work, two, two, and four
+01:04 something like that, should be able to produce
+01:06 all the work and just finish early.
+01:08 No cancellation, 2.42 seconds.
+01:11 But if it takes too long, this cancellation
+01:13 kicks in and off it goes.
+01:15 So these interesting coordination concepts
+01:18 like to have this block only run for so long
+01:21 with some sort of time out, also if this thing kicks off
+01:25 child tasks and then you decide to cancel it or time it out
+01:29 or something like that or this one has an error.
+01:32 Even those get canceled if they're still running.
+01:34 There's really interesting stuff that happens
+01:36 around this behind the scenes that does happen
+01:39 in normal asyncio, definitely doesn't happen
+01:41 in threading or multiprocessing that makes this
+01:44 a really nice coordination framework.
+01:46 And that's Trio, like I said
+01:47 there's actually a lot more to it.
+01:49 You can build really interesting things from the ground up.
+01:51 But I think this is enough to give you
+01:53 some inspiration and some ideas to go explore it
+01:55 if it's useful for you.

transcripts/09-built-on-asyncio/11-trio-concept.txt

@@ -0,0 +1,29 @@
+00:00 Let's review our core concepts around Trio.
+00:02 Trio is independent async await capable
+00:07 library that is entirely independent
+00:09 of Python's built in asyncio library.
+00:12 That whole loop of structure and
+00:14 underlying things has nothing to do with Trio.
+00:17 So Trio is it's own thing from scratch.
+00:19 And the reason it's like that is they want to make
+00:22 sure they have complete control over how stuff
+00:25 executes, the cancellation, the error handling
+00:26 all of those types of things.
+00:29 So here's a general use case, I'd like to go an generate
+00:32 some work and consume some work with the
+00:34 producer consumer style and I want to maybe even
+00:37 let those pieces kick off sub child tasks and so on.
+00:41 And I'd like to either do all the work and finish
+00:43 successfully in five seconds or I want them
+00:46 to be canceled if they have still pending work.
+00:49 So we just create one with block for the move on part
+00:51 that's the time out and then the async with block.
+00:55 One's async, one is not, be careful there.
+00:58 The async with block to open the nursery
+01:00 kick off all the work and either that's going to block
+01:02 until it's finished, it's going to block until
+01:04 you cancel or it's going to block until one of them has an
+01:06 error in which case it'll cancel all the
+01:08 running and not yet started tasks.
+01:12 It's a really simple coordination
+01:13 concept around async work.

transcripts/09-built-on-asyncio/12-trio-async.txt

@@ -0,0 +1,21 @@
+00:00 Before we move on from Trio, I just want to point out
+00:02 Trio-async, and I did throw this out at the beginning
+00:05 when we talked about Trio, but I want to make it super clear
+00:08 if for example, you want to write in Trio
+00:10 but somewhere you want to use, say, aiohttp client
+00:14 we've seen how awesome that is
+00:16 and that's a totally reasonable thing to integrate.
+00:18 Or maybe I want to use the async library
+00:20 that talks to Postgres.
+00:21 Well, for sure, the aiohttp client will not work
+00:25 inside of Trio's async methods.
+00:28 You'll get some kind of error that it's not
+00:30 the right kind of event loop.
+00:31 It's not an asyncio event loop, it's a Trio event loop
+00:33 and they can't deal with each other.
+00:35 If you want to use those libraries in code
+00:38 that you write based on Trio, you have to use this library
+00:42 to create adapting a layer of asyncio event loop
+00:46 over the Trio's event loop.
+00:48 Just be aware that you're going to this if you want to use
+00:51 any external libraries that are built on top of asyncio.

transcripts/09-built-on-asyncio/7-trio-intro.txt

@@ -0,0 +1,22 @@
+00:00 The next extra library that we're going to
+00:03 look at that builds on asyncio and makes it better
+00:06 and easier and simpler is Trio.
+00:08 Trio's goal is to produce a production quality, permissively
+00:11 licensed async and await native io library for Python.
+00:15 So it has a bunch of things for work with networks
+00:20 and so on, but it also has really great support for just
+00:21 coordinating anything built on top of asyncio itself.
+00:25 So where Trio really shines is it tries to focus
+00:28 on making coordination around asyncio simpler.
+00:32 They want to make it easy to do the best right thing
+00:35 with asyncio, so what's interesting is this is a framework
+00:38 built entirely from the ground up that integrates
+00:40 with async and await, but does not directly use asyncio.
+00:45 So like asyncio.get_event_loop, that is not part of this whole
+00:51 framework, it's something similar and in parallel to that
+00:54 and you actually have to use a bridging library.
+00:57 Something called trio-asyncio in order to actually
+01:00 use things built on the asyncio event loop.
+01:04 I think you'll find Trio an interesting
+01:06 library that could work for certain circumstances
+01:09 and types of apps you're building.

transcripts/09-built-on-asyncio/8-trio-app-intro.txt

@@ -0,0 +1,33 @@
+00:00 Our goal with Trio here is
+00:01 to take something we've already done
+00:04 and make it simpler
+00:05 and actually make it do even more
+00:07 without any complications at all.
+00:10 You guys remember the producer-consumer,
+00:12 here we are again.
+00:13 It's a simple application
+00:14 and there's a really nice example
+00:16 I can show you here with Trio.
+00:18 So, here's the synchronous version, we've seen that.
+00:21 We've taken the synchronous version
+00:22 and we've upgraded it to use asynch I/O.
+00:25 So, we get the event loop.
+00:27 We create all the tasks.
+00:29 We turn them into a single task.
+00:30 We wait for them to run.
+00:31 This is okay.
+00:32 One of the things we didn't really talk about
+00:34 is cancellation.
+00:35 What if we're going to say,
+00:36 run this and if the user chooses to cancel,
+00:39 or we're willing to wait,
+00:40 say up to five seconds but not longer,
+00:42 then we're going to bail
+00:44 and cancel all the tasks and things like that.
+00:45 So, we'll see that with Trio
+00:47 this more advanced scenario becomes super easy.
+00:49 But our first job is we're going to take this app
+00:52 and we're going to convert it to use Trio,
+00:54 and a little bit like unsync,
+00:55 you're going to see that some of the challenges
+00:58 and ugly hoops you have to jump through just go away.