Most of the transcripts for the videos.

Author: mikeckennedy

transcripts/02-setup/1-do-you-have-python3.txt

@@ -0,0 +1,42 @@
+00:00 In this short chapter, we're going to talk about
+00:01 setting up your computer so that you can follow along.
+00:04 Do you have the right version of Python?
+00:06 What editors are you going to use?
+00:08 Can you get the source code
+00:09 to get started on some of the examples?
+00:11 Things like that.
+00:12 Obviously this is a Python course
+00:14 so you're going to need Python.
+00:16 But, in particular, you need Python 3.5 or higher.
+00:21 Now I would recommend the latest, Python 3.7.
+00:24 Maybe you're on a Linux machine, and it
+00:25 auto-updates as part of the OS, and that's probably 3.6.
+00:29 But you absolutely must have Python 3.5
+00:32 because that's when some of the primary
+00:34 async language features were introduced
+00:37 namely, the async and await keywords.
+00:41 Do you have Python, and if you do, what version?
+00:44 Well, the way you answer that question varies by OS.
+00:47 If you are on Mac or you're on Linux
+00:49 you just type 'python3 -V'
+00:52 and it will show you the Python version.
+00:54 In this screenshot, I had Python 3.6.5
+00:56 but in fact, 3.7 is out now
+00:57 so you might as well go ahead and use that one.
+01:00 But if you type this and you get
+01:01 an answer like 3.5 or above, you're good.
+01:04 If it errors out, you probably don't have Python.
+01:07 I'll talk about how to get it in a sec.
+01:09 Windows, it's a little less straightforward.
+01:12 You can type 'where python'
+01:14 and the reason you want to do that is
+01:16 there's not a way to target Python 3 in particular
+01:18 it just happens to be the first python.exe
+01:21 that lands in your path.
+01:23 So by typing 'where' you can see all the places
+01:25 and down here you can see I typed 'python -V' again
+01:27 same command but without the '3'
+01:29 and I got Python 3.6.5, the Anaconda version.
+01:32 That would be fine for this course
+01:34 Anaconda's distribution should be totally fine.
+01:37 But, again, has to be 3.5 or above.

transcripts/02-setup/2-getting-python-3.txt

@@ -0,0 +1,18 @@
+00:00 If you don't have Python
+00:01 or you have an older version of Python
+00:03 or you would just like to get a newer version of Python
+00:05 yes, you can go to python.org and download it
+00:08 but I recommend that you check out Real Python's article
+00:11 on installing and managing and upgrading Python.
+00:14 So just visit realpython.com/installing-python
+00:18 and check it out.
+00:19 The guys over there are putting lots of effort
+00:20 into keeping this up to date.
+00:22 For example, one of the ways you might want
+00:23 to install it on Mac OS would be to use Homebrew
+00:27 and that's different than what you get off of python.org.
+00:29 It let's you upgrade it a little more easily.
+00:31 That's the way I'm doing it these days
+00:32 and really liking it so far.
+00:34 So this article will help you find the best way
+00:36 to install it on your OS.

transcripts/02-setup/3-recommended-editor.txt

@@ -0,0 +1,24 @@
+00:00 In this course like most of our courses
+00:02 I'm going to be using PyCharm.
+00:04 Now you don't have to use exactly the same editor.
+00:06 You can use Visual Studio Code with a Python plug-in.
+00:09 You can use Emacs. You can use Vim.
+00:11 Whatever makes you happy.
+00:12 But if you want to follow along exactly.
+00:15 Then I recommend you use Pycharm.
+00:16 Now almost all of this course can be done
+00:18 in the Community Edition, the free edition of PyCharm.
+00:22 There is one chapter on web development.
+00:24 Maybe it's a little bit easier with PyCharm Pro
+00:27 but because we're not really working with CSS, JavaScript
+00:30 the template, anything like that
+00:32 I think you could actually use PyCharm Community Edition
+00:34 for the entire course. So if you want to use that
+00:38 just visit jetbrains.com/pycharm.
+00:41 Get it installed and I'll show you
+00:42 how to use it along the way.
+00:43 If you want to use something else, like I said, no problem
+00:45 use what makes you happy.
+00:47 Just be aware this is the one we're using
+00:48 so you have to adapt your editor and waverunning code
+00:51 to what we have over here.

transcripts/02-setup/4-hardware-requirements.txt

