Even if you got to attend PyCon, there were just too many great talks to go and attend them all.
Luckily, our friends at the PSF were on top of publishing the videos online for the whole world
to watch for free. On this episode, we'll meet up with Brett Slacken and replay his path through
PyCon. We talk about his top 10 favorite sessions from PyCon 2017. This is Talk Python to Me,
episode 116, recorded May 31, 2017.
Welcome to Talk Python to Me, a weekly podcast on Python, the language, the libraries, the
ecosystem, and the personalities. This is your host, Michael Kennedy. Follow me on Twitter
where I'm @mkennedy. Keep up with the show and listen to past episodes at talkpython.fm
and follow the show on Twitter via at Talk Python.
This episode is brought to you by Rollbar and CodeChip. Be sure to check out what they're
offering during their segments. It really helps support the show.
Brett, welcome back to Talk Python.
Thanks for having me.
Yeah, it's always a pleasure. We had a really nice time last, almost two years ago on episode
25. And now we're back to talk about PyCon.
Yeah, it's been a long time. I can't believe it's been that long. A lot of good episodes
between.
Yeah, thanks. It really has been a long time. So we talked a little bit before PyCon about
another show together. And you had this great idea of like, hey, we're both going to PyCon. Let's kind
of do a like a PyCon roundup and go through the talks mostly that you went to because I was,
you know, happily stuck in my booth talking to people. So I didn't get to that many talks. But
nonetheless, they're all on YouTube. So everyone listening can watch it even if they didn't go
to PyCon, right?
Yeah, definitely. And that's, you know, PyCon is a great conference for that reason is that on the
second day while you're there, they're already uploading talks from the first day.
So you can even watch some of the talks you missed yesterday. So you can talk to other
people about those talks while you're still at the conference, which is just really amazing that
they yeah, yeah, it's really amazing how quickly they come up and the quality, because going there
really is a bit of a paradox of choice.
Oh, yeah. And they actually set it up to be that way. Like they'll put all of the best talks,
quote unquote, best from the speakers that are, you know, most well known for the quality of their
talks, they put them at the same time. So you can't possibly go to all of the best,
quote unquote, best talks, you have to go and try different things out and see ones from new
speakers with different kind of fields of discipline and stuff like that. So it's, that's a big part of
the fun of being there. And they're able to do that because they know they're all recorded. So people
don't feel like they're missing out.
Yeah, they really do a nice job. So I definitely am looking forward to talking about these eight or
nine talks that we've picked out to discuss. Yeah. But before we do, maybe you know, it's been almost
two years, since you've been on the show, maybe tell people what you do day to day with Python and
things like that. Yeah, sounds good. So I'm a software engineer, still working at Google, I work on a
product called Google surveys. It's a research platform to answer questions, kind of market research and
survey statistics, we can predict elections and that kind of stuff. And we use a lot of Python to do that.
So it's hundreds of 1000s lines of Python, everything from Django looking code on the front
end down to NumPy and statistical functions. And we also use a lot of JavaScript and go and other
things for other pieces of the system. But overall, it's the majority of our code is in Python. And
yeah, that sounds like a fun project to work on. Yeah, it's been great. It's I've been working on it for
many years now. And it just keeps growing. And it's been amazing to see Python grow from you know,
my first commit was, you know, 2000 lines of Python and to have that grow by 100 or 200
times. It's been really remarkable that the language kept working.
It really does grow and stretch pretty well. It's awesome. We'll even talk about some examples
in some of these talks, like for example, with Instagram, right?
Yes, exactly.
So also maybe catch us up on your book. I originally got to know you through
Effective Python, the book that you wrote a little bit before we had you on the show. And I really liked
it. So it's still selling. Are you working on new books? Anything like this?
Yeah, great question. So it's, it ended up getting translated into a bunch of languages. It's doing well.
translated into Chinese, both traditional and simplified, German, Polish, Korean, Portuguese.
So it's been crazy to see Japanese also, versions of the book all over the place in the translations
of the word of, you know, the words Effective Python and all these other languages. So it's been doing
really well. Weird tweets and other languages that I don't know and translate doesn't really capture
programming jargon very well. So that's interesting trying to find friends of mine who know these
languages to help me understand what people are saying. But do they like the book or what?
Yeah, because it's like dry humor or like a joke about the cover not having a snake on it. You know,
there's like stuff that it's really hard to get through trans automated translation, right?
Yeah, absolutely.
But yeah, so I think I'm looking forward to, you know, everyone's watching the Python death clock of
Python, two, seven death clock of 2020. And so it'll be interesting to see. I think if you know,
if there's another if it's good to have another edition of the book in time for that, because so
much is changing. And I think we'll talk about that today. But no plans yet. I think it's still
material still really good and is up to date.
Yeah, excellent. So people want to check that out. That was episode 25 from a couple years ago.
All right. So yeah, let's let's talk about the talks.
Yeah, you went to PyCon. I went to PyCon. I didn't get a chance to go to that many talks. And honestly,
I find the hallway track to be really quite, quite valuable. You make these connections,
and you can talk to people there that, you know, those aren't recorded. And those won't be,
you can't relive those, right?
Yeah, definitely. And I think they're actually are recording the lightning talks now. But that was,
you know, I think if you went to the conference and just did lightning talks and hallway track,
you'd probably have a really good time.
Yeah, the other place that I spent a lot of time was in the open sessions.
Yeah, that's awesome. Yeah, I didn't get to go to any of those this time.
Yeah, yeah. And those are still not recorded as far as I know.
No, they're not.
It wasn't obvious if they were.
Yeah.
All right, cool. But let's focus on the talks that you went to. And I did go to some of them,
and then also went back and watched the others. All right. So the very, very first talk at PyCon,
the opening keynote was by Jake Vanderplass.
Yeah, and he's a longtime PyCon speaker. I mean, he's been there for many years. And I don't know if
you've seen his other talks before, but he's, you know, he's done tons of them. And he's up at
University of Washington. He's actually an astronomer. That's his job, which is just crazy
that that's someone gets to do that professionally.
So amazing, right?
Yeah. So yeah, I feel very inadequate whenever I hear him like talking about what he does day to
day and the science he does. It's like pretty awesome.
Yeah. A lot of the stuff that they do with Python and astronomy is really fascinating. And what struck
me about this talk, there were a couple of things. And maybe I'll set the stage before I touch on some
of the astronomy stuff.
Sure.
was basically Jake's theme. I think it was a great way to kick off the conference. It was that
the people that you are sitting among these 3000 people and everyone else in the community,
we're all here for Python, but we don't all use Python the same way. And we don't all have the same,
the same jobs, the same type of challenges and so on. So for example, if I sat down to write like a well
structured 50 Python file web application that talks to a database, I'll have one way of thinking and
working with Python. If I have astronomy data, and I want to just explore it dynamically, say in
IPython notebooks or Jupyter or whatever, that's an entirely different way of working with it. And
these different ways of working are an opportunity to learn more and catch Python from a different
perspective.
Yeah, exactly. And he called it, I think, the mosaic of Python, which I really,
I really liked the analogy there. And that's a big part of what's great about going to Python,
or even just watching the talks from it is, you have these people from just very different disciplines
with very different backgrounds, talking about these subjects. So yeah, he really emphasized that
very well.
Yeah, I thought that was a great, great opening message. And it was like, okay, I see that the
people I'm talking to, maybe they really do have not just a different way of working, but a really good
reason to not work the same way that I do. And so I think it kind of opened my eyes a little bit to
appreciating the differences.
Yeah, definitely. And then he walked us through like all of the tools that he uses, or he knows
of in the scientific community, kind of went, walked through like, you know, where they came from. And
it was really interesting to me, because he, the way he actually showed it was in kind of these
concentric circles of dependencies, you know, where at the core, you know, is Python itself, and then
something like NumPy, which is really like a fundamental tool for numerical computation and Python.
But I didn't even realize how many additional layers on top of that there are, you know, in terms
of machine learning or data processing or things specific to astronomy. And, you know, he basically
went off the page with how many concentric circles there are.
Yeah. Yeah.
Here's Python. Here's a bunch of scientific stuff that you may have heard of. Here's a bunch of,
you know, higher level scientific stuff that builds on top of that. Here's all the amazing
things that they're doing at in astronomy on top of that. Oh, and by the way, here's all all of these
amazing satellites that are coming online, that you basically work with them through Python, which is
really, really amazing.
Yeah, that was crazy. Because yeah, like the a bunch of different telescopes he showed,
and then he like went to the GitHub page where the code is actually completely open source,
mostly written in Python, and you can actually go in and fix bugs. And that was another thing he was
basically saying, you know, in there is that and so is I think Katie Huff and her keynote later,
but, you know, you can go in there and you can you can contribute to these satellites, you know,
which is crazy. So it's all done in the open, the kind of this open science approach to,
you know, astronomy that hadn't really been there in the past.
Yeah, that was another super interesting theme of this talk was how we've seen how successful open
source has been. And the challenges as science becomes more technology of how do we make science
reproducible. So let's try to follow a kind of a similar path with open science as we do with open
source.
Yeah, definitely. And I think that that's, there's this graph he had, I think he might have tweeted the
graph last year at some point, but just the graph of like, number of astronomy,
publications, you know, in academic journals that are using Python, how it's just taking off. And so
it seems like this is really interesting effect that the open source approach of the Python community
has had on astronomy in particular, and is starting to have more generally where people are publishing
their code, their methods, their data, putting them out there so that all the results are reproducible,
easy to verify, you can't p hack the results so that you're getting fake discoveries and stuff like
that.
Yeah, I thought it was really great. And the graph that you're talking about, I mean, it really looked
like an example of an explosive growth startup out of some sort of growth hack story. But yeah,
no, this is the number of things using Python now, right?
Yeah, it makes you think that we just learned how to get into space, or we just invented the telescope,
because it's just taken off. It's bizarre. So it's really great. And science is very computational
now, where maybe in the past, it was more about labs or film processing or something like that. It
seems like data processing is how science is done. And that came across really strongly as well.
Yeah, it definitely did. One final thing that he covered that I thought was interesting that kind
of is related to that was, people traditionally had learned in the sciences, some very focused language,
like there's some language, I don't remember the name of it, that is like, here's how you do astronomy
programming, you know, IDL or something like that. Yeah, yeah, I believe it was IDL. That's right.
And he's like, that's really great. You can get astronomy job with that. But if all these people
now are grad students learning Python, like if for some reason, they don't decide to pursue
astronomy, they have a super marketable thing that they've learned as part of it, right?
Yeah, definitely. Yeah, it's much better. And then also people can contribute back to astronomy in a
way that so it goes both ways. It's two way street, you know, right, like maybe we're programmers,
we can program really well, but we don't, we're not astronomers, but we might want to like hobbyist
in it a little bit. And we can actually help out on structuring code or performance or something,
even if we're not astronomers, right? So you're right, like, I would never go contribute to an
IDL program. No, no way. Yeah, it's not gonna happen. Yeah. All right. So going from the sciences
and the sort of mosaic, let's kind of go back to maybe more traditional computer science,
like large software development house with Dropbox, right? Yeah. This is the talk on
mypy and static typing with I think Yuka and David from Dropbox, which is also where Guido works.
Yeah. And this project, mypy is something that's like Guido's main focus right now. He said when I
interviewed him, what is that like a couple months ago? Oh, great. Yeah. And the things I mean,
there's a bunch of things I didn't know here and a couple points that I thought were really
interesting. But the first one is they just, you know, oh, okay, Dropbox has 5 million lines of
Python. Wow, that's a lot. That's, that's cool. They just tell you that. And then 700,000 lines of that
are typed now, which is a lot of code. And so they're actually running the type checker at build
time. They do it as part, almost like part of their continuous integration process where
you can't commit to upstream until you've run the type checker and verified that it's clean.
So it's and then they, they actually said that it's helping engineers at Dropbox move faster,
get more done, do larger scale refactorings. So I think the proof that typing was a good idea,
Guido is basically helping realize that and kind of test it out and make sure that that this is
worthwhile. So any naysayers will be like, well, okay, this is not just an academic exercise in
typing. Like we actually have practical use cases, a very large practical code base. And we've shown it's
valuable. Yeah, they had a pretty interesting example of just like a three lines of code or
maybe four lines of code, like really, really simple function. It's like, you have no idea what
this does. It's entirely simple. And but it's it's kind of similar versions, but not identical versions
exist in a lot of places in 5 million lines of code, which one is this? And how do you know you're not
breaking it? Right? Yeah, definitely. I thought that was pretty interesting. And they also went through a lot
of the the ways in which you might approach this problem, right? You might put some sort of like, comment in your
code, to say, here's what the types are. But then they talked about all the various trade offs on that, right?
Yeah, definitely. And I think it's also interesting, because right now, you know, in the landscape outside of Python,
you have things like TypeScript, which is the language from Microsoft, and Google's working on it, related to Angular,
the the web framework. And then on the Facebook side with react, which is a great framework for for JavaScript
UIs, they have something called flow, which is also a type checker. So there's a parallel here where
in flow, you know, you do all the type annotation, a lot of it with comments. And then with TypeScript,
you do it in line with the special kind of syntax looks a lot like Python, actually. And then Google's
old closure compiler for JavaScript also had type annotations and comments. And then in Python to seven,
you can get all of the functionality of mypy and typing also do by doing it through comments. So
it's kind of like this thing where it's like, well, we didn't plan to have this in the language. So we
had to figure out a way to shoehorn it in using comments, that it's a common theme. But now Python
three, six, and even since three, three has all the different parts of support that you really need in
order to add types everywhere that you'd want. Yeah, and I don't see it being used that often. But I find it,
I find it really a valuable thing on the boundaries of parts of my program, like, like,
here's this whole data access layer. And I'm not going to go and like fill out the whole data access
layer with type hints. But maybe on the external functions that are being used by the rest of the
app, like just as you cross that boundary, I find it a really helpful thing some of the time.
Yeah, definitely. And I think like with the code base, I've been working in, you know, this 350,
400,000 line code base, you know, we've got a bunch of spaghetti in there that we really could,
it'd be better if we could refactor it out. And I think finding, kind of discovering the common
components in there and putting a boundary around them with a well defined interface that has typing
information would make the whole system much more stable and easier to understand, easier to test.
So I'm not against types. And I think that for core libraries or core functionality that a code base
relies on, it's really valuable. And I liked that they had a really gradual way of adopting it. It's
not some big bang thing where you need to go in and start writing types from day one, or you have to
freeze your whole code base, switch everything to types and then unfreeze it, you can actually go from
a leaf node up to a root node in terms of the file interdependencies, one file at a time,
and it all works as expected. It's like a depth first conversion.
Yeah, yeah, exactly. So, so I think that's really cool that they they've really thought
through that. And they've actually done it. And they explain the strategies for how they would do
it. And you're like, okay, run the script this way. Some best practices around checking in the script
you use to run my pie to make sure that you actually are running it consistently across all
developers workstations. But it was really cool how much progress they've made, even since the last
time I saw a talk on this. Yeah, it does really look quite nice.
There's two things I'm most excited about here. I mean, I think the first one is just structural
typing in Python. I think if you've used Go or TypeScript recently, the structural typing of the
interfaces, it's just so nice where you can say, oh, this is looks like a duck, quacks like a duck,
it's duck. And we can strictly enforce that it's a duck at compile time. It just feels so great. And
it's interesting because my pie doesn't do this. Like Python, you always think of it that way. You're
like, oh, if I can call dot open on it, then I can pass it to this function, right?
Right.
But the type system so far that they're implementing really looks like the Java type system.
So it's kind of odd because it's not really Pythonic yet, you know?
Yeah, that is really interesting because it's not like you're expressing like the thing that comes
here has to have these two functions in this field.
Right.
It's just, it has to literally be in this type hierarchy.
Exactly.
Yeah. Interesting.
Yeah. And so I think that it's not ready for prime time until that's like, I think people will have
trouble adopting it because they'll feel like it's a little clunky until that's done. But they said
they plan to do that, which is awesome. Yeah. So that is awesome. Yeah. And there's a pep.
Oh, what's the pep?
Oh, I haven't actually found it. They just mentioned there's a PEP for proto. They call it protocols.
Okay.
There's a PEP for my pie to support those. I couldn't, I haven't actually dug it up yet,
but I need to find it.
Right. Okay, cool. Yeah. If you're working in PyCharm, it will do that sometimes. Like you can
hit a button when you're at the call side of a function and it'll say there's no type hence here,
but you're going to need these three properties on whatever you pass. And it'll kind of like pop
that up. But yeah, it would be really cool if this supported, I didn't really even think about like,
okay, how, how sort of almost incongruent this way of specifying types is with the way that people
think of dynamic typing in Python. That's interesting.
Exactly. And there's one other repercussion of this that I think is extremely interesting,
which is, you know, in Python right now, like you're writing, let's say you're accessing a
dictionary and, you know, it's my dictionary, square bracket, the key, and then close square
bracket. And maybe you'll do that in a try except, and you'll catch the key error because you're
expecting that there might be a key error. Like the key may not be there. It's a common idiom.
You see people, oh, I expected this exception to happen. So I'm going to catch it right there.
Instead of checking if the key's there and then fetching it,
I'm just going to go for it and then handle the exceptional case. In that way, like exceptions
are part of the interface for a lot of methods and functions. And you see that all over the place
in code. And it's not slower in Python. It's about the same speed as a function call. So this is like
something that people do all the time. In the type system of mypy, you can't specify the types of the
exceptions that come out of a function. And they have no plans to do it because typed exceptions in Java
were really a big problem.
Yeah. Yeah. They are challenging.
Very challenging. And C# didn't make that mistake, like doesn't have checked exceptions.
So I think what it means for Python programmers is that once three, six and mypy become more common,
I think that that idiom of raising an exception and expecting it to be caught is going to go away.
And I think people are going to do it more like go programming where you return like a tuple of
it's okay and here's the result or it's not okay and here's the error.
Yeah, sure, sure. Result comma error in some kind of tuple and you just look at one or the other. Yeah.
Yeah. And they support optional types in mypy so they can actually enforce typing on the variations,
which is really cool. Like they have kind of like what Swift can do. They can do that in mypy already.
So this talk to me was like a sneak peek of what Python will be written like in three years,
essentially.
That's a cool analysis.
Yeah.
What I was sort of seeing when I was looking at this was part of the overall trend towards Python 3.
Oh, yeah, definitely.
Yeah. And, you know, when Guido was on the show, I think he mentioned even that
this will provide some foundation for helping them move to Python 3 at Dropbox.
Oh, yeah.
They can reason more carefully about the code and decide if it's going to be a problem
at some sort of conversion.
Yeah, exactly. Yeah, I think that's definitely the case. And there are already 700,000 lines in.
So I think it was probably the first 100,000 that was the hard part. I'm looking forward to an update
once they, you know, say that they're totally done or whatever.
Yeah, it'll be pretty awesome.
Yeah.
Hey, everyone. Michael here. Let me take just a moment and thank one of our sponsors who makes
this show possible. This portion of Talk Python to Me has been brought to you by Rollbar.
One of the frustrating things about being a developer is dealing with errors.
Relying on users to report errors, digging through log files, trying to debug them,
or a million alerts just flooding your inbox and ruining your day.
With Rollbar's full stack error monitoring, you get the context, insight and control you need to
find and fix bugs faster. Adding the Rollbar Python SDK is just as easy as pip install Rollbar.
You can start tracking production errors and deployments in eight minutes or less.
Rollbar works with all the major languages and frameworks, including the Python ones like Django,
Flask, Pyramid, as well as Ruby, .NET, Node, iOS, and Android. You can integrate Rollbar into your
existing workflow. Send error alerts to Slack or HipChat or automatically create new JIRA issues,
pivotal tracker issues, and a lot more. They have a special offer for Talk Python to me listeners.
Visit talkpython.fm/Rollbar, sign up and get the bootstrap plan free for 90 days.
That's 100,000 errors tracked for free. But you know, just between you and me,
I hope you don't encounter that many errors. Give Rollbar a try today. Just go to talkpython.fm
slash Rollbar. So let's talk about the gillectomy. Yeah. So this is Larry Hastings talk,
and he's been at it for a couple of years. And first of all, let me just like take a step back
and maybe tell us what the GIL is. And do you think the GIL is actually a problem for Python?
Wow. Okay. Okay. So the gill, yeah, the global interpreter lock, which is the part of the
CPython interpreter that locks the state machine state while your program is running so that
different threads don't trash each other. It's a key part of how CPython works, how CPython's virtual
machine works. And it has unintended consequences, which are that it prevents your Python program from
using multiple cores at the same time. So it limits the actual execution speed of Python,
vanilla Python.
Right. Basically only for computational stuff.
Only for computational stuff. Yeah.
When you are waiting on the OS, like for network or file, it releases the gill, right?
Yeah, it does. And so for IO bound applications, or memory bound applications, it's not a big deal. But for
CP bound stuff, especially servers where they're trying to be really high, like highly responsive,
that can be a problem. So yeah, to answer your question, is it a problem? Well, depends on who you ask.
Like, in the JavaScript community, v8 is not multi threaded in the same way. It's completely single core for similar reasons.
Which means node is in a similar situation, right?
Yeah.
But you don't really hear people complaining about that with node, because it's really all they can use.
And then things like Go are, you know, are highly concurrent, super fast. And so I think Python's limiting itself by not being able to use all CPUs out of the box. There are tools like multiprocessing, the multiprocessing module for Python that do let you take advantage of all CPUs. It's just, it's just hard to use if you don't know what you're doing.
I don't think it's that huge a problem. I think the thing that's sort of relieved the pressure is there, when you really are doing a lot of computation, often there's some library and some bit of it is in C, and it really does take advantage of it, like NumPy or something, right?
So yeah, the really intense cases seem to have already worked around it, and you just pip install a thing and you're okay.
Yeah, but even in those cases, like NumPy and other packages like this, it's like, you need to restructure your program to take advantage of it. And I think that's the burden. It's, this was working, why can't I just turn up the speed dial and have it go faster, or increase the concurrency, you know, where you can do that with some other languages or other constructs. So yeah, I think most people, it doesn't matter. But I think certain areas, it does. And so I'm happy that they're spending time on it. And Larry's been diving into it.
Yeah. Okay, so that brings us to the Gilectomy.
Yeah. So yeah, he's been talking about it for a couple years now. And he's, he's trying to remove the GIL or at least remove the, the overhead of the GIL. And it's been tried a few times. If you look back at his older talks, I think there's an attempt at it. The original attempt at it was by Greg Stein, who I actually used to work with at Google. And he had added multi course, multi threaded support to Python, I think version, maybe it's version one five or version two, way back when. And it was insanely slow. It was like, awful.
And so yeah, anyway, so Larry's got a very particular style of presenting, which is, which is funny and very intense. But yeah, he just right off the bat, he's like, yeah, you know, Python without the gill, you can take the GIL out very quickly. It's actually not too hard. The problem is that it's really slow. It's 19 times, the one with the gills 19 times faster than the one without it, right?
Exactly. So yeah, you can do this. But before you see any advantage, you're going to need like 32 cores and really highly concurrent algorithms.
Yeah, exactly. You know, Larry is the guy who knows this stuff. So it's been interesting, because he is taking, you know, everything he knows, every trick in the book, essentially, and applying them to this GIL problem.
Yeah, so he, you know, in this talk, he walked through a lot of those. And, you know, we can talk about a couple of those examples. It started off just seeming hopeless, like he has no chance. And the graphs he was showing was the amount of CPU time that it takes to run a bunch of benchmarks, or maybe the Fibonacci benchmark. And it just looked hopeless. And all of his work was hopeless.
And so about halfway through the talk, I'm like, Oh, man, this is like, he's like, totally failed on this attempt, you know, but well, I won't give away the end. Okay, because we can talk about the end in just a second. But there's a bunch of techniques, though, that he used. I don't know if you remember any.
Yeah, well, I think what was interesting about this was he did lay out a lot of the different techniques and things that he had tried over over time, and really pulled out a lot of the challenges and trade offs that you have to make. And so it's like, I want the Gilgon, I want to just like, take advantage of all the CPUs.
Well, here are the trade offs. And here's where things actually get slower. And so there was stuff around garbage collection and managing reference counting and consistency there, the different types of locking that he had used, and just some of the allocation stuff. And yeah, it was, it was interesting.
Yeah, and there's a lot of reference. That's exactly right. And there's a lot of references of things that I like need to look up after that, like, some two stage locking stuff, getting rid of like accelerating thread local variables. There's something about, there's a book called the garbage collection handbook that I like, I was like, Oh, wow, I've heard of that has an algorithm called buffered reference counting, which I guess was the was the way that they he was able to make it fast.
So it's just really interesting to see how much it takes to do it correctly. But how it's actually all very well known algorithms in computer science research, and there's papers on basically everything that he's trying to do. So he's not actually treading new ground, which is really encouraging, because it's just about applying it to the Python space. He's not inventing some new technology that needs to be proven, and might be full of bugs. He's like, Oh, no, this is in the handbook.
He also invented it independently. But he's like, Oh, no, this is this is actually a known technique that I'm using. So even when he did invent something, it just was like a reinvention of the thing that existed, right?
Yeah, like from the 1977 or whatever it was. Yeah, that's always how it is.
It's definitely how it is.
Yeah. But ultimately, the last graph he showed was that it's really close now. I'm shocked because I did not think it was going to be possible. And you know, he's within, I think, maybe two x or less of slowness.
Wow.
You know, you can imagine that Python two seven goes away, because Python three, three has no gill, and it's super fast, or Python three has no GIL and super fast. And people like, wow, why would I use Python two, and I could use Python three, and run a lot faster.
Yeah, so this is actually an interesting point. I don't believe the galectomy came from these origins. But, you know, the next thing that we're going to talk about, I think, more or less did. And Brett Cannon, and Dino Veland are working on you started working on this thing called pigeon pigeon pigeon pigeon pigeon pigeon pigeon pigeon pigeon.
Basically, there's a couple of folks in the core developer saying, what can we do to improve adoption of Python three?
Right.
What if we made it 50% faster, right? That alone, if nothing else happened, that alone would make a huge difference.
And I think actually, regardless of whether it's been faster or not, the last two years have made like a huge shift towards Python three.
Yeah.
But the next talk that we're going to talk about by Victor Stinner was really highlighting some of the performance improvements that he and some other folks have done on Python three.
Yeah, definitely.
I really like this talk.
And I thought, you know, Victor's a really solid member of the Python core developer community.
And I really like this talk because it was very scientific in its presentation.
It was like, okay, here's, here's how we did the measurements.
It started off just with that.
You know, this is like, right.
As you say, it like actually started out with the measurements we've been using are unreliable.
First thing before we even start this process is we have to fix the measurements, right?
Yeah.
You can't even trust the numbers we used in the past.
So speed.python.com, which has all the benchmarks on it is like not something we should have been judging ourselves by in the past.
Yeah.
So that was, that was great.
Right.
And part of that isn't even just like, hey, we were bad at like running this code, but modern CPU architectures have things like turbo boosting and the speed at which your processor might run at could vary by like two or three X depending on how it's trying to save energy at the time and all sorts of stuff.
Right.
Yeah.
And that came up, that actually came up in a few different talks, including the Gilectomy one, another one I went to where people are trying to benchmark things and there's no good way to like disable all of the magic features that are in modern Intel CPUs or even ARM CPUs.
And so I think that there's actually a module that they're putting together.
That's like the standard benchmarking module that turns off all of this stuff automatically.
I actually don't remember what the, what it was called.
It was like perf or performance or something.
I think Victor Stenner had worked on it.
Yeah.
So that's great.
So I think if you're doing any benchmarking of any kind, you know, it's worth picking that module up and using it for your purposes.
So you can make sure that you're actually comparing stable numbers over time.
Yeah.
So then he talked about, I didn't count him exactly, but just something like 10 major, major improvements on Python 3.5 and 3.6 where he focused.
Yeah.
And there's, I mean, there's so many of them.
It's getting into the weeds with some of the stuff, but one of the ones was, one thing is like, it's no longer actually called Python bytecode.
That was one I liked.
So Python doesn't have bytecode anymore.
It has something called word code because bytes only one byte where a word is like 16 bits or, you know, it's multiple bytes.
Yeah.
And so there's some inner loop in the CPython runtime that had an if statement, which is like, okay, is this bytecode, does it have any arguments?
Because if it does, then it's more than one byte.
And they just said, you know what, let's just get rid of that and just have it be two bytes always because memory performance on, you know, modern machines is good enough that we don't need to actually save space.
Yeah.
And they basically removed a conditional check in C eval.c, which is like the switch statement.
Yeah.
The hot loop.
Yeah.
That's the super hot loop.
And so simple things like that, like maybe we'll just throw in like a wasted byte when there's no arguments and that will actually make it a little bit less memory efficient, like tiny, but much faster.
Yeah.
Exactly.
And so it ends up like netting, I don't remember what the performance boost, but there's a bunch of these that improve benchmarks by, you know, 5%, 10%, 20%.
And that stuff really adds up.
So it's really, they've done a lot.
And so Python 3.6 is extremely fast compared to others.
It's amazing to see that that progress.
Yeah.
So I would definitely say, especially if you're on Python 2 still and you're like, is it really worth switching?
You know, I get this language feature.
Sure.
I can do double star to create dictionaries out of other dictionaries and whatever, but is that really worth it?
Like check out this optimization talk because there's a lot of stuff where it's like, and this is 40% faster and this is two times faster and this is 12% faster.
And it's just like, whoa.
Yeah, definitely.
And like the decimal module, for example, that one is actually just rewritten in C, but I think it was 40, 40 times faster.
Yeah.
40 times faster.
Which is like, I've used decimal all the time.
So that would be helpful for, you know, what I've done.
He also alluded to something that will be in Python 3.7.
He didn't really want to go into it yet because he says the results aren't perfect or fully proven.
But he did say that in Python 3.7 that method calls are going to be faster across the board.
And, you know, that's my biggest problem I would say with Python is that calling a function is really slow.
Yeah.
That's a really good point.
Like you are at odds with performance with structuring your code well.
Exactly.
And so especially with the optimizing code, you're like, well, this is really hard to understand.
So I'm going to split this into functions so I can like follow it.
And as soon as you start doing that in Python, like you're slowing your program down every single time.
And that's not a tradeoff you want to make.
You know, that's terrible.
And so anything you can do to make function calls faster, they already, he already talked about a few of those.
And he said there's more coming in 3.7.
So I just, I think it's maybe a, the beginning of this performance renaissance in Python.
Yeah.
That I'm really looking forward to the Gilectomy being part of that as well.
But just, you know, meat and potatoes optimization, which is what Victor's doing.
It's just really great to see.
Yeah.
Really, really amazing stuff.
And some of the stuff that struck me was like how simple the changes were, but how careful you have to be in making them because of the edge cases.
It's like, here's a simple optimization, but it took us two and a half years because it was incredibly difficult.
To get every edge case just right.
Yeah.
Totally.
Yeah.
And that's, that's why it's like a darker, you know, you really need to know what you're doing to optimize and you need really good tests.
I think the case you're talking about is they rewrote LRU cache algorithm.
And yeah, it took them like two.
Yes.
That was the one I think.
Yeah.
Two and a half years.
Yeah.
It's pretty, pretty crazy.
Yeah.
That's pretty amazing.
All right.
So one that I did not see, but you went to, maybe you can tell us about is the debugger one.
Yeah.
So this is by Elizaveta Shashkova from JetBrains, I think in St. Petersburg.
And this one was really cool.
So it's cool because there's this PEP called PEP 523 and it's a Python enhancement proposal.
And it's a, the purpose of the PEP is to give a pigeon, which you were just talking about,
which is a JIT compiler, a just in time compiler for Python to make Python faster.
That's what the PEP was for.
It added a bunch of hooks into the C, CPython runtime that lets you change the way that functions
and code are evaled.
Okay.
So you can plug in new stuff.
Yeah.
The big idea is like, let's not keep rewriting new runtimes.
Let's try to find a way that you can plug into the one that we all have without forcing everyone
to go, should I do PyPy?
Should I do JIT?
Should I do IronPython?
Like, forget this, right?
Yeah, exactly.
And so make it more extensible.
So that's really cool that that PEP was created and has been plugged into Python.
I think it might be 3.5 that it landed.
But what they didn't realize when they developed this PEP is it would enable new use cases.
And so Eliza, what she went through is how they actually leverage that same interface to
enable a debugger for Python that is as fast or almost as fast as just vanilla Python.
And so if you've ever run your Python code under a debugger, it's something like 30 times slower.
Oh, interesting.
And so it's really hard to actually simulate a lot of the problems you have.
Or if you have timing issues, especially where there's races, you just can't even reproduce
them because it's so slow.
Everything runs in the right order under the debugger.
And then once you run it normally, then it goes fast enough.
And then you get these data races again.
And then you can't.
Then you get the bugs.
Yeah.
Heisenbugs.
Right.
And so they created this thing into JetBrains.
And I think it's I think the core of its open source, where it basically uses the PEP523
hooks that are meant to be for speedy eval.
And it'll actually rewrite the Python bytecode or wordcode in as it's coming through and insert
breakpoints into the bytecode, which makes it, you know, orders of magnitude faster because
the old Python debugger uses it's a set trace where you get a function call for every single
line of Python.
It's almost like a profiler.
Yeah, exactly.
And it's the slowest thing imaginable.
You know, it's first of all, you're calling a function, which is slow.
Right.
And then you do it for every single line, whether or not you want you care about that line.
So I love this talk because she walked through all the how the debuggers work, all the details
about why they're slow benchmarks are on that.
Then she explained her approach, how they do it, what it's good at, how it works.
She even showed the disassembly of the Python bytecode and how they plug into it.
So it was really awesome.
Yeah, that's cool.
I'm definitely going to have to check this one out.
Yeah, I would.
And my favorite part about it is just like that PEP defined an interface that is generally
useful to people.
So it wasn't intended to be used for this purpose, but it was general enough that it could be.
And that's good design from my perspective.
Yeah, it's really nice that, you know, that wasn't even part of the plan, right?
But just this flexing and growing CPython actually made this other use case really good.
Yeah, definitely.
So I'm looking forward to using that debugger.
And I keep hearing great things about PyCharm.
And I've never actually used it for anything like day to day.
I poked around with it, but never built a whole program with it.
Yeah, I don't know if this is the same thing.
But when you debug something in PyCharm, if you just do that on like a brand new machine,
it'll say warning the debugger speedups are not built.
You basically have to run this compiler statement to like build something into your system.
Oh, yeah.
That might be the same thing.
Yeah.
I think that might be it actually.
Yeah.
So there's like a little output that it says, hey, you can make this much faster if you run this line once.
Gotcha.
Yeah, no, I didn't know about that.
This portion of Talk Python to Me is brought to you by CodeChip.
Try CodeChip Basic, a free, simple, out-of-the-box, continuous integration service in the cloud.
Thousands of customers use CodeChip Basic every day.
Its pre-installed CI dependencies make testing your software and deploying it work out-of-the-box.
The average setup time for CodeChip Basic is less than three minutes.
CodeChip Basic comes with a free plan that grants 100 builds per month, unlimited projects, and unlimited users.
Do you run an open source project?
Those are always free on CodeChip.
And they just improved their Python support.
So give CodeChip a try and visit talkpython.fm/CodeChip to learn more and sign up for free.
That's talkpython.fm/CodeChip.
So one of the things that I thought was really neat, you know, I think there's a lot of things touching on this.
It's like, hey, this Python 3 stuff is becoming really amazing.
And maybe the pinnacle of that was the Instagram keynote.
Yeah.
And this is a great talk.
It was kind of two parts.
I think Lisa Guo was the one who talked mostly about the actual transition.
But it was, yeah, how they moved from Python, you know, Python 2 to Python 3 while not having any downtime.
Oh, yeah.
I watched this talk and I thought, okay, there's almost no other company out there.
I mean, maybe a handful, but almost anyone else that says, well, we can't switch to Python 3 because we have a large code base.
We have a lot of users.
We've got to keep shipping.
Like what Instagram did was really quite incredible.
The first thing that I sort of thought, okay, this is going to get really interesting is they just have one branch that they develop from, right?
They don't just like, it's not like they said, well, let's just fork everything and go over there for six months and work on that.
Yeah, and that's a recipe for disaster, I think.
And I actually work in a monorepo with a single trunk as well.
I've been doing that for years, which is kind of odd for many people.
And it's a great way to develop, but it does make it challenging to do large refactorings like this where you're changing style all over the place.
I want to do it all at the same time without breaking people or making sure that commits keep flowing through.
So just in terms of process and collaboration with a large team of people, I don't remember how many engineers they have working there, but it's hard.
Yeah, but there are many, yeah, quite a few.
So their goals were, we're not going to branch.
We're going to take our existing code, which is Python 2.7 running Django 1.3, which is five versions out of date.
Yeah.
And we're going to move that to Python 3 and the latest version of Django.
I suspect that Django switching and Django 2 saying like, we're not going to support Python 2 anymore.
So we're just done.
They're like, we're kind of painting ourselves into permanently into a somewhat of an old version.
Let's see if we can like, you know, get back on track.
Yeah.
And that was the incentive there.
Yeah.
I thought that was, you know, there's been this push to get all the libraries into Python 3, which has really made a lot of progress over the last, let's say, five years.
And now it's, you know, it's almost there for all the major ones.
And this is example, this is an example of the dividends that that's paid off because now Python Django 2 is like, yeah, we're not going to support these older versions.
And then Instagram's like, well, we really like that open source project and we collaborate, you know, we work on that.
And so they're incentivized to move.
And she also mentioned that Python 3.6 is just faster, which is, so those are two proof points that this strategy that Python's had more recently, maybe they should have had earlier, that would have helped the transition to happen faster.
But this more recent strategy of performance in libraries is starting to actually be enough of a carrot and a stick to get people to start converting at a large scale.
Yeah, it's really, really interesting.
I totally agree with you.
So they said, we're going to try to continue to ship new features.
We're going to check into this one branch.
We're not going to branch it.
We're going to have a very careful rollout of Python 3.
I thought that was actually really interesting as well.
Both the test, how they did the testing by saying, we're going to slowly say, these are the tests that pass and we'll like eat our way back into all the tests until they basically all pass again.
And the way of staging the rollout as well was interesting.
And they were basically maintaining a Python 2 and 3 code base, like one that could run under either runtime at the same time.
So that's kind of how they started this and what gave them the ability to make those more tactical moves in production.
They ran the tests, all the tests under 3 and 2 using a whitelist or an exclusion list, inclusion and exclusion lists.
And then they basically just started moving test after test across and setting up some best practices and all that kind of stuff.
And yeah.
Yeah, I really like this, that it was very prescriptive.
These are the steps you need to take.
Do it this way, this way.
And then like it was really a roadmap, not just a, hey, look, we did it.
Yeah, definitely.
Like if you work somewhere and you want to be able to explain to your boss, like, oh, this is, this is what we need to do and how we need to do it.
Like this is just have them watch this video because it's really, definitely.
It's really convincing.
And it has a bunch of best practices for teams.
And it even has some like nuggets that are really valuable.
Like one I thought was really cool was they talked about they rely on memcache so heavily.
And there's this issue between version two and version three of memcache where, oh, sorry, version two and version three of Python where the pickle module becomes, it can poison the other version.
I don't know if you remember seeing this.
Right.
They're basically, yeah, they're basically incompatible with like their serialization format and various things.
Yeah.
So it was really interesting because I've actually had this problem in production many times.
Even if you don't change the version of Python, you can cause memcache poisoning where you have a pickle version of the object and you've somehow slightly changed the structure of the object.
And now if you have two different versions of your app accessing memcache at the same time, but they both have different definitions of the object, they'll actually start poisoning each other and you'll cause just total runtime failures.
And the only solution, even if you flush the cache, it doesn't work because the old version will start writing it stuff into the cache.
The new version will start writing it stuff.
So there's, once you get into this loop of death, it's like, there's nothing you can do.
It's really scary.
Yeah.
So they started, they started partitioning their memcache keys to make sure that they wouldn't interact.
I'm envisioning them putting like PY3 or PY2 in front of every key name or something.
Exactly.
And that's really an amazing best practice.
It seems so obvious when you hear about it, but like, I think that that's something that, you know, even if you're just doing rollouts of deployments or, you know, you have new Docker images that are holding your app in them, that's actually a great strategy.
Just to reduce the amount of incompatibilities between the runtime, the, you know, runtime versions you have going on.
Right.
Maybe even like your app version or something, right?
It could even be, be that much, but it could be your code change, not Python's internal change.
Yeah.
That's, that's what I'm trying to say.
Yeah.
Between your own code versions, you know, your commit hash, you could use as a, as a prefix.
I think that's a really cool best practice.
Yeah.
Cool.
Yeah.
So I really liked this.
And in the end, they, I guess I could talk about the rollout really quick.
That was interesting.
They said, okay, first thing we're going to do is we're just going to run the tests on Python three as well.
And we'll start to slowly work that up.
And then we're going to switch all the dev environments to run Python three, but still ship to do continuous integration and ship to Python two.
And then once we get all the dev environments working and we stop hitting bugs, we're going to switch to just the employees of Facebook.
And then 0.1% of the users and then like 20%.
And then, and so they, they had this really structured rollout and they said, but by the time we got done with the internal use cases, we were like, there's barely anything left to do.
Yeah, definitely.
So that's, that's just really conservative.
Well done.
And I'd say just, you know, you have to have everyone on board though, that it takes time.
It's going to take a lot of resources.
You need to dedicate a team is not doing anything else.
And yeah, so I, I, I think it's a model that we should all follow.
Yep.
And in the end they said, look, there's these different parts of our code.
We run Python and Django and micro WSGI.
We run our async stuff like notifications and celery.
And we got a 40% performance improvement in, in celery, in the async area.
And we got a 12% performance memory speed improvement in the, the web front end, which there's like something you could take to your, your company, to your executives and say, look how much we're paying for all of these servers we got to maintain.
Right.
Look how much better it'll be.
Yeah.
I mean, it just, it just translated straight to like a financial savings and number of machine capacity, you know, that you could get out of it.
And that's, that's another just amazing kind of convincing argument.
So it's just, you know, you have speed and you have efficiency and then you have the cost savings.
So it's, it's great.
Yep.
It's great.
So we started this whole discussion of, by thinking of satellites that look out into space.
But the next one you went to is about satellites looking in towards the world.
Yeah.
So this is a, this is by Catherine Scott and she, she wrote the book on open CB for Python.
She's been in Python community for a while doing a lot of stuff like robots and computer vision.
And I think she recently joined a company called planet, which is a satellite imagery company that lets you buy satellite imagery and also let you get access to it for free under a bunch of circumstances.
And that was a big part of the pitch of this talk was kind of showing you that, that API and for academic research and all these other purposes, how you get access to it.
So it's more accessible than I've ever knew that you could, you know, you can say like, Hey, this lat lawn, like, can you give me every image of it, you know, for the last number of years?
And they can actually, you can actually pull that up through an API now, which is just totally bonkers.
You know, that's really cool.
And you could actually see how it changes over time, maybe.
Yeah. And, you know, and, and for her, you know, she mentioned it was, it was kind of like an aside, but for her, it was also like something that she thought was politically important or, you know, deforestation of the rainforest and like all these other kinds of things like that.
She thought it was useful for, but also just like plain old science, understanding ecology and urban analysis, but urban environments from space and just all kinds of GIS kind of use cases.
So it was really cool to see her work, work through a bunch of those, those examples.
Oh yeah. That sounds, that sounds really interesting.
Another one controlling things or even more so was the factory automation one, right?
Who I think actually they used to work together, Catherine and Jonas, I don't actually know that, but he works at Tempo Automation, which is a pick and place robot company in San Francisco.
And so they do a lot of crazy things, factories.
I love this talk.
It was really fun because he had a live demo for the entire thing.
And I'm pretty sure that the video captures some of that.
I don't know if you remember seeing that, but he had this conveyor belt contraption set up there and had a conveyor belt and had two pusher pads and he had some gum, like chewing gum.
And he's like, we're going to build a robot that will sort this gum into bubble gum and, you know, and spearmint gum based on the color of the package and a barcode.
Oh, that's cool.
Yeah.
And so then he walks you through.
Okay.
In Python, there's actually a PI serial library that will interface with a serial port and the serial port is a micro scanner for barcode.
And, and so he just like walked you through just from the beginning, like, okay, here's how you can scan a barcode.
Here's how you can actuate a little paddle, like in a pinball machine.
Here's how you can turn on a conveyor belt.
There's all this stuff I never, I know it's in there.
I've seen stuff on TV or whatever about factories and conveyor belts and factories, but he just went through like how it all actually works together.
And you can do it all from Python.
There's great libraries for it.
And it seemed really easy.
So it's like, that's one of the best talks where you're like, oh, I could totally do this, you know?
Yeah.
Made it entirely accessible, right?
Yeah.
Totally accessible.
Excellent.
Yeah.
That's great.
Yeah.
I really think the internet of things and these little devices, we're just at the beginning.
There'll be really cool stuff we can do with it.
Yeah, definitely.
And I think it also makes you realize that the internet of things, you know, we talk about it mostly for consumers and the little devices in our houses.
But in the factory, these devices are actually much more impactful.
And so you have sensors on control, you know, on conveyor belts or factory floors or the actual, like, not the supply chain, but the Henry Ford thing that's escaping me right now.
Assembly line?
Assembly line.
Thank you.
Yeah.
And so I think, you know, he just showed all of the things you need in order to do that.
So it's awesome that it's available over the internet, but it's also really scary because you're like, wow, if someone got access to that thing over the internet, they could, you know, cause a conveyor belt.
Like, yeah, I love Lucy style to be like running at a million miles an hour.
Yeah.
So I thought that was pretty funny just seeing into that as well.
Yeah.
That's neat.
Yeah.
All right.
The last one I thought was really pretty inspiring by Marietta.
Yeah.
Called Dial M for Mentor.
Right.
She's the first female Python core developer who's landed a commit into Python, you know, 20 some odd years after Python started.
So it's just really great that the Python community has been able to, we had a couple years ago, Hey, we need to really diversify the people who are committing to the core, sent out the call.
They tried to mentor people.
And he repeatedly said that we need to have more different types of people committing to Python.
And so she is, she is the first committer, female committer to Python and to the core.
To me, this talk was a lot about the kind of journey of mentorship of what it takes to, to, to, to make a contribution like that for someone where it might seem really scary.
Yeah, absolutely.
I mean, really the part where she talks about being a core developer, that's not until like the last five minutes.
It's until then is like, here's all the ways that I was frustrated becoming a developer.
Here's all the ways I got stuck.
And I felt inadequate and I felt like this was not for me and how I either kept myself going or I got help from someone.
And, you know, on the core developer side, I think Guido actually was her mentor to help her make her way through to actually, you know, getting stuff working.
Yeah.
At the code level in CPython, which is cool.
Yeah.
It's cool.
And I think that she explained a lot of her fears and the common kind of issues that people have when they're like need mentorship, but are too afraid to ask for it or have a hard time finding it.
And so it's a good wake up call for, I think people just in general, but in the Python community, especially to realize that we need to structure mentorship better and have a more active approach to how we do it.
And I've heard, you know, DjangoCon actually has a mentorship program for talks there where they will pair people who have never given a talk, but have thought about it with people who have given many talks to try to help them, you know, work through their slides.
Practice.
Yeah.
And I don't know if they're actually doing this for PyCon itself yet, but they do it for DjangoCon.
And I think that's an awesome model.
And I really hope that they, they should just do that for all of the regional PyCons and all of the, you know, all of those kind of meetup groups, just because that's, that's how you build confidence in young people or, or, or people who are approaching Python from different backgrounds.
And I think that's really critical.
So I think that her talk is a great way to kind of focus on what this meant, what these mentors should be doing and what, you know, how they need to make people feel comfortable seeking out mentorship.
Yeah. I think if you're in your first five years of programming, this will be really helpful for you looking for mentorship and finding your way and feeling confident.
And I think if you've been programmed for a really long time, this will help remind you what it's like for people coming into the modern environment and maybe how you can help.
Yeah, definitely. And I've been on both sides of that, you know, I remember like needing mentorship way back when, and I also, and now I do mentor people, but I, I would mentor more if I had a better way of connecting to people who need it.
You know, and there's a couple of ways she calls out that people can do that, which is great for people to volunteer.
And I hope that more kind of come up in the Python community so that the mentor, the, the people doing the mentoring also more of them volunteer and really make a point of taking the time to do it.
Yeah. It was a great talk. So let's leave it with that, huh?
Yeah.
For the ones that we went to, maybe I can ask you real quick, just, are there some other ones you're like, this is on my to watch list, but I didn't make it to it.
Yeah. Raymond Hettinger always has a talk, not always, but usually, and it's always great. And so he had one on dictionaries that I didn't get to see, but I heard was awesome.
Yeah. I don't know if it was this particular talk, but one of his talks was basically sold out. Like they closed the door and said, you can't come in. Like we're at the limit for fire code in this room.
Yeah. That's usually what happens fire code. Yes. I was like, if people are new to Python, I'm like, well, you should probably go to this talk and get there like early. Yes. I, and I don't go to the, I'll watch that talk later, you know?
And then Brandon Rhodes, who was the chair of the conference. He also had a talk on dictionaries as well. I think it was different enough from the other ones. I'm looking forward to watching that one. He's a great speaker.
Yeah. That's, that's really good. And the last one was just Brett Cannon. He had a talk on what's new in Python three, six. It's just like an, a summary. And so you can read that online. If you just Google like what's new in Python three, six, you'll find it. But you know, hearing someone give the talk is a lot more interesting than reading through the notes. So I would definitely check that out.
I agree with you on that. I've read what it was in there and when it all came out, then I watched his talk and really the, this is here is what you get from reading the peps, but it's like, this is here. And this is the implication of what this being here means and whatnot. I think you just get a lot more appreciation for it.
Yeah. I agree.
All right. Excellent. So that was really, you know, it was fun, fun pike on, right?
Oh, it was great. Yeah. And next year it's in Cleveland. I think the next two years it's in Cleveland, Ohio. So that's going to be totally different. Change the scene.
Yeah. And I'm looking, looking forward to that and some great talks. So yeah, I'm looking forward to next year. And, and in the meantime, there's a bunch of regional Pycons coming, you know, Python conferences coming up. So that's another thing to just check out. Like if you, if you can't travel to one of these other places, you'd be surprised how many local Pycons there are across the United States and really across the world. So it's, it's worth checking those out.
Yeah, absolutely. I think they just announced PyCon Canada. And then there's also PyCascades, which is going to be in February. I think these are the PyCascades is brand new. And actually Marietta, the last person we spoke about,
was part of the organizer for that. Right. Yeah. Yeah. I think, I think it's for all the Pacific Northwest kind of area. Yeah. So definitely get out to one of these Pycons or multiple ones. If you're, if this sounds interesting to you, it's really a great time. Even if you don't go to the talks. Yeah, I agree. All right. Final two questions, Brett. Okay. If you're going to write the Python code, what editor do you use?
I'm still using Sublime Text. I'm on version three now. Yep. That's, it's still, still my, still my thing. And if I'm in a terminal, I still use Emacs. So that's my, I'm on that side of the debate.
All right. Very cool. And a notable PyPI package.
Wow. Recently, it's going to be what I can't live without. Right. I think it's been my go-to still. Yeah. If I'm doing web development, I'm going to install Flask every time, basically. So without a doubt. But I think if I'm actually just trying to do processing, it's, it's NumPy, which it's still the best thing that happened to Python.
All right. Yeah, for sure. It's very cool. I'll throw one more in there with mypy, just from the static typing talk.
I haven't used it enough to install it every time, but I think that's a great, that's actually something I should shoot for is that being my go-to.
Yeah. Yeah. That's very cool. Yeah. All right. So you actually have a playlist of this, right?
Oh, wow. I do. Yeah. I could share that. That's a good idea.
Yeah. If it's already, I'll just put it in the show notes. Sounds good.
And just subscribe to it and just go through. They can basically replay PyCon through your attendance.
Sounds good. Yeah. I think I'll add a couple more in there too. I think the lightning talks are worth checking out and, but that's great. Yeah, we should do that.
All right. Awesome. Brett, thanks for being on the show. It was excellent to talk with you.
Yeah. Thanks so much for having me. I had a really good time.
You bet. Bye.
This has been another episode of Talk Python to Me.
Today's guest has been Brett Slatkin, and this episode has been brought to you by Rollbar and Codeship.
Rollbar takes the pain out of errors.
They give you the context and insight you need to quickly locate and fix errors that might have gone unnoticed until your users complain, of course.
As Talk Python to Me listeners, track a ridiculous number of errors for free at rollbar.com slash Talk Python to Me.
Do you have software? Would you like to know if it has bugs before you deploy it?
Then jump over to talkpython.fm/Codeship and set up a free Codeship Basic account, Ship Tested Software.
Are you or your colleagues trying to learn Python?
Well, be sure to visit training.talkpython.fm.
We now have year-long course bundles and a couple of new classes released just this week.
Have a look around. I'm sure you'll find a class you'll enjoy.
Be sure to subscribe to the show.
Open your favorite podcatcher and search for Python.
We should be right at the top.
You can also find the iTunes feed at /itunes, Google Play feed at /play, and direct RSS feed at /rss on talkpython.fm.
Our theme music is Developers, Developers, Developers by Corey Smith, who goes by Smix.
Corey just recently started selling his tracks on iTunes, so I recommend you check it out at talkpython.fm/music.
You can browse his tracks he has for sale on iTunes and listen to the full-length version of the theme song.
This is your host, Michael Kennedy.
Thanks so much for listening. I really appreciate it.
Smix, let's get out of here.
Stay tuned. I'll see you next time.
Don't believe
Thank you.