Michael Kennedy: Today on Talk Python, the creators behind FastAPI, Flask, Django, Quart, and Litestar
Michael Kennedy: get practical about running apps based on their frameworks in production.
Michael Kennedy: Deployment patterns, async gotchas, servers, scalings, and the stuff that you only learn
Michael Kennedy: at 2 a.m. when the pager starts going off.
Michael Kennedy: For Django, we have Carlton Gibson and Jeff Triplich.
Michael Kennedy: For Flask, we have David Lord and Phil Jones.
Michael Kennedy: And on Team Litestar, we have Yannick Noverde and Cody Fincher.
Michael Kennedy: And finally, Sebastian Ramirez from FastAPI is here as well.
Michael Kennedy: Let's jump in.
Michael Kennedy: This is Talk Python To Me, episode 533, recorded December 17th, 2025.
Michael Kennedy: Welcome to Talk Python To Me.
Michael Kennedy: the number one Python podcast for developers and data scientists.
Michael Kennedy: This is your host, Michael Kennedy.
Michael Kennedy: I'm a PSF fellow who's been coding for over 25 years.
Michael Kennedy: Let's connect on social media.
Michael Kennedy: You'll find me and Talk Python on Mastodon, Bluesky, and X.
Michael Kennedy: The social links are all in your show notes.
Michael Kennedy: You can find over 10 years of past episodes at talkpython.fm.
Michael Kennedy: And if you want to be part of the show, you can join our recording live streams.
Michael Kennedy: That's right.
Michael Kennedy: We live stream the raw uncut version of each episode on YouTube.
Michael Kennedy: Just visit talkpython.fm/youtube to see the schedule of upcoming events.
Michael Kennedy: Be sure to subscribe there and press the bell so you'll get notified anytime we're recording.
Michael Kennedy: Hey, before we jump into the interview, I just want to send a little message to all the companies
Michael Kennedy: out there with products and services trying to reach developers.
Michael Kennedy: That is the listeners of this show.
Michael Kennedy: As we're rolling into 2026, I have a bunch of spots open.
Michael Kennedy: So please reach out to me if you're looking to sponsor a podcast or just generally sponsor
Michael Kennedy: things in the community and you haven't necessarily considered podcasts, you really should.
Michael Kennedy: Reach out to me and I'll help you connect with the Talk Python audience.
Michael Kennedy: Thanks everyone for listening all of 2025. And here we go into 2026. Cheers.
Michael Kennedy: Hello, hello, Carlton, Sebastian, David, Cody, Yannick, Phil, Jeff, welcome back to Talk Python,
Michael Kennedy: all of you. Thanks for having us. Thank you for having us. Happy to be here again. We're here for
Michael Kennedy: what may be my favorite topic for sure. Something I spend most of my time on is web API stuff,
Michael Kennedy: which is awesome. So excited to have you here to give your inside look at how people should
Michael Kennedy: be running your framework, at least the one that you significantly contribute to, depending on
Michael Kennedy: which framework we're talking about, right? It's going to be a lot of fun, and I'm really excited
Michael Kennedy: to talk about it. However, there's an interesting fact that I've been throwing out a lot lately is
Michael Kennedy: that fully half of the people doing professional Python development have only been doing it for two
Michael Kennedy: years or less. And some of you been on the show, it was maybe two years longer than that. Let's just
Michael Kennedy: do a quick round of introductions for people who don't necessarily know you. We'll go around the
Michael Kennedy: squares here in the screen sharing. So Carlton, you're up first. Oh, I get to go first. Brilliant.
Carlton Gibson: Well, I'm Carlton. I work on the Django Red framework mostly. I'm a former Django fellow.
Carlton Gibson: I maintain a number of packages in the ecosystem. And the last few years I've been back to building
Carlton Gibson: stuff with Django rather than working on it. So I run a build startup that's, well, we're still
Michael Kennedy: going. So I'm quite excited about that. Awesome. How is it to be building with Django than building
Carlton Gibson: Django? Oh, I'm literally having the time of my life. Like I spent five years as a Django fellow
Carlton Gibson: working on Django and I just built up this backlog of things I wanted to do and I had no time and no
Carlton Gibson: capacity and no, no sort of nothing to work on with them. And it's just, it's just a delight.
Carlton Gibson: And every day I sit down on my computer thinking, oh, what's today?
Carlton Gibson: I look at the background.
Carlton Gibson: Oh, yes.
Carlton Gibson: And every day, a delight.
Carlton Gibson: So I'm still just loving it.
Carlton Gibson: That's awesome.
Michael Kennedy: So more often you're appreciating your former self than cursing your former self
Michael Kennedy: for the way you built.
Michael Kennedy: Yeah, that's an interesting one.
Michael Kennedy: I think we should move on before.
Michael Kennedy: All right.
Michael Kennedy: Speaking of building with and for Sebastian, FastAPI.
Michael Kennedy: Hello.
Michael Kennedy: So, okay, intro for the ones that don't know me.
Michael Kennedy: I'm Sebastian Ramirez.
Michael Kennedy: I created FastAPI.
Michael Kennedy: Yeah, that's pretty much it.
Michael Kennedy: And now I have been building a company since the last two years, FastAPI Cloud, to deploy
Michael Kennedy: FastAPI.
Michael Kennedy: So, I get to drink from funny cups, as you can see.
Michael Kennedy: The world's best boss.
Michael Kennedy: Amazing.
Michael Kennedy: So, I think you deserve to give a bit of a shout out to FastAPI Cloud.
Michael Kennedy: That's a big deal.
Michael Kennedy: Thank you.
Michael Kennedy: Thank you very much.
Michael Kennedy: Yeah, it's super fun.
Michael Kennedy: And the idea is to make it super simple to deploy FastAPI applications.
Michael Kennedy: The idea with FastAPI was to make it very simple to build applications, build APIs,
Michael Kennedy: and get the idea from idea to product in record time.
Michael Kennedy: That was the idea with FastAPI.
Michael Kennedy: But then deploying that, in many cases, is just too cumbersome.
Michael Kennedy: It's too complicated.
Michael Kennedy: There are just so many things to that.
Michael Kennedy: So I wanted to bring something for people to be able to say, like,
Michael Kennedy: hey, just one command FastAPI deploy, and we take care of the rest.
Michael Kennedy: And then we and the team, I have an amazing thing
Michael Kennedy: that I've been able to work with.
Michael Kennedy: We suffer all the cloud pains so that people
Michael Kennedy: don't have to deal with that.
Michael Kennedy: And yeah, it's painful to build, but it's so cool to use it.
Michael Kennedy: You know, like that's the part when I say like, yes,
Michael Kennedy: this was worth it.
Michael Kennedy: When I get to use the thing myself, that is super cool.
Michael Kennedy: MARK MANDEL: Yeah, I'm assuming you build FastAPI
Michael Kennedy: Cloud with FastAPI somewhat.
Michael Kennedy: FRANCISCO MOLIN: Yes, yes, yes, exactly.
Michael Kennedy: FastAPI Cloud runs on FastAPI Cloud.
Michael Kennedy: And I get just like now random things in there and like, yes.
Michael Kennedy: Congrats to that again.
Michael Kennedy: That's super cool.
Michael Kennedy: David Lord, welcome.
Michael Kennedy: Welcome back.
David Lord: Yeah.
David Lord: Hello.
David Lord: I'm David Lord.
David Lord: I'm the lead maintainer of Pallets, which is Flask, Jinja, Click, Berkswag.
David Lord: It's dangerous, markup safe.
David Lord: And now Pallets Eco, which is a bunch of the famous extensions for Flask that are getting
David Lord: community maintenance now.
David Lord: I've been doing that since, I think I've been the lead maintainer since like 2019, but a
David Lord: maintainer since like 2017.
David Lord: So it's been a while.
Michael Kennedy: That's been a while.
Michael Kennedy: We're coming up on seven, eight years.
Michael Kennedy: That's crazy.
Michael Kennedy: Time flies.
David Lord: It's always funny because I always feel like I've been doing it for way, way longer.
David Lord: And then I look at the actual date that I got added as a maintainer.
David Lord: I'm like, well, it couldn't have been that late.
Michael Kennedy: I was doing stuff before that, right?
Michael Kennedy: Well, I'm sure you were deep in flask before you got added as a maintainer of it, right?
Michael Kennedy: Yeah.
Michael Kennedy: Phil Jones, since you are also on the same org, next.
Michael Kennedy: Hey, welcome back.
Michael Kennedy: Hello.
Phil Jones: Yeah, I'm Phil Jones.
Phil Jones: I am the author of Quartz, which is also part of Palette.
Phil Jones: I also work on Berkshagen and Flask and help out there.
Phil Jones: And I've done a server called Hypercorn as well.
Phil Jones: So a bit of interest in that part of the ecosystem.
Phil Jones: What is Quart for people who don't know?
Phil Jones: Quart is basically Flask with async await.
Phil Jones: And that was the idea behind it really to make it possible to do async await.
Phil Jones: So yeah, that's pretty much it.
Phil Jones: If we, when we manage to merge them, we will.
David Lord: And the goal now with Quart as part of palettes is to eventually have it be one code base with Flask.
David Lord: But given that we both have small children now, we're moving a lot slower.
Michael Kennedy: Having kids is great.
Michael Kennedy: I have three kids.
Michael Kennedy: Productivity is not a thing that they are known to imbue on the parents, right?
Michael Kennedy: Especially in the early days.
Michael Kennedy: I want to say, Phil, thank you.
Michael Kennedy: I've been running Quart for a couple of my websites lately, and it's been amazing.
Phil Jones: Nice.
Phil Jones: Yeah, I also use it at work.
Phil Jones: We've got all our stuff in Quart, which is, yeah, it's really good fun.
Phil Jones: A bit like Carlton.
Michael Kennedy: So when people, if they get, if they listen to the show or they go to the website of the show and they're not on YouTube, then that somehow involves court.
Janek Nouvertné: Janek, welcome.
Janek Nouvertné: Hey.
Janek Nouvertné: Yeah, I'm Janek de Vietni.
Janek Nouvertné: I work on Litestar.
Janek Nouvertné: I just looked up how long it's been because I was curious myself.
Janek Nouvertné: I also had the same feeling that it's been a lot longer than, it's actually only been three years.
Janek Nouvertné: Yeah.
Janek Nouvertné: And I also, I noticed something with all you guys here in the room.
Janek Nouvertné: I use almost all of the projects you maintain at work,
Janek Nouvertné: which is quite nice.
Janek Nouvertné: We have a very big Django deployment.
Janek Nouvertné: We have some Flask deployments.
Janek Nouvertné: We have a few FastAPI deployments.
Janek Nouvertné: I think we have one core deployment
Janek Nouvertné: and we also have two Light Store deployments,
Janek Nouvertné: which obviously is a lot of fun to work with.
Janek Nouvertné: And I find it really, really nice actually
Janek Nouvertné: to work with all these different things.
Janek Nouvertné: It's super interesting also because like everything
Janek Nouvertné: has its own niche that it's really good at.
Janek Nouvertné: And even, you know, you think
Janek Nouvertné: if you maintain a framework yourself,
Janek Nouvertné: you tend to always recommend it for everything.
Janek Nouvertné: But I noticed it's not actually true.
Janek Nouvertné: There's actually quite a few cases
Janek Nouvertné: where I don't recommend Litestar.
Janek Nouvertné: I recommend, you know, just, you know,
Janek Nouvertné: use Django for this or, you know,
Janek Nouvertné: use Flask for that or use FastAPI for this
Janek Nouvertné: because, well, they are quite different after all.
Janek Nouvertné: And I find that really, really interesting
Janek Nouvertné: and nice. And I think it's a good sign of a healthy ecosystem if it's not just, you know,
Janek Nouvertné: the same thing, but different, but it actually brings something very unique and different to
Michael Kennedy: the table. I think that's a great attitude. And it's very interesting. You know, I feel like
Michael Kennedy: there's a lot of people who feel like they've kind of got to pick their tech team for everything.
Michael Kennedy: I'm going to build a static site. Like, well, I've got to have a Python-based static site builder.
Michael Kennedy: Like, well, it's a static site. Who cares what technology makes it turn? You're writing Markdown,
Michael Kennedy: and out comes HTML.
Michael Kennedy: Who cares what's in the middle, for example, right?
Michael Kennedy: And, you know, I feel like that's kind of a life lessons learned.
Michael Kennedy: Absolutely, yeah.
Michael Kennedy: Yeah, that's awesome.
Michael Kennedy: Cody, hello, hello.
Cody Fincher: Yeah, hey guys, I'm Cody Fincher.
Cody Fincher: I'm also one of the maintainers of Litestar.
Cody Fincher: I've been there just a little bit longer than Yannick.
Cody Fincher: And so it's been about four years now.
Cody Fincher: And Yannick actually teed this up perfectly
Cody Fincher: because I was going to say something very similar.
Cody Fincher: I currently work for Google.
Cody Fincher: I've been there for about three and a half years now.
Cody Fincher: And we literally have every one of the frameworks
Cody Fincher: you guys just mentioned,
Cody Fincher: and they're all in production.
Cody Fincher: And so one of the things that you'll see
Cody Fincher: on the Litestar org and part of the projects
Cody Fincher: that we maintain are that we have these optional batteries
Cody Fincher: and most of the batteries that we have
Cody Fincher: all work with the frameworks for you guys.
Cody Fincher: And so it's nice to be able to use that stuff,
Cody Fincher: you know, regardless of what tooling you've got
Cody Fincher: or what project it is.
Cody Fincher: And so, yeah, having that interoperability
Cody Fincher: and the ability to kind of go between the frameworks
Cody Fincher: that work the best for the right situation is crucial.
Cody Fincher: And so I'm glad you mentioned that, Yannick.
Cody Fincher: But yeah, nice to see you guys
Michael Kennedy: on the show. Cody, tell people what Litestar is. I know I had both you guys and Jacob on a while
Michael Kennedy: ago, but it's been a couple of years, I think. Litestar at its core is really a web framework
Cody Fincher: that kind of sits somewhere in between, I'd say, Flask and FastAPI and Django. So whereas, you know,
Cody Fincher: Flask doesn't really, you know, bundle a lot of batteries. There's a huge amount of, you know,
Cody Fincher: third-party libraries and ecosystem that's built around it that people can add into it, but there's
Cody Fincher: not really like, for instance, a database adapter or a database plugin or plugins for
Cody Fincher: VEAT or something like that, right, for front end development. And so what we have been doing
Cody Fincher: is building a API framework that is very similar in concept to FastAPI that is also extensible.
Cody Fincher: So if you want to use the batteries, they're there for you. But if you don't want to use
Cody Fincher: them, you don't have to, right? And so a lot of the tooling that we built for LightStore
Cody Fincher: was birthed out of a startup that I was in prior to joining Google. And so having all
Cody Fincher: this boilerplate, really, it needed somewhere to go.
Cody Fincher: And so a lot of this stuff ended up being plugins,
Cody Fincher: which is what we bundled into Litestar
Cody Fincher: so that you can kind of add in this extra functionality.
Cody Fincher: And so I know I'm getting long-winded.
Cody Fincher: It's somewhere between Django and Flask,
Cody Fincher: if you were to think about it in terms of a spectrum,
Cody Fincher: in terms of what it gives you in terms of a web framework.
Cody Fincher: But in short, it does everything that all the other guys do.
Michael Kennedy: Very neat. It's definitely a framework I admire.
Michael Kennedy: Jeff Triplett, so glad you could make it.
Jeff Triplett: Yeah, thanks for having me.
Jeff Triplett: Yeah, I'm Jeff Triplett. I'm out of Lawrence, Kansas.
Jeff Triplett: I'm a consultant at a company called Revolution Systems.
Jeff Triplett: I was on, some people know me from being on the Python Software Foundation board.
Jeff Triplett: I've been off that for a few years.
Jeff Triplett: As of last week, I'm the president of the Django Software Foundation.
Jeff Triplett: So I've been on that board for a year.
Jeff Triplett: I'm kind of a Django power user, I guess.
Jeff Triplett: I've used it for about 20 years.
Jeff Triplett: And I've kind of not really worked on, I don't even think I have a patch anymore in Django.
Jeff Triplett: But I've done a lot with the community.
Jeff Triplett: I've done a lot with contributing through conferences and using utilities.
Jeff Triplett: I try to promote Carleton's applications like Neapolitan.
Jeff Triplett: And if I like tools, Python tools in general, I try to advocate for it.
Jeff Triplett: I've also used all of these applications.
Jeff Triplett: Litestar, I haven't, but I have a friend who talks about it a lot.
Jeff Triplett: And so I feel like I know a lot from it.
Jeff Triplett: As a consultant, we tend to go with the best tool for the job.
Jeff Triplett: So I've done a little bit of FastAPI.
Jeff Triplett: I worked with Flask a lot over the years, even though we're primarily a Django shop.
Jeff Triplett: It just depends on what the client needs.
Michael Kennedy: And you see a lot of different sizes of web app deployments.
Michael Kennedy: So I think that's going to be an interesting angle for sure.
Jeff Triplett: Yeah, absolutely.
Jeff Triplett: Small ones to hundreds of servers.
Jeff Triplett: We don't see it as much anymore the last four or five years, especially with like CDNs and caching.
Jeff Triplett: We just don't see load like we did, you know, 10 years ago or so.
Jeff Triplett: And then I also do a lot of like small, I kind of call them some of them little dumb projects, but some are just fun.
Jeff Triplett: Like I've got a FastAPI web ring that I wrote a year ago for April Fool's Day.
Jeff Triplett: And for some reason that kind of took off and people liked it, even though it was kind of a joke.
Jeff Triplett: So I started like peppering it on a bunch of sites and I maintain like Django packages.
Jeff Triplett: I do a newsletter, Django News newsletter, just kind of lots of fun stuff.
Michael Kennedy: Definitely looking forward to hearing all of your opinions.
Michael Kennedy: So I've got a bunch of different your app in production topics
Michael Kennedy: I thought we could just work around or talk over.
Michael Kennedy: So I thought maybe the first one is what would you recommend,
Michael Kennedy: or if you don't really have a strong recommendation,
Michael Kennedy: what would you choose for yourself to put your app in your framework in production?
Michael Kennedy: I'm thinking app servers, reverse proxies like Nginx or Caddy.
Michael Kennedy: Do you go for threaded?
Michael Kennedy: Try to scale out with threads.
Michael Kennedy: you try to scale out with processes, Docker, no Docker, Kubernetes. What are we doing here,
Michael Kennedy: folks? Carlton. I think we'll just keep going around the circle here. So you may get the first
Michael Kennedy: round of everyone. No, I'll try to mix it up, but let's do it this time.
Carlton Gibson: I do the oldest school thing in the book. I run Nginx as my front end. I'll stick a
Carlton Gibson: WSGI server behind it with a pre-fork, a few workers, depending on CPU size, depending on
Carlton Gibson: the kind of requests I'm handling. These days, in order to handle long-lived requests,
Carlton Gibson: like server-sent events, that kind of, or WebSocket type things, I'll run an ASGII server as a kind
Carlton Gibson: of sidecar. I've been thinking about this a lot, actually. But yeah, this is interesting.
Carlton Gibson: If you're running a small site and you want long-lived requests, just run ASGII. Just use
Carlton Gibson: ASGII. Because any of the servers, Hypercorn, Uvacorn, Daphne, Grannion is the new hot kid on
Carlton Gibson: the bot, right? All of those will handle your traffic, no problem. But for me, the scaling
Carlton Gibson: paddles and whiskey are so well known and just like i can do the maths on the back of the pencil i know
Carlton Gibson: exactly how to scale it up having done it for so long for me for my core application i would still
Carlton Gibson: rather use the whiskey server and then limit the async stuff to just to the use cases where it's
Carlton Gibson: particularly suited so i'll do that um process manager i deploy using systemd if i want to if i
Carlton Gibson: want a container i'll use podman by systemd it's as old school as it gets i'll very often run a
Carlton Gibson: a Redis instance on localhost for caching,
Carlton Gibson: and that will be it.
Carlton Gibson: And that will get me an awful long way.
Carlton Gibson: If I have to schedule,
Carlton Gibson: I just get a bigger box.
Carlton Gibson: And a bigger box.
Carlton Gibson: Yeah, yeah, yeah.
Carlton Gibson: I really, really, really need multiple boxes.
Carlton Gibson: Well, then we'll talk.
Michael Kennedy: I feel like you and I are in a similar vibe.
Michael Kennedy: But one thing I want to sort of throw out there to you,
Michael Kennedy: but also sort of the others is,
Michael Kennedy: what are we talking with databases?
Michael Kennedy: Like, who is bold enough to go SQLite?
Michael Kennedy: Anyone's going SQLite out there?
Cody Fincher: Yeah, it depends, right?
Cody Fincher: It just depends on what you're doing, right?
Cody Fincher: And how many concurrent users you're going to have.
Cody Fincher: It really is amazing there.
David Lord: The Palette's website is running on Flask,
David Lord: which I wasn't doing for a while.
David Lord: I was doing a static site generator.
David Lord: Then I got inspired by Andrew Godwin's static dynamic sites.
David Lord: And so it loads up all these markdown files,
David Lord: static markdown files into a SQLite database at runtime
David Lord: and then serves off of that
David Lord: because you can query really fast.
David Lord: Oh, that's awesome. I love it.
David Lord: So I am using SQLite for the Palette's website.
Janek Nouvertné: Yeah, I also do have a few small apps that use SQLite.
Janek Nouvertné: And one recently that's Cody's fault
Janek Nouvertné: because he put me on that track
Janek Nouvertné: where it's running a SQLite database in the browser
Janek Nouvertné: because nowadays it's quite easy to do that.
Janek Nouvertné: And then you can do all sorts of stuff with it,
Janek Nouvertné: like hook into it with DuckDB and perform some analysis.
Janek Nouvertné: So you don't actually need to run any sort of server at all.
Janek Nouvertné: You can just throw some files into Nginx and serve your data.
Janek Nouvertné: And as long as that's static,
Janek Nouvertné: you have a super, super simple deployment.
Janek Nouvertné: So yeah, definitely SQLite.
Michael Kennedy: If you can, I like it.
Michael Kennedy: I agree.
Michael Kennedy: It's interesting.
Michael Kennedy: The database probably won't go down with that, probably.
Michael Kennedy: Let's do this by framework.
Michael Kennedy: So we'll do vertical slices in the visual here.
Michael Kennedy: So Jeff.
Jeff Triplett: Yeah, Django, Postgres, pretty old school stack.
Jeff Triplett: I think putting a CD in front of anything is just a win.
Jeff Triplett: So whether you like Fastly or Cloudflare,
Jeff Triplett: you get a lot of mileage out of it.
Jeff Triplett: You learn a lot about caching
Jeff Triplett: because it's kind of hard to cache Django by default.
Jeff Triplett: So you get to play with curl
Jeff Triplett: and kind of figure out why very headers are there.
Jeff Triplett: And it's a good learning experience to get through that.
Jeff Triplett: I also like Coolify, which is kind of new, at least new to me and new to Michael.
Jeff Triplett: We talk about this in our spare time a lot.
Jeff Triplett: It's just kind of a boring service that'll launch a bunch of containers for you.
Jeff Triplett: There's a bunch of one-click installs, so Postgres is a one-click.
Jeff Triplett: It also does backups for you, which is really nice to have for free.
Jeff Triplett: I run a couple dozen sites through it and really like it.
Jeff Triplett: You can either do a hosted forum, I don't get any money from it, or you can run the open-source version.
Jeff Triplett: I do both.
Jeff Triplett: I've got like a home lab that I just run stuff using the open-source version.
Jeff Triplett: And for five bucks a month, it's worth it to run a couple servers.
Jeff Triplett: And like Carlton said, you can just scale up.
Michael Kennedy: Yeah, it's got a bunch of one-click deploy for self-hosted SaaS things as well.
Michael Kennedy: Like I want an analytics stack of containers that run in its own isolated bit.
Michael Kennedy: Just click here and go.
Jeff Triplett: Yeah, one-click, it's installed and you're up.
Jeff Triplett: And then once you get one Django, Flask, FastAPI site working with it,
Jeff Triplett: and it uses like a Docker container.
Jeff Triplett: Once you get that set up, it's really easy to just kind of duplicate that site,
Jeff Triplett: plug it in to GitHub or whatever your Git provider is.
Jeff Triplett: And it's a nice experience for what normally is just our syncing files
Jeff Triplett: and life's too short for that.
Michael Kennedy: Sebastian, I want to have you go last on this one
Michael Kennedy: because I think you've got something pretty interesting
Michael Kennedy: with FastAPI Cloud to dive into.
Michael Kennedy: But let's do Litestar next. Cody.
Cody Fincher: I have actually bought all the way in on Gradient.
Cody Fincher: So for the ASCII server, I've actually been running Gradient now
Cody Fincher: for I'd say a year in production.
Cody Fincher: It's worked pretty well.
Cody Fincher: There's a couple of new things that I'm actually kind of
Cody Fincher: with. I don't know how well they're going to work out. So I'm going to go ahead and throw this out
Cody Fincher: there. But Granian is one of the few ASCII servers that supports HTTP2. And it actually can do HTTP2
Cody Fincher: clear text. And so this is part of the next thing I'm going to say. Because I work for Google, I'm
Cody Fincher: actively using lots of Kubernetes and Cloud Run mainly. And so most of the things that I deploy
Cody Fincher: are containerized on Cloud Run. And I typically would suggest if you're not using something like
Cody Fincher: SystemD and deploying it directly on bare metal, then you are going to want to let the container
Cody Fincher: or whatever you're using to manage your processes,
Cody Fincher: manage that and spin that up.
Cody Fincher: And so I typically try to allocate,
Cody Fincher: you know, like one CPU for the container
Cody Fincher: and let the actual framework scale it up and down as needed.
Cody Fincher: Cloud Run itself has a, like an ingress,
Cody Fincher: like a load balancer that sits in front
Cody Fincher: that it automatically configures.
Cody Fincher: And you're required to basically serve up
Cody Fincher: clear text traffic in when you run Cloud Run.
Cody Fincher: And because now Gradient supports HTTP2
Cody Fincher: and Cloud Run supports HTTP2 clear text,
Cody Fincher: you can now serve Granian as HTTP2 traffic.
Cody Fincher: The good thing about that is that you get an unlimited upload size.
Cody Fincher: And so there are max thresholds to what you can upload
Cody Fincher: into the various cloud environments.
Cody Fincher: HTTP2 usually circumvents that or gets around it
Cody Fincher: because of the way the protocol works.
Cody Fincher: And so you get additional features and functionality because of that.
Cody Fincher: So anyway, that's what I typically do.
Cody Fincher: And most of my databases are usually Postgres,
Cody Fincher: AlloyDB if it needs to be something that's on the analytical side.
Michael Kennedy: Yeah, I'm on Team Granian as well.
Michael Kennedy: I think that's a super neat framework.
Michael Kennedy: I had Giovanni on who's behind it a while ago.
Michael Kennedy: It seems like it's not as popular,
Michael Kennedy: but it's based on Hyper from the Rust world,
Michael Kennedy: which has like 130,000 projects based on it or something.
Michael Kennedy: So, you know, at its core, it's still pretty battle-tested.
Michael Kennedy: this portion of talk python to me is brought to you by our course just enough python for data
Michael Kennedy: scientists if you live in notebooks but need your work to hold up in the real world check out just
Michael Kennedy: enough python for data scientists it's a focused code first course that tightens the python you
Michael Kennedy: actually use and adds the habits that make results repeatable we refactor messy cells into functions
Michael Kennedy: and packages, use Git on easy mode, lock environments with uv, and even ship with Docker.
Michael Kennedy: Keep your notebook speed, add engineering reliability.
Michael Kennedy: Find it at Talk Python Training.
Michael Kennedy: Just click courses in the navbar at talkpython.fm.
Michael Kennedy: Yannick, how about you?
Michael Kennedy: You've got a variety, it sounds like.
Michael Kennedy: Yeah, definitely.
Janek Nouvertné: There's a pretty clear split between what I do at work and what I do outside of that.
Janek Nouvertné: So at work, it's Kubernetes deployments.
Janek Nouvertné: And we managed that pretty much the same way that Cody described.
Janek Nouvertné: So it's one or two processes per pod max.
Janek Nouvertné: So you can have Kubernetes scaled or even manually easily scale that up.
Janek Nouvertné: You can just go into Kubernetes and say, OK, do me one to five more pods or whatever.
Janek Nouvertné: And don't have to worry.
Janek Nouvertné: Don't have to start calculating whatever.
Janek Nouvertné: Most of the stuff we run nowadays with uv corn or Django deployment
Janek Nouvertné: up until I think three months ago or so was running under the Unicorn,
Janek Nouvertné: but we switched that actually.
Janek Nouvertné: And it's been a really great experience.
Janek Nouvertné: I think we tried that a year ago and it didn't work out quite so well.
Janek Nouvertné: There was some things that didn't work as expected or didn't perform great
Janek Nouvertné: or Django was throwing some errors or Uvicorn was throwing some errors.
Janek Nouvertné: And then apparently all of that got fixed
Janek Nouvertné: because now it runs without any issue for the production.
Michael Kennedy: Yeah, for people who don't know, the vibe used to be run G Unicorn, but then with UVicorn workers, if you're doing async stuff.
Michael Kennedy: And then UVicorn kind of stepped up its game and said, you can actually treat us as our own app server.
Michael Kennedy: We'll manage lifecycle and stuff.
Michael Kennedy: And so that's the path you took, right?
Janek Nouvertné: Yeah, exactly.
Janek Nouvertné: Before that.
Janek Nouvertné: Well, no, actually, before that, we didn't because our Django is fully synchronous.
Janek Nouvertné: It doesn't do any async.
Janek Nouvertné: So it was just bare metal G Unicorn.
Janek Nouvertné: And it's still synchronous with just running it under UVcorn.
Janek Nouvertné: But interestingly, still quite a bit faster in a few cases.
Janek Nouvertné: We tried that out and we low tested it in a couple of scenarios
Janek Nouvertné: and we found that it makes a lot of sense.
Janek Nouvertné: But outside of that, I do have a lot of, well,
Janek Nouvertné: very simplistic deployments that are also just systemd
Janek Nouvertné: and a couple of Docker compose files and containers
Janek Nouvertné: that are managed through some old coupled together Ansible things.
Janek Nouvertné: But I think the oldest one that I have still running is from 2017.
Janek Nouvertné: And it's been running without a change for like four or five years.
Janek Nouvertné: That is awesome.
Janek Nouvertné: I don't see a reason to do anything about it because the app works.
Janek Nouvertné: It's being used productively.
Janek Nouvertné: So why change anything about that?
Janek Nouvertné: No need to introduce.
Janek Nouvertné: Just don't touch it.
Janek Nouvertné: Yeah, I was actually looking into Coolify that you two guys mentioned.
Janek Nouvertné: I was thinking about, you know, maybe upgrading it to that, but I played around with it and I thought, well, why?
Janek Nouvertné: You know, if I have to look into that deployment maybe once a year.
Janek Nouvertné: So that's really nothing to gain for me to make it more complicated.
Janek Nouvertné: David, Team Flask.
David Lord: I mentioned this before the show started, but I think I'm pretty sure I've said this the last time I was on Talk Python,
David Lord: but the projects I do for work typically have less than 100 users.
David Lord: And so my deployment is usually really simple.
David Lord: And usually they've chosen like Azure or AWS already.
David Lord: So we just have a Docker container
David Lord: and we put it on the relevant Docker container host
David Lord: in that service and it just works for them.
David Lord: We have a Postgres database and we have like Redis.
David Lord: But I never really had to deal with like scaling
David Lord: or that sort of stuff.
David Lord: But the funny thing is like, at least for my work,
David Lord: I'm always, we're often replacing older systems.
David Lord: And so even a single Docker container running a Flask application is way more performant and responsive than anything they're used to from like some 20 year old or 30 year old Java system.
David Lord: Right. And it can just respond on a small container with like a little bit of CPU and a little bit of memory.
David Lord: They're always shocked at like, how much do we need to pay for?
David Lord: Oh, just like it'll run a potato.
David Lord: You know, there's only 100 users and they're like, that's a lot of users.
David Lord: So my recommendation is always start small and then scale up from there.
David Lord: Don't try to overthink it ahead of time.
David Lord: Yeah, for my personal stuff, I'm using like Docker containers now and fly.io.
David Lord: I haven't gotten in.
David Lord: So I do want to look into Granian and Coolify, but I haven't gotten there yet.
David Lord: And for the Docker container, I can definitely recommend pythonspeed.org.
David Lord: I don't remember off the top of my head who writes that, but it's somebody in the Python
David Lord: ecosystem.
David Lord: And they have a whole series of articles on how to optimize your Docker container.
David Lord: And that sounds really complicated, but you end up with a Docker file that's like 20 lines
David Lord: long or something.
David Lord: So it's not like there's crazy things.
David Lord: It's just you have to know how to structure it.
David Lord: And then I just copy and paste that to the next project.
David Lord: Nice.
David Lord: Yeah.
Michael Kennedy: I resisted doing Docker for a long time because I'm like, I don't want that extra complexity.
Michael Kennedy: But then I realized the stuff you put in the Docker file is really what you just type in
Michael Kennedy: the terminal once and then you forget.
David Lord: I mean, always using Postgres, Redis, probably if I need some background.
David Lord: tasks, just plain SMTP server for email. I wrote for all three of those things. I wrote new
David Lord: extensions in the Flask ecosystem that I'm trying to get more people to know about now. So Flask
David Lord: SQLAlchemy Lite, L-I-T-E, instead of Flask SQLAlchemy, takes a much more lightweight approach to
David Lord: integrating SQLAlchemy with Flask. And then Flask Redis, I revived from like 10 years of
David Lord: non-maintenance. And then I wrote this whole system, this whole pluggable email system called
David Lord: email simplified, kind of inspired by Django, Django's pluggable system, except, and so there's
David Lord: like Flask email simplified to integrate that with Flask. But unlike Django, you can use email
David Lord: simplified in any library you're writing, in any Python application you're writing. It doesn't have
David Lord: to be a Flask web framework. It's pluggable as the library itself. And then you can also integrate
David Lord: it with Flask or something else. So Flask email simplified. I get like three downloads a month
Michael Kennedy: right now. So it needs some popularity. Awesome. I've been doing the non-simplified email lately.
Michael Kennedy: So I'm happy to hear that there might be a better way. Yeah. I think people do underappreciate just
Michael Kennedy: how much performance you got out of Python web apps. You know, they're like, oh, we're going to
Michael Kennedy: need to rewrite this and something else because the GIL or whatever. Like I decided just to make
Michael Kennedy: a point to pull up the tail till my log running court, by the way. And each one of these requests
Michael Kennedy: doing like multiple db calls and it's like 23 milliseconds six milliseconds three milliseconds
Michael Kennedy: you know nine milliseconds it's like that's good enough for that's a lot of requests per second
Michael Kennedy: per worker until you gotta you gotta have a lot of traffic speaking of court phil what's your take
Phil Jones: on this one i think it's very similar i also build docker containers and uh with a postgres database
Phil Jones: on the back end and i run hypercorn as the ascii server and put them behind a aws load balancer
Phil Jones: and just run them in ECS.
Phil Jones: And I think it's pretty simple,
Phil Jones: but I guess it depends on your biases.
Phil Jones: But yeah, that's all we do really.
Phil Jones: And it goes a long way.
Phil Jones: There are multiple ECS tasks,
Phil Jones: mostly because if one falls over rather than scaling,
Phil Jones: it's usually the database that you need to scale, I find.
Phil Jones: But yeah, that's how we run it.
Phil Jones: The nice thing for me about Hypercorn
Phil Jones: is that I can play with HTTP 3.
Phil Jones: So that's what we're doing at times.
Michael Kennedy: Oh, HTTP 3, okay.
Michael Kennedy: I've just been getting my HTTP 2 game down,
Michael Kennedy: so I'm already behind the game.
Michael Kennedy: What's the deal with HTTP/3?
Phil Jones: It's obviously a totally new way of doing it over UDP now
Phil Jones: rather than TCP.
Phil Jones: Although at the application level,
Phil Jones: you can't tell any difference really.
Phil Jones: But I mean, I just find it interesting.
Phil Jones: I'm not really sure it will help too much.
Phil Jones: And it's probably best if you've got users who have not that
Phil Jones: great a network connection.
Phil Jones: But for most other cases, I don't think it matters too much.
Michael Kennedy: Just keep blasting packets until some of them get through.
Michael Kennedy: OK, fine.
Michael Kennedy: We'll give you a page eventually.
Michael Kennedy: There's three pages, actually.
Michael Kennedy: All right, Sebastian, you are running not just FastAPI from your experience, but you're running FastAPI for a ton of people through FastAPI Cloud at, I'm sure, many different levels.
Michael Kennedy: This probably sounds like a shameless plug, and it kind of is, but it's sort of expected.
Michael Kennedy: I will deploy FastAPI or FastAPI Cloud.
Michael Kennedy: Just because, well, the idea is just to make it super simple to do that.
Michael Kennedy: You know, like if you are being able to run the command FastAPI run.
Michael Kennedy: So FastAPI run has like the production server
Michael Kennedy: that is using Ubicorn underneath.
Michael Kennedy: And if you can run that,
Michael Kennedy: then you can run also FastAPI deploy.
Michael Kennedy: And then like, you know, like it will most probably just work.
Michael Kennedy: And, you know, we just wrap everything and like deploy,
Michael Kennedy: build, install, deploy, handle HTTPS, all the stuff
Michael Kennedy: without needing any Docker file or anything like that.
Michael Kennedy: And I think for many use cases,
Michael Kennedy: it's just like simpler being able just to do that.
Michael Kennedy: There are so many projects that I have been now building,
Michael Kennedy: like random stuff that is not really important, but now I can.
Michael Kennedy: And before it was like, yeah, well, I know how to deploy this thing like fully with like
Michael Kennedy: all the bells and whistles, but it's just so much work that yeah, I know later.
Michael Kennedy: So for that, I would end up just like going with that.
Michael Kennedy: Now if I didn't...
Michael Kennedy: Well, what I was going to ask is how much are you willing to tell us how things run inside
Michael Kennedy: FastAPI Cloud?
Michael Kennedy: Oh, I can't, it's just so much stuff that is going on.
Michael Kennedy: And it's also, it's fun that nowadays that they're like,
Michael Kennedy: we have Docker and we have Docker Swarm and there was Nomad
Michael Kennedy: and Kubernetes and oh, Kubernetes won.
Michael Kennedy: And then we have the cloud providers and there's AWS
Michael Kennedy: and Google and Azure.
Michael Kennedy: And you will expect that all these things
Michael Kennedy: and all this complexity is like, now that it's like, okay,
Michael Kennedy: these are the clear winners.
Michael Kennedy: So it's like a lot of complexity to take on,
Michael Kennedy: but once you do it all works, but it doesn't.
Michael Kennedy: And it's just like so much work to get things to work together, to work correctly.
Michael Kennedy: And the official resources from the different providers and things,
Michael Kennedy: in many cases, it's like, oh, the solution is hidden in this issue somewhere in GitHub
Michael Kennedy: because the previous version was obsolete,
Michael Kennedy: but now the new version of this package or whatever is like, it's just, it's crazy.
Michael Kennedy: But like, yeah, so if I didn't have FastAPI Cloud, I will probably use containers.
Michael Kennedy: I will probably use Docker.
Michael Kennedy: If it's like something simple,
Michael Kennedy: I will deploy with Docker Compose,
Michael Kennedy: probably try to scale minimum replicas.
Michael Kennedy: I don't remember Docker Compose has that.
Michael Kennedy: I remember that Docker Swarm had that,
Michael Kennedy: but then Docker Swarm sort of lost against where Net is.
Michael Kennedy: I will put a traffic load balancer in front
Michael Kennedy: to handle HTTPS and, yeah, well, like regular load balancing.
Michael Kennedy: And, yeah, just regular YubiCorn.
Michael Kennedy: What some of the folks we were talking about before,
Michael Kennedy: At some point, we needed to have Unicorn on top of Uvicorn
Michael Kennedy: because Uvicorn wouldn't be able to handle workers.
Michael Kennedy: But now Uvicorn can handle its workers like everything
Michael Kennedy: and handle the main thing was some VE processes
Michael Kennedy: and reaping the processes and handling the stuff.
Michael Kennedy: Now it can't just do that.
Michael Kennedy: So you can just run plain Uvicorn.
Michael Kennedy: So if you're using FastAPI and you say FastAPI run,
Michael Kennedy: that already does that.
Michael Kennedy: So if you're deploying on your own,
Michael Kennedy: you can just use the FastAPI run command.
Michael Kennedy: Then, of course, you have to deal with the scaling
Michael Kennedy: and HTTPS and a lot of balancing
Michael Kennedy: and all the stuff,
Michael Kennedy: but the core server,
Michael Kennedy: you can just run it directly.
Michael Kennedy: If going beyond that,
Michael Kennedy: then there will probably be
Michael Kennedy: some cluster Kubernetes
Michael Kennedy: and trying to scale things,
Michael Kennedy: figure out the ways to scale things
Michael Kennedy: based on the load of the requests,
Michael Kennedy: like scaling automatically.
Michael Kennedy: Having normally one container per process
Michael Kennedy: to be able to scale that more dynamically
Michael Kennedy: without depending on the local memory
Michael Kennedy: for each one of the servers
Michael Kennedy: and things like that,
Michael Kennedy: I'm probably saying too much.
Michael Kennedy: But yeah, actually, you know, like if I didn't have a CPI cloud,
Michael Kennedy: I will probably use one of the providers that abstract those things a little bit away,
Michael Kennedy: you know, like render, railway, fly, like, I don't know.
Michael Kennedy: Like, I don't really think that a regular developer should be dealing with,
Michael Kennedy: you know, like the big hyperscalers and like Kubernetes
Michael Kennedy: and like all that complexity for a common app.
Michael Kennedy: Most of the cases, I think it's just really too much complexity to real with.
Michael Kennedy: It's kind of eye-watering to open up the AWS console or Azure or something.
Michael Kennedy: Whoa.
Michael Kennedy: Oh, the other day, you know, like the other day I had to, in one of the AWS accounts, I had to change the account email.
Michael Kennedy: I think I spent four hours.
Michael Kennedy: I know.
Michael Kennedy: Because I had to create the delegate account that has the right permissions to roll.
Michael Kennedy: And they're like, oh, no, this is, you know, like,
Michael Kennedy: sometimes it's just overwhelming the amount of complexity
Michael Kennedy: that needs to be dealt with.
Michael Kennedy: And, yeah, I mean, it's great to really have, like,
Michael Kennedy: you know, like the infra people that I have working with me
Michael Kennedy: at the company that I can deal with all that mess
Michael Kennedy: and, like, can make sure that everything is just running perfectly
Michael Kennedy: and it just works.
Michael Kennedy: So it's like, you know, like, sort of SRE as a service,
Michael Kennedy: DevOps as a service for everyone.
Michael Kennedy: It's like a cloud product that provides DevOps as a service,
Cody Fincher: I spent a number of years doing nothing but cloud migrations to these hyperscalers for enterprises.
Cody Fincher: And I can tell you that when you mentioned the eye-watering comment about the network and all that stuff,
Cody Fincher: it's so incredibly complicated now, right?
Cody Fincher: There's literally every kind of concept that you need to know to deploy these enterprises now,
Cody Fincher: move them from on-prem to the cloud.
Cody Fincher: So it does get incredibly complicated.
Cody Fincher: Having something simple like what Sebastian is talking about, I think, is super helpful
Cody Fincher: when you're just trying to get started
Cody Fincher: and get something up and running quickly.
Michael Kennedy: I've got a lot of questions
Michael Kennedy: and I realize that we will not be getting through all of them.
Michael Kennedy: So I want to pick carefully.
Michael Kennedy: So let's do this one next.
Michael Kennedy: Performance, what's your best low effort tip?
Michael Kennedy: Not like something super complicated,
Michael Kennedy: but I know there's a bunch of low hanging fruit
Michael Kennedy: that people maybe missed out on.
Michael Kennedy: And this time let's start with Litestar.
Michael Kennedy: Cody, back at you.
Cody Fincher: I'm going to stick to what I know,
Cody Fincher: which is databases because I deal with that.
Cody Fincher: every single day. There's a couple of things that I see as like gotchas that I constantly see over
Cody Fincher: and over. One, SQLAlchemy kind of obfuscates the way it's going to execute things and what kind of
Cody Fincher: queries it's going to actually execute. So it's really easy if you're not kind of fluent in how
Cody Fincher: it works to create N plus one types of issues. And so when people start talking about sync or async,
Cody Fincher: it's really, in my mind, it's less of that because you're going to spend more time waiting on the
Cody Fincher: network and database and those kind of things, then you're going to spend serializing just
Cody Fincher: generally, right? And or processing things on the web framework. And so, one, making sure that you,
Cody Fincher: your relationships dialed in correctly so that you don't have N plus one queries. The other thing is
Cody Fincher: oversized connection pooling into Postgres and just databases in general, because what people don't
Cody Fincher: tend to know is that each of those connections takes up CPU cycles and RAM of the database.
Cody Fincher: And so when you slam the database with hundreds of connections, you're just taking away processing power that can be done for other things, right?
Cody Fincher: And so you end up ultimately slowing things down.
Cody Fincher: So I've seen databases that have had so many connections that all of the CPU and all the stuff is actually doing things, just managing connections and can't actually do any database work.
Michael Kennedy: And so what about this socket?
Michael Kennedy: Is it busy?
Michael Kennedy: What about this socket?
Michael Kennedy: Is it busy?
Michael Kennedy: It's just round robin that, right?
Cody Fincher: Paying attention to the database is kind of my first kind of rule of thumb.
Michael Kennedy: 100%.
Michael Kennedy: I like that one a lot.
David Lord: I'll throw in putting stuff or identifying work that doesn't need to be done immediately for the user and putting in a background task.
David Lord: Having a background worker defer things till later.
David Lord: So sending email is an example, although there's nuances there about knowing that it's sent and everything.
David Lord: But yeah, if you user kicks off some process and then you wait to do that process in the worker, you're holding that worker up, which is more relevant in WSGI than ASGI.
David Lord: but and you're making them wait for their page to load again versus record what they wanted to do
David Lord: send it off to the background let them see the status of it but let the background worker handle
Michael Kennedy: it all right yeah like i said as you guys go for it i'm not sure if that's some sort of
Janek Nouvertné: it's not really a trick or a tip or more more like a i think the most common mistake i see when i
Janek Nouvertné: is ascii specific but when i look at ascii apps that people have written who are maybe not as
Janek Nouvertné: familiar with ASCII or async Python at all, if you make something an async function, you should be
Janek Nouvertné: absolutely sure that it's non-blocking. Because if you're running an ASCII app and you're blocking
Janek Nouvertné: anywhere, your whole application server is blocked completely. It doesn't handle any other requests
Janek Nouvertné: at the same time. It's blocked. I don't think I've had any mistake more times when I've looked through
Janek Nouvertné: some apps that someone has written or that i've came across somewhere so this is really it's super
Janek Nouvertné: super common and it has such a such a big impact on the overall performance in every every metric
Janek Nouvertné: imaginable so i would say unless and that's nowadays what i tell people unless you're 100
Janek Nouvertné: sure that you know what you're doing and you know it's it's non-blocking don't make it async put it
Janek Nouvertné: in a thread pool, execute it in a thread, whatever.
Janek Nouvertné: All of the ASCII frameworks and Django
Janek Nouvertné: give you a lot of tools at hand to translate your stuff
Janek Nouvertné: to from sync to async so you can still run it.
Janek Nouvertné: Do that unless you're very sure that it actually fully supports
Janek Nouvertné: async.
Michael Kennedy: MARK MANDEL: Yeah, that's good advice.
Michael Kennedy: Sebastian.
Michael Kennedy: SEBASTIAN BASTIAN: Hey, I'm actually going to second, Yannick.
Michael Kennedy: I think, yeah, like it's--
Michael Kennedy: and it's maybe counterintuitive that one
Michael Kennedy: of the tips of performance is to try to not optimize that much performance at the beginning.
Michael Kennedy: You know, like, I think the idea with async is like, oh, you can get so much performance
Michael Kennedy: and throughput in terms of accuracy, whatever.
Michael Kennedy: But the thing is, in most of the cases, you know, like, till apps grow so large, they
Michael Kennedy: actually don't need that much extra throughput, that much extra performance.
Michael Kennedy: And in a framework like, you know, like, as Yannick was saying, well, in my case, I know
Michael Kennedy: FastAPI, but like, you know, like also many others.
Michael Kennedy: If you define the function with async, it's going to be run async.
Michael Kennedy: If you define it non-async and regular def,
Michael Kennedy: it's going to be run on a thread worker automatically.
Michael Kennedy: So it's just going to do the smart thing automatically.
Michael Kennedy: So it's like fair, you know, like it's going to be good enough.
Michael Kennedy: And then you can just start with that and just keep blocking code everywhere.
Michael Kennedy: You know, like just not use async until you actually know
Michael Kennedy: that you really need to use async.
Michael Kennedy: And once you do, you have to be, as Yannick was saying,
Michael Kennedy: you know, like 100% sure that you are not running blocking code inside of it.
Michael Kennedy: And if you need to run blocking code inside of Async code,
Michael Kennedy: then make sure that you are sending it to a thread worker.
Michael Kennedy: Sending it to a thread worker sounds the own thing,
Michael Kennedy: but yeah, like, you know, like Django has tools,
Michael Kennedy: any IO has tools.
Michael Kennedy: I also built something on top of any IO called AsyncR,
Michael Kennedy: that is just to simplify these things,
Michael Kennedy: to asyncify a blocking function,
Michael Kennedy: keeping all the type information
Michael Kennedy: so that you get autocompletion and inline errors and everything.
Michael Kennedy: even though it's actually doing all the stuff
Michael Kennedy: of sending the thing to the thread work.
Michael Kennedy: So the code is super simple.
Michael Kennedy: You keep very simple code,
Michael Kennedy: but then underneath it's just like doing
Michael Kennedy: all the stuff that should be done.
Michael Kennedy: But you know, like that's normally
Michael Kennedy: when you actually need to hyper-optimize things.
Michael Kennedy: In most of the cases,
Michael Kennedy: you can just start with just not using async at first.
Michael Kennedy: Also, now that you're going to have Python multi-threaded,
Michael Kennedy: then suddenly you're going to have
Michael Kennedy: just so much more performance out of the blue
Michael Kennedy: without even having to do much more.
Michael Kennedy: So, yeah, actually that's, you know, like, sorry, I kept speaking so much, but here's a tip for improving performance.
Michael Kennedy: Upgrade your Python version.
Michael Kennedy: I was just chatting today with Savannah.
Michael Kennedy: She was adding the benchmarks to the, you know, like Python benchmark, the official Python benchmarks that they run for the CPython, the faster CPython program.
Michael Kennedy: And the change from Python 3.10 to Python 3.14
Michael Kennedy: when running FastAPI is like almost double the performance
Michael Kennedy: or something like that.
Michael Kennedy: It was like, it was crazy.
Michael Kennedy: It was just crazy improvement in performance.
Michael Kennedy: So you can just upgrade your Python version.
Michael Kennedy: You're gonna get so much better performance just out of that.
Michael Kennedy: - Yeah, that's an awesome piece of advice
Michael Kennedy: that I think is often overlooked.
Michael Kennedy: And it's not only CPU speed,
Michael Kennedy: it's also memory gets a lot lower.
Michael Kennedy: Whoever's gonna jump in, go ahead.
David Lord: Last year, I was looking at MarkupSafe, which is an HTML escaping library that we use and
David Lord: has a C extension for speedups.
David Lord: And I almost convinced myself that I can stop maintaining the C extension because just Python
David Lord: itself got way faster.
David Lord: But then it turned out that I could do something to the C extension to make it faster also.
David Lord: So I'm still maintaining.
David Lord: But just the fact that I almost convinced myself like, oh, I can drop a C extension for just
David Lord: a Python upgrade instead was pretty impressive.
David Lord: They've done a lot, especially with like string handling
David Lord: and, you know, which you're going to use
David Lord: for templating for web apps.
Phil Jones: Phil.
Phil Jones: Yeah, well, I definitely echo looking at your DB queries
Phil Jones: because by far and large, that's always where
Phil Jones: our performance issues have been.
Phil Jones: It's either badly written query or we're returning
Phil Jones: most of the database when the user just wants to know
Phil Jones: about one thing or something silly like that.
Phil Jones: I was thinking about low-hanging ones,
Phil Jones: which I think you asked about.
Phil Jones: So I'd say uv loop, which is still a noticeable improvement.
Phil Jones: And also, because I think it's likely a lot of us are returning JSON, often changing the
Phil Jones: JSON serializer to one of the faster ones can be noticeable as well and obviously quite easy to do.
Michael Kennedy: So yeah, that's my key.
Michael Kennedy: That's really good advice.
Michael Kennedy: I didn't think about the JSON serializer.
Michael Kennedy: What one do you recommend?
Michael Kennedy: I think, is it you, JSON?
Michael Kennedy: Or is it all JSON?
Phil Jones: I can't remember which one was deprecated.
Phil Jones: But yeah, if you look at the Tech Empower benchmarks, everyone's changing the JSON serializer
Phil Jones: to get that bit extra speed.
Michael Kennedy: But yeah, you're like, our framework looks bad because our JSON serializer is like third
Michael Kennedy: of the performance.
Phil Jones: We changed, well, David added a JSON provider to Flask.
Phil Jones: And yeah, you could see it make a difference in the tech and power benchmarks.
Phil Jones: So that was really good.
Phil Jones: Yeah, cool.
David Lord: Yeah, it's pluggable now.
David Lord: But if you're not installing Flask or JSON, I mean, I don't know what other JSON library
David Lord: you'd be using at this point, unless you're already using one.
David Lord: But or JSON is very, very fast.
Michael Kennedy: Okay, this is something I'm going to be looking at you later.
Michael Kennedy: So over to Django, Jeff, David talked about running stuff in the background and was it Django 5 or Django 6 that got the background task thing?
Jeff Triplett: Yeah, Django 6 just came out a couple of weeks ago.
Jeff Triplett: And I'll hand that off to Carlton in a second because I think Carlton's had more to do with the actual plumbing being on the steering council.
Jeff Triplett: My advice to people is the best way to scale something is just to not do it, avoid the process completely.
Jeff Triplett: So like I mentioned to CDN earlier, it's content heavy sites, cache the crap out of stuff.
Jeff Triplett: It doesn't even have to hit your servers.
Jeff Triplett: You can go a lot, as we mentioned earlier, too, just by doubling the amount of resources a project has.
Jeff Triplett: Django is pretty efficient these days, especially with async views.
Jeff Triplett: Like everybody else has said, too, any blocking code, move off to threads, move off to a background queue.
Jeff Triplett: Django Q2 is my favorite one to use because you can use a database.
Jeff Triplett: So for those little side projects where you just want to run one or two processes, you can use it.
Jeff Triplett: It works great.
Jeff Triplett: And Carlton, if you want to talk about Django internals.
Carlton Gibson: Yeah, OK.
Carlton Gibson: So the new task framework I just mentioned, the main thing, the main sort of bit about it is that it's, again, this pluggable Django API.
Carlton Gibson: So it gives a standard task API.
Carlton Gibson: So if you're writing a third-party library and you, I know, you need to send an email.
Carlton Gibson: It's the canonical example, right?
Carlton Gibson: You need to send an email in your third-party library.
Carlton Gibson: Before, you'd have had to tie yourself to a specific queue implementation, whereas now Django is providing a kind of like an ORM of tasks.
Carlton Gibson: Right, right.
Michael Kennedy: You got to do Redis, you got to do Celery, and you got to manage things and all that.
Carlton Gibson: You don't have to pick that now as the third-party package author.
Carlton Gibson: You can just say, right, just use Django,
Carlton Gibson: wrap this as a Django task and queue it.
Carlton Gibson: And then the developer, when they come to choose their backend,
Carlton Gibson: if they want to use Celery or they want to use Django Q2
Carlton Gibson: or they want to use the Django task backend,
Carlton Gibson: which Jake Howard, who wrote this for Django provided as well,
Carlton Gibson: you can just plug that in.
Carlton Gibson: So it's a pluggable interface for tasks,
Carlton Gibson: which is, I think, the really nice thing about it.
Carlton Gibson: In terms of quick wins, everybody's mentioned almost all of mine.
Carlton Gibson: I'm going to, Cody and Phil, they mentioned the database.
Carlton Gibson: That's the big one.
Carlton Gibson: Django, the ORM, because it does lazy related lookups,
Carlton Gibson: it's very easy to trigger in M plus one where, you know,
Carlton Gibson: the book has multiple authors and suddenly you're iterating through the books
Carlton Gibson: and you're iterating through the authors and it's a lookup.
Carlton Gibson: So you need to do things like prefetch related, select related.
Carlton Gibson: You need to just check that you've got those.
Carlton Gibson: Django debug toolbars are a great thing to run in development
Carlton Gibson: where you can see the queries and it'll tell you where you've got the duplicates.
Carlton Gibson: And then the slightly bigger one is to just check your indexes.
Carlton Gibson: The ORM will create the right indexes if you're leaning,
Carlton Gibson: if you're going through primary keys or unique fields.
Carlton Gibson: But sometimes you're doing a filter on some field,
Carlton Gibson: and then there's not the right index there,
Carlton Gibson: and that can really slow you down.
Carlton Gibson: So again, you can do the SQL explain on that and find that.
Carlton Gibson: And then the thing I was going to say originally was caching,
Carlton Gibson: is get a Redis instance, stick it next to your Django app,
Carlton Gibson: and as Jeff said, don't do the work.
Carlton Gibson: If you're continually rendering the same page and it never changes,
Carlton Gibson: cache it and pull it from the cache rather than rendering.
Carlton Gibson: Because template DB queries are one of your biggest things.
Carlton Gibson: The second one's always going to be serialization.
Carlton Gibson: It's either serialization or template rendering.
Michael Kennedy: So if you can avoid that by caching, you can save an awful lot of time on your account.
Michael Kennedy: Yeah.
Michael Kennedy: I was wondering if somebody would come back with database indexes,
Michael Kennedy: because that's like a 100x multiplier for free almost.
Michael Kennedy: It's such a big deal.
Carlton Gibson: It really can be.
Carlton Gibson: If you're making a particular query and it's doing a full table scan
Carlton Gibson: all of a sudden you put the index in, it's instant. It's like, oh, wow. You don't have to be a DBA or
Michael Kennedy: master information architect sort of thing. I don't know about Postgres. I'm sure it has it.
Michael Kennedy: Somebody can tell me. But with Mongo, you can turn on in the database, I want you to log all
Michael Kennedy: slow queries and slow for me means 20 millisecond or whatever. Like you put a number in and then
Michael Kennedy: you run your app for a while and you go, look at what's slow by slowest. And then you can see,
Michael Kennedy: well, maybe that needs an index, right? Like just let your app tell you what you got to do.
Carlton Gibson: Yeah, there is a post.
Carlton Gibson: I'm just trying to see if I can quickly look it up now.
Carlton Gibson: There's a Postgres extension,
Carlton Gibson: which will automatically run explain
Carlton Gibson: on the slow queries and log them for you.
Carlton Gibson: So it'll...
Carlton Gibson: There you go.
Cody Fincher: See if I can find...
Cody Fincher: It's pgstat statements, I think,
Cody Fincher: is what you're thinking about.
Cody Fincher: Right, okay.
Michael Kennedy: If you're unsure about your database indexes,
Michael Kennedy: do this, or at least go back and review your queries.
Michael Kennedy: Yeah, I agree.
Michael Kennedy: Very good.
Michael Kennedy: All right, I can see we're blazing through these questions.
David Lord: I had one more.
David Lord: If I can mention one.
David Lord: No, please go ahead.
Michael Kennedy: Yeah, go ahead, David.
David Lord: If you want to like get some more responsive parts of your website, like make your website a little more responsive or interactive with the user, HTMX or Datastar, especially like if you're using Cort or another ASGI where you can do SSE, server sent events or WebSockets, streaming little bits of changes to the web front end and then rendering them with the same HTML you're already writing can make things a lot more responsive.
David Lord: We had talk about that from Chris May at FlaskCon last year, which you can find on YouTube.
Michael Kennedy: This is not one of the questions, but let me just start out for a quick riff on this, folks.
Michael Kennedy: Out in the audience, someone was asking, what about HTMX?
Michael Kennedy: And I think more broadly, I am actually a huge fan of server-side-based, template-based apps.
Michael Kennedy: I think it just keeps things simpler in a lot of ways, unless you need a lot of interactivity.
Michael Kennedy: But things like HTMX or a little bit of JavaScript can reduce a lot of the traffic and stuff.
Michael Kennedy: Where do people land on those kinds of things?
Janek Nouvertné: I absolutely love HTMLX, not just because you don't have to write a lot of JavaScript or whatever,
Janek Nouvertné: but mostly because if I'm just building a simple app that needs a bit more than just be a static HTML page,
Janek Nouvertné: it needs some interactivity, a little bit of reactivity.
Janek Nouvertné: I feel like having the whole overhead of building an SPA or whatever tools you need for the whole JavaScript, TypeScript, whatever stack, it's just so much work to get a little bit to make a simple thing a little bit nicer, a little bit more reactive.
Janek Nouvertné: And I feel like HTMX just fits right in there.
Janek Nouvertné: It's super great.
Janek Nouvertné: I've built a couple of things with it now,
Janek Nouvertné: a few of my own projects, a few things that work.
Janek Nouvertné: And it makes things so much easier
Janek Nouvertné: where the work probably wouldn't have been done
Janek Nouvertné: if it was just because it's too much.
Janek Nouvertné: If you're doing a whole front end thing
Janek Nouvertné: that you have then to deploy and build and whatever,
Janek Nouvertné: or it would have been less nice.
Janek Nouvertné: So it's an amazing, really amazing thing.
Cody Fincher: As the maintainer and author, though, one of the things that is not frustrating, but it's understandable is that HTMX is not for everybody, right?
Cody Fincher: There's not like you can't use HTMX in all occasions or Datastar, right?
Cody Fincher: And so there are people that are always going to want to use React and there's going to be people that want to use all these other frameworks.
Cody Fincher: And so having some cohesive way to make them all talk together, I think, is important.
Cody Fincher: I don't have that answer yet, but I just know that like I can't always say HTMX is it, right?
Cody Fincher: And then you'll have a great time because I'll inevitably meet somebody that says I need to do this.
Cody Fincher: And it's right. And it's in a single page application or something is more appropriate for that.
Cody Fincher: And so it's obviously the right tool for the right job when you need it.
Cody Fincher: But, you know, I want to make something that is cohesive depending on whatever library you want to use.
Jeff Triplett: I would throw one thing in there, though.
Jeff Triplett: I would rather somebody start with HTMX than I would start with React if you don't need it.
Jeff Triplett: Because React can be total overkill. It can be great for some applications.
Jeff Triplett: But oftentimes the consultant, we see people like having an about page and they throw a React at it.
Jeff Triplett: Like, why do you need that?
Jeff Triplett: Like, especially for small things with partials.
Jeff Triplett: Do you mean you don't want to start with Angular?
Jeff Triplett: You know, it's fine if you need it,
Jeff Triplett: but I don't think you really need it.
Jeff Triplett: Like, introduce tools as you need them.
Jeff Triplett: Django 6.0 just added template partials,
Jeff Triplett: and I guess my job here is to hand off to Carlton
Jeff Triplett: because this is his feature.
Michael Kennedy: Yeah, I was happy to see that come in there, Carlton.
Michael Kennedy: Nice job.
Carlton Gibson: No, it's okay.
Carlton Gibson: Plug the new feature.
Carlton Gibson: So, I mean, I stepped down as a fellow in 2023
Carlton Gibson: into a new business,
Carlton Gibson: and I read the essay about template fragments
Carlton Gibson: on the htmx website where it's this like named reusable bits in the in the templates and i was
Carlton Gibson: like i need that so i built django template partials released as a third-party package and it's now just
Carlton Gibson: been merged into core for django 6.0 and i have to say about htms it's really changed the way i write
Carlton Gibson: websites before i was the fellow i used to write mobile applications and do the back do the front
Carlton Gibson: end of the mobile application then the back end in django using django rest framework and i was
Carlton Gibson: that's how i got into you know open source was by django rest framework and since starting the
Carlton Gibson: we're three years in we've hardly got a json endpoint in sight it's like two three four of
Carlton Gibson: them in the whole application and it's oh it's just a delight again you know you asked me at the
Carlton Gibson: beginning michael am i having fun yeah i really am having fun and htmx is the reason i do grant
Michael Kennedy: there are you know these use cases awesome all right let's talk about our last topic and we have
Michael Kennedy: five minutes ish to do that so we gotta we gotta stay on target quick but let's just go around
Michael Kennedy: run real quick here we talked about upgrading the python version getting better performance out of
Michael Kennedy: it i mentioned the lower memory side but i think one of the underappreciated aspects of this you
Michael Kennedy: know the instagram team did a huge talk you know on it a while ago is the memory that you run into
Michael Kennedy: when you start to scale out your stuff on the server because you're like oh i want to have four
Michael Kennedy: workers so i can have more concurrency because of the gills so now you've got four copies of
Michael Kennedy: everything that you cache in memory and just like the runtime and now you need eight gigs instead of
Michael Kennedy: what would have been one or who knows right but with free threaded python coming on which i've
Michael Kennedy: seen a couple of comments in the chat like hey tell us about this like it's we could have true
Michael Kennedy: concurrency and we wouldn't need to scale as much on the process side i think giving us both better
Michael Kennedy: performance and the ability to say well you actually have four times less memory so you could
Michael Kennedy: run smaller servers or whatever what's the free threaded story for all the frameworks carlton
Carlton Gibson: let's go back to you for do it in reverse i'm really excited about it i don't know how it's
Carlton Gibson: going to play out but i'm really excited about it all it can do is help django the async story in
Carlton Gibson: django is nice and mature now uh but still most of it's sync like you know you're still going to
Carlton Gibson: default the sync you're still going to write your sync views you still got template rendering you
Carlton Gibson: know django's template template based kind of framework really you're still going to want to
Carlton Gibson: run things synchronously, concurrently, and proper threads are going to be, yeah, they can't but help.
Carlton Gibson: I don't know how it's going to roll out. I'll let someone else go because I'm getting locked up.
Michael Kennedy: Yeah, I just like elaborated that for people out there before we move on is you could set up your
Michael Kennedy: worker process to say, I want you to actually run eight threads in this one worker process.
Michael Kennedy: And when multiple requests come in, they could both be sent off to the same worker to be processed.
Michael Kennedy: And that allows that worker to do more unless the GIL comes along and says, stop, you only
Michael Kennedy: get to do one thing in threads in Python.
Michael Kennedy: And all of a sudden, a lot of that falls down.
Michael Kennedy: This basically uncorks that and makes that easy all of a sudden.
Michael Kennedy: Even if you yourself are not writing async, your server can be more async.
Carlton Gibson: Yeah.
Carlton Gibson: And this is the thing that we found with ASCII is that you dispatch to a, you know, using
Carlton Gibson: to async or you dispatch it to a thread, a thread pool executor, but Python doesn't run
Carlton Gibson: that concurrently.
Carlton Gibson: And so it's like, or in parallel.
Carlton Gibson: So it's like, ah, it doesn't actually go as fast as you want it to.
Carlton Gibson: And so you end up wanting multiple processes still.
Carlton Gibson: All right, let's keep it with Django.
Carlton Gibson: Jeff, what do you think?
Jeff Triplett: I'm going to defer to the others on this.
Jeff Triplett: I have the least thoughts.
Michael Kennedy: All right, write down the stack, Sebastian.
Michael Kennedy: Write down the video, not website, web framework.
Michael Kennedy: I think it's going to be awesome.
Michael Kennedy: This is going to help so much, so many things.
Michael Kennedy: The challenge is going to be third-party libraries used by each individual application
Michael Kennedy: and if they are compatible or not.
Michael Kennedy: That's where the challenge is going to be.
Michael Kennedy: But other than that, it's just going to be free extra performance for everyone.
Michael Kennedy: Just, you know, like just upgrading the version of Python.
Michael Kennedy: So that's going to be us.
Michael Kennedy: Cody.
Cody Fincher: Yeah, I'm going to echo what Sebastian just said.
Cody Fincher: The third party libraries, I think, are going to be the big kind of sticky point here.
Cody Fincher: I'm looking forward to seeing what we can do.
Cody Fincher: I'm going to kind of hold my thoughts on that.
Cody Fincher: Yannick kind of speak a little bit on it because I know that he's looked at msgspec specifically
Cody Fincher: and some of the other things that might, you know, give some better context here.
Cody Fincher: But yes, the third party libraries are going to be the kind of the sticky issue.
Cody Fincher: but I'm looking forward to seeing what we can make happen.
Janek Nouvertné: I'm super excited, actually, specifically about async stuff,
Janek Nouvertné: because for most of the time, it's like,
Janek Nouvertné: if you can already saturate your CPU,
Janek Nouvertné: async doesn't help you much.
Janek Nouvertné: Well, now, if you have proper threads,
Janek Nouvertné: you can actually do that in async as well.
Janek Nouvertné: And I think it's going to speed up a lot of applications
Janek Nouvertné: just by default,
Janek Nouvertné: because almost all async applications out there
Janek Nouvertné: use threads in some capacity because, well, most of things aren't async by nature.
Janek Nouvertné: So they will use a thread pool and it will run more concurrently.
Janek Nouvertné: And so that's going to be better.
Janek Nouvertné: But I'm also a bit scared about a few things that mainly, as a few others have said now,
Janek Nouvertné: third-party libraries extension is specifically those that are Python C extensions.
Janek Nouvertné: just recently, I think like three weeks ago,
Janek Nouvertné: so got a msgspec released for Python 3.14
Janek Nouvertné: and proper free threading support.
Janek Nouvertné: And that took a lot of work.
Janek Nouvertné: Fortunately, a few of the Python core devs
Janek Nouvertné: chimed in and contributed to PRs
Janek Nouvertné: and helped out with that.
Janek Nouvertné: And all around the ecosystem,
Janek Nouvertné: the last few years,
Janek Nouvertné: there's been a lot of work going on.
Janek Nouvertné: But especially for more niche libraries
Janek Nouvertné: that are still here and there,
Janek Nouvertné: I think there's still a lot to do and possibly also quite a few bugs lurking here and there
Janek Nouvertné: that haven't been found or are really hard to track down.
Janek Nouvertné: I'm curious and a bit maybe scarce, too hard of work, but I'm cautious.
Michael Kennedy: It's going to be a little bit of a bumpy ride as people turn that on
Michael Kennedy: and then the reality of what's happening.
Michael Kennedy: However, I want to take Cody's warning and turn it on its head
Michael Kennedy: about these third-party libraries,
Michael Kennedy: Because I think it's also an opportunity for regular Python developers who are not async fanatics to actually capture some of that capability.
Michael Kennedy: Say if some library says, hey, I realize that if we actually implement this lower level thing, you don't actually see the implementation of in true threading.
Michael Kennedy: And then you use it, but you don't actually do threading.
Michael Kennedy: You just call even a blocking function.
Michael Kennedy: You might get a huge performance boost, a little bit like David was talking about with markup safe.
Michael Kennedy: And you could just all of a sudden, with doing nothing
Michael Kennedy: with your code, goes five times faster on an eight core
Michael Kennedy: machine or something in little places where it used to matter.
Janek Nouvertné: I'm super excited for--
Janek Nouvertné: we currently focused on the things that are out there
Janek Nouvertné: right now and that might need to be updated.
Janek Nouvertné: But I'm super excited for what else might come of this,
Janek Nouvertné: new things that will be developed or stuff
Janek Nouvertné: that we are currently not thinking about
Janek Nouvertné: or have that hadn't been considered for the past 30 years or so,
Janek Nouvertné: because it just wasn't feasible or wasn't possible or didn't make sense at all.
Janek Nouvertné: I think it would pay off definitely.
Janek Nouvertné: All right. Team Flask.
Phil Jones: You guys got the final word.
Phil Jones: I think it would probably be more advantageous to whiskey apps
Phil Jones: than it will for ASCII apps.
Phil Jones: And when I've been playing with it, it's mostly on the whiskey flask side
Phil Jones: where I'm quite excited about it.
Phil Jones: At the same time, like the others are a bit worried because not clear to me,
Phil Jones: for example, that green threading is going to work that well
Phil Jones: with free threading.
Phil Jones: And that may have been fixed,
Phil Jones: but I don't think it has yet.
Phil Jones: And that might then break a lot of whiskey apps.
Phil Jones: So next, I think.
Phil Jones: But yeah, very excited for Flask in particular.
David Lord: Thanks for bringing up green threading.
David Lord: I added that to my notes
David Lord: of mention right now.
David Lord: So Flask already has emphasized
David Lord: for years and years and years
David Lord: that don't store stuff globally,
David Lord: don't have global state,
David Lord: bind stuff to the request response cycle
David Lord: if you need to store stuff,
David Lord: look stuff up from a cache otherwise.
David Lord: And my impression is that that emphasis is pretty successful.
David Lord: I don't, there's any well-known extensions using like global state or anything like that.
David Lord: It's helped that the dev server that we have is threaded by default.
David Lord: Like it's not going for performance, obviously, it's just running on your local machine, but
David Lord: it's already like running in a threaded environment, running your application in a
David Lord: threaded environment, not a process-based one by default.
David Lord: I don't know if anybody even knows that you can run the dev server as process-based.
David Lord: And we also already had for a decade or more than a decade,
David Lord: Gevent to enable the exact same thing that free threading is enabling for Flask,
David Lord: which is concurrent work and connections.
David Lord: And so plenty of applications are already deployed that way
David Lord: using Gevent to do what kind of ASCII is enabling.
David Lord: I've run all the test suites with pytest FreeThreaded,
David Lord: which checks that your tests can run concurrently in the free threaded builds.
David Lord: so go check that out by Anthony Shaw.
David Lord: And I'm pretty sure Granian already supports free-threading.
David Lord: Not sure though, I haven't looked into Granian enough.
Michael Kennedy: But like-
Michael Kennedy: You know, I'm not sure either.
Michael Kennedy: It does have a runtime threaded mode
Michael Kennedy: but I don't know if that's truly free-threaded or not.
David Lord: All of those things combined make me pretty optimistic
David Lord: that Flask will be able to take advantage of this
David Lord: without much work from us.
David Lord: I mean, I know that's a big statement right there
David Lord: and I haven't tested it
David Lord: but the fact that we've emphasized
David Lord: all these different parts for so long already
David Lord: makes me confident about it.
Michael Kennedy: I'm also super excited about it.
Michael Kennedy: And just one final thought I'll throw out there
Michael Kennedy: before we call it a show,
Michael Kennedy: because we could go on for much longer,
Michael Kennedy: but we're out of time.
Michael Kennedy: I think once this comes along,
Michael Kennedy: whatever framework out of this choice you're using out there,
Michael Kennedy: there's a bunch of inner working pieces.
Michael Kennedy: One of them may have some kind of issue.
Michael Kennedy: And I think it's worth doing some proper load testing
Michael Kennedy: on your app, you know, point something like locus.io at it
Michael Kennedy: and just say, well, what if we gave it 10,000 concurrent users
Michael Kennedy: for an hour?
Michael Kennedy: Does it stop working?
Michael Kennedy: Does it crash?
Michael Kennedy: Or does it just keep going?
Michael Kennedy: You're like, so that seems like a pretty good thing to do the first time before you deploy
Michael Kennedy: your first free threaded version.
Michael Kennedy: Yeah.
Michael Kennedy: All right, everyone.
Michael Kennedy: I would love to talk somewhere.
Michael Kennedy: This is such a good conversation, but I also want to respect your time and all that.
Michael Kennedy: So thank you for being here.
Michael Kennedy: It's been an honor to get you all together and have this conversation.
Michael Kennedy: Thank you very much for having us.
Janek Nouvertné: Thank you.
Janek Nouvertné: Yeah.
Janek Nouvertné: Thanks for having us all.
Janek Nouvertné: Thanks, everybody.
Janek Nouvertné: Yeah.
Janek Nouvertné: It's nice being here.
Janek Nouvertné: Yeah.
Janek Nouvertné: Thanks for having us.
Michael Kennedy: Thanks for having us all.
Michael Kennedy: Bye.
Michael Kennedy: Bye-bye.
Michael Kennedy: This has been another episode of Talk Python To Me.
Michael Kennedy: Thank you to our sponsors.
Michael Kennedy: Be sure to check out what they're offering.
Michael Kennedy: It really helps support the show.
Michael Kennedy: If you or your team needs to learn Python,
Michael Kennedy: we have over 270 hours of beginner and advanced courses
Michael Kennedy: on topics ranging from complete beginners to async code,
Michael Kennedy: Flask, Django, HTMX, and even LLMs.
Michael Kennedy: Best of all, there's no subscription in sight.
Michael Kennedy: Browse the catalog at talkpython.fm.
Michael Kennedy: And if you're not already subscribed to the show
Michael Kennedy: on your favorite podcast player, what are you waiting for?
Michael Kennedy: Just search for Python in your podcast player.
Michael Kennedy: We should be right at the top.
Michael Kennedy: If you enjoyed that geeky rap song, you can download the full track.
Michael Kennedy: The link is actually in your podcast blog or share notes.
Michael Kennedy: This is your host, Michael Kennedy.
Michael Kennedy: Thank you so much for listening.
Michael Kennedy: I really appreciate it.
Michael Kennedy: I'll see you next time.
I started to meet.
And we're ready to roll.
Upgrade the code.
No fear of getting whole.
We tapped into that modern vibe over King Storm.
Talk Python To Me, I-Sync is the norm.
Редактор субтитров А.Семкин Корректор А.Егорова