@@ -0,0 +1,32 @@
+00:00 You might consider what hardware
+00:02 you're taking this course on.
+00:03 Most of the time, the courses we have
+00:06 it doesn't matter what you're running on.
+00:07 You could probably take many of the courses
+00:09 we have on here, on say like, a Raspberry Pi
+00:12 or something completely small and silly like that.
+00:15 However, on this one
+00:17 you really need to have at least two cores.
+00:20 If you don't have two cores, you're not going to be able
+00:22 to observe some of the performance benefits
+00:25 that we talk about.
+00:27 So here's my machine, I have a MacBook Professional
+00:29 15 inch, 2018 edition with the Core i9
+00:33 which you can see 12 cores here.
+00:35 Six real cores, each of them hyper thread.
+00:37 So it appears as 12 to the operating system.
+00:40 But this system will really let us see a difference
+00:43 from when we're running on single threaded mode
+00:45 to parallel mode that actually takes advantage
+00:47 of all of the processors.
+00:49 But you don't have to have 12 cores.
+00:51 If you have two or four
+00:52 that will already let you see a difference
+00:54 but the more the better for this course
+00:57 because when we get to the performance section
+00:59 in particular, the CPU bound type of stuff
+01:02 we're trying to take advantage of the CPU
+01:04 you'll just see a bigger benefit, the more cores you have.
+01:07 So at least dual core is not required
+01:10 but to see some of the benefits
+01:11 you have to have more than one core.

transcripts/02-setup/5-get-the-source.txt

@@ -0,0 +1,29 @@
+00:00 Every single thing you see me type in this course
+00:02 will be available to you in GitHub.
+00:04 Before you go farther, pause the video and go over to
+00:07 GitHub.com/talkPython/async-techniques-python-course
+00:12 You can also just click the link to this GitHub
+00:15 repo in your course details page.
+00:18 You want to make sure you get access to this
+00:20 and go over there and star
+00:21 and consider forking it as well.
+00:23 That way you have a copy of exactly
+00:25 we're working with during this course.
+00:26 I encourage you to play around and write some code
+00:29 and try out the ideas from each chapter
+00:31 as we get to them.
+00:33 Most of the chapters have a starting and
+00:35 final version of code.
+00:37 So if you wanted to take, say, a serial
+00:40 single threaded computational little app
+00:42 that we build, and convert it to
+00:44 threads and convert it to
+00:45 multiprocessing, and things like that
+00:47 you'll have a copy over here on GitHub.
+00:49 So just be sure to star this, and
+00:51 consider forking it. Definitely check it out so
+00:53 you have access to it. If you don't do Git
+00:56 and that's fine, just click where it says
+00:58 clone or download, and
+00:59 download a zip, and then you'll have the
+01:00 source, as well.

transcripts/03-why-async/01-async-for-speed.txt

@@ -0,0 +1,74 @@
+00:00 Let's begin our exploration of async by taking
+00:02 a really high-level view, we're going to look
+00:05 at the overall async landscape, some of the particulars
+00:09 about working with async in concurrent programming
+00:11 in Python, and the two main reasons that you care
+00:14 about asynchronous programming.
+00:16 In this first video we're going to focus on async for speed or
+00:20 for performance, the other main reason you might care
+00:23 about asynchronous programming or concurrent code would be
+00:26 for scalability, doing more at once.
+00:29 Right now we're going to focus on doing things faster
+00:32 for an individual series of computations.
+00:35 Later we're going to talk about scalability
+00:37 say for web apps and things like that.
+00:39 Let's look at some really interesting trends that have
+00:43 happened across CPUs in the last 10 years or so, 15 years.
+00:47 So here's a really great presentation by Jeffrey Funk
+00:50 over on SlideShare and I put the URL at the bottom
+00:52 you can look through the whole thing, you can see there's
+00:54 172 slides, but here I am pulling up one graphic that
+00:57 he highlights, because it's really, really interesting.
+01:01 See that very top line, that red line, that says
+01:03 transistors in the thousands, that is Moore's Law.
+01:07 Moore's Law said the number of transistors in a CPU
+01:11 will double every 18 months and that is surprisingly
+01:15 still accurate; look at that, from 1975 to 2015
+01:19 extrapolate a little bit, but still basically doubling
+01:23 just as they said.
+01:25 However people have often, at least in the early days
+01:28 thought of Moore's Law more as a performance thing
+01:31 as the transistors doubled, here you can see
+01:33 the green line "clock speed" and the blue line "single threaded
+01:37 performance" very much follow along with Moore's Law.
+01:40 So we've thought about Moore's Law means computers get
+01:44 twice as fast every 18 months and that was true more or less
+01:48 for a while, but notice right around 2008, around 2005
+01:53 it starts to slow and around 2008 that flattens off and
+01:57 maybe even goes down for some of these CPUs and
+02:00 the reason is we're getting smaller and smaller and smaller
+02:03 circuits on chips down to where they're basically
+02:05 at the point of you can't make them any smaller, you can't
+02:08 get them much closer both for thermal reasons and
+02:12 for pure interference reasons.
+02:14 You can notice around 2005 onward, CPUs are not getting
+02:19 faster, not really at all. I mean, you think back
+02:22 quite a bit and the speed of the CPU I have now is
+02:24 I have a really high-end one, it's a little bit faster but
+02:28 nothing like what Moore's Law would have predicted.
+02:30 So what is the take away?
+02:31 What is the important thing about this graphic?
+02:34 Why is Moore's Law still effective?
+02:37 Why are computers still getting faster, but the CPU and
+02:40 clock speed, really performance speed, single-threaded
+02:43 performance speed, is not getting faster, if anything
+02:45 it might be slowing down a little.
+02:47 Well that brings up to the interesting black graph
+02:50 at the bottom, for so long this was one core and
+02:53 then when we started getting dual-core systems and
+02:56 more and more CPUs, so instead of making the individual
+03:00 CPU core faster and faster by adding more transistors
+03:03 what we're doing is just adding more cores.
+03:05 If we want to continue to follow Moore's Law
+03:08 if we want to continue to take full advantage of the
+03:11 processors that are being created these days
+03:14 we have to write multi-threaded code.
+03:17 If we write single-threaded code, you can see it's either
+03:19 flat, stagnant, or maybe even going down over time.
+03:23 So we don't want our code to get slower, we want our code to
+03:26 keep up and take full advantage of the CPU it's running on
+03:29 and that requires us to write multi-threaded code.
+03:32 Turns out Python has some extra challenges, but
+03:35 in this course we will learn how to absolutely take
+03:38 full advantage of the multi-core systems that
+03:40 you're probably running on right now.

transcripts/03-why-async/02-demo-async-for-speed.txt

@@ -0,0 +1,81 @@
+00:00 Let's look at a real world example
+00:01 of a Python programming that is doing a very poor job
+00:05 taking advantage of the CPU it's running on.
+00:08 I'm running on my MacBook that I discussed
+00:10 in the opening, has 12 cores.
+00:13 This is the Intel i9 12 core maxed out
+00:18 you know, all nobs to 11 type of CPU
+00:20 for my MacBook Pro, here, so you can see
+00:22 it has a lot of processors. It has a lot of cores.
+00:27 In particular, has 12 hyper-threaded cores
+00:29 so six real cores, each one of which is hyper-threaded.
+00:34 Here we have a program running in the background
+00:35 working as hard as it can.
+00:37 How much CPU is the entire computer using? Well, 9.5%.
+00:43 If this were 10 years ago, on single core systems
+00:46 the CPU usage would be 100% but you can see
+00:49 most of those cores are dark, they're doing nothing
+00:53 they're just sitting there.
+00:54 That's because our code is written
+00:56 in a single-threaded way.
+00:58 It can't go any faster.
+00:59 Let's just look at that in action real quick.
+01:01 Now, this graph, this cool graph
+01:03 showing the 12 CPUs and stuff
+01:05 this comes from a program called Process Explorer
+01:09 which is a free program for Windows.
+01:10 I'm on my Mac, so I'll show you something
+01:12 not nearly as good but I really wanted to show you
+01:14 this graph because I think it brings home
+01:16 just how underutilized this system is.
+01:19 So let's go over here and we're going to run
+01:22 a performance or system monitoring tool
+01:25 actually built in Python
+01:26 which is pretty cool in and of itself, called Glances.
+01:29 So we're sorting by CPU usage, we're showing what's going on.
+01:33 We had a little Python running there, actually
+01:35 for a second, running probably in PyCharm
+01:37 which is just hanging out, but you can see the system
+01:39 is not really doing a whole lot, it is recording.
+01:41 Camtasia's doing a lot of work to record the screen
+01:43 so you have to sort of factor that out.
+01:46 Now, let's go over here and create another screen
+01:50 notice right here we have 12 cores.
+01:52 Okay, so if we run PtPython, which is a nicer REPL
+01:57 but just Python, and we write an incredibly simple program
+02:00 that's going to just hammer the CPU.
+02:03 Say x = 1, and then while true: x += 1.
+02:09 So we're just going to increment this, over and over and over.
+02:12 I'm going to hit go, you should see Python jump up here
+02:16 and just consume 100% of one core.
+02:19 This column here is actually measuring in
+02:24 single core consumption whereas this
+02:27 is the overall 12 core bit.
+02:31 Here it's working as hard as it can.
+02:33 You'll see Python'll jump up there in a second.
+02:37 Okay, so Python is working as hard as it can, 99.8%
+02:41 running out of my brew installed Python, there.
+02:44 But the overall CP usage, including screen recording
+02:48 on this whole system?
+02:50 11%, and of course as we discussed, that's because our code
+02:53 we wrote in the REPL, it only uses
+02:55 one thread, only one thread of concurrent execution
+02:59 that means the best we could ever possibly get is 1/12%.
+03:04 8.3% is the best we could ever do
+03:07 in terms of taking advantage of this computer
+03:10 unless we leverage the async capabilities
+03:12 that we're going to discuss in this course.
+03:14 So if you want to take advantage of modern hardware
+03:17 with multiple cores, the more cores the more demanding
+03:21 or more pressing this desire is
+03:24 you have to write concurrent multi-threaded code.
+03:27 Of course, we're going to see a variety of ways to do this
+03:29 both for I/O bound and, like this, CPU bound work
+03:33 and you handle those differently in Python
+03:35 which is not always true for other languages
+03:37 but it is true for Python.
+03:38 And by the end of this course, you'll know
+03:41 several ways to make, maybe not this simple, simple program
+03:45 but to make your Python program doing real computation
+03:48 push that up to nearly 100% so it's fully taking advantage
+03:52 of the CPU capabilities available to it.