Autoscaling is a simple concept. Automatically add resources when needed, and automatically shut them down to avoid paying for excess capacity. How hard could that be? If you've set up Autoscaling yourself, you know it's not that easy, especially using the native Autoscalers on platforms like AWS and Heroku. That's why you need JudoScale.
JudoScale is Autoscaling as a service, and they make Autoscaling simple and easy, as it should be. You can use JudoScale on AWS, Heroku, Render, Fly.io, and more. It's free for low traffic apps, and unlimited plans start at $25 per month. Autoscale on Easy Mode at Judoscale.com. Hello, and welcome to another episode of The Bike Shed, a weekly podcast from your friends at Bopopop about developing great software.
I'm Joel Kinville. And I'm Adi Slater, and together we're here to share a bit of what we've learned along the way. So, Adi, what's new in your world? Yeah, I am a little nervous to admit this in public because I'm giving VS Code a try. Okay.
Moving out of the terminal into a separate window? Yeah, and that is the thing I think that is giving me the most trouble about it is being out of the terminal 100% of the time. That's been where I've worked for so long, and everything I need is so in reach. But the thing that has motivated this attempted switch, this experiment, is that I've been switching a lot between some projects, either internal thought about projects, client work, and personal projects, and volunteer work projects. And every single one of them has a different configuration for Rubikop and LSPs and different things like that.
And I have been finding that, NeoVim, my usual editor, is a lot more finicky about picking up project specific configuration and just kind of running with it. And not having an auto-formatter is just really a damper on the workflow. Having to worry about indentation manually is not something I've had to do in so long that I'm giving it a shot because it seems like VS Code, the tooling there just works TM a lot more. I've tried once or twice before. It didn't stick.
But that's also true about them when I first started using them. So I don't know. I'm in the middle of this experiment. I'm not really loving it, but I think at the moment that is still just familiarity. I feel like I was in a very similar boat to you maybe almost a year ago now, where I was just done with having to constantly configure and fix issues with my tooling setup.
And I just wanted to work. Give me LSP integration out of the box. Give me auto-formatting out of the box. I don't want to have to dedicate an hour to play around with configs and make it work. Yeah, that was really fun when the tools and the environment to get the work done was new to me.
I'm very much interested in that and had lots of fun learning about how the editor and the plugins and different things interacted and how to make these things work together. But yeah, I've progressed from that. That's not where I get my enjoyment. My enjoyment is from building things so much more now and so much less the toys or the tools that you do it with. And yeah, I think that's been driving this decision this time away from home.
And I was worried about admitting this in public because, at least to myself, and I think more so in the past online, so much of my identity was tied up in being a VIM user. And I don't know if that is quite so much what a big portion of my online identity or anything is anymore, but it is still very much personally. So not only is it familiarity for my workflow, but there's a little bit of that mental hurdle for myself, I think. The real programmers use VIM. Exactly, which that's just archaic thinking anyway.
Have you seen the XQCD on that? Probably, but I haven't. So a series of people that keep upping the ante on the real programmers use whatever to code until you get to the point where somebody went up to everybody else by being like, you know, programmers just use random cosmic radiation to flip bits on their hard drive disk. Wow. You know, it's taking that argument to sort of, you know, reduction to the absurd.
Oh, I thought you're going to say logical next step, of course. You know, there is, I was just thinking about this the other day because there is a streamer playing Mario 64 on Twitch and just captured this moment where the little Mario that he was controlling around a platform like jumped up to another platform just instantaneously. And nobody knew what was going on. It's like, is this a bug? Anything like that.
And the best hypothesis after this has been like looked at by the community for a super long time is that that was the rare instance where there was something noticeable about a cosmic ray flipping a bit. And that's kind of the only explanation that is the most supported at this time. And so just there being such a bright and visual and colorful example of that happening is just fascinating. But given the amount of computing that is being recorded these days, it's not to happen eventually. But other than that, what's new in your world?
I've been tinkering around with some performance work. And it's a side of things that I've not had to interact with quite as much before, specifically tuning concurrency on sidekick workers and database connection pools. What happens is you have your database connection pool, which you said in your database yaml on a Rails app. And then a Heroku, you might spin up a dyno to have sidekick worker. And you can give that worker a concurrency, which is sort of how many parallel workers are going to be on that dyno.
And they will go to work. What can happen is that they can exhaust the connection pool. So when you spin up a dyno that involves booting the Rails app, and so it looks at your database yaml, it looks at your connection number. So let's say your connection is five. You have a connection pool of size five.
But if you've brought up the sidekick concurrency to 10 on that dyno, then you have 10s for parallel processes, each of which might want to read from the database. And then you'll get a lot of exceptions around exhausted connections. So the general advice is that you want that connection pool to match the concurrency level, match or exceed the concurrency level on your worker process. Getting that to work is a little bit tricky, just because you have to set that configuration in one place, so your database yaml, which is going to get shared by all of your dynos. And you can set environment variable for it, but Heroku doesn't give you per dyno environment variables, it gives you global environment variables that are shared across everything.
There are ways of getting around that, where you can sort of alias environment variables in your proc file for a particular dyno that you could do something like that. You could set the pool number to just be the largest of all your concurrences. So you've got some dynos that have concurrency of 10, some have concurrency of five, maybe your web process is concurrency of five, but you're like, you know what, the pool is going to be 10 for everybody just because that's my largest one. That makes sense. Or this is a really interesting idea.
Because that pool number is not a number of connections that will be instantiated at boot time, rather it's a maximum that this process is allowed to create if it needs them. What you can do is just set it to an arbitrarily high number to basically say, however many connections you want, go ahead and do them. So I've seen people recommend like 100 or 200 as that just a hard code of value you put in your database yaml. And that really just means that I don't care. Right.
Use as many as you want. And in practice, you're going to be limited because you're probably not using a lot more than your concurrency number. You know, there's a few other caveats on there that you might use a few extra if you're spinning off your own threads or doing some async things. In practice, it's about the number of your concurrency. So just by limiting how many dinos you have and how much concurrency you have on each, that will limit the total number of connections that you'll have.
Yeah, makes sense. Which depending on your Heroku Postgres plan might be a couple hundred or 500 or something like that. So as long as you stay under that, you're fine. You don't ever have to worry about tuning the connection pool on a per dino basis. It seems pretty straightforward.
Yeah, it's really interesting because I sort of started this trying to fix this problem by being like, how can I tune this correctly? And I'm looking at a few different approaches. And it turns out that the approach I'm leaning towards is actually sort of the opposite. It's not how can I get my number more accurate? It's how do I not care about this number at all?
Yeah, that's opposite the way that we're usually sort of thinking, right? We want something kind of dialed in and working efficiently. But when you kind of take it back to first principles and think, well, that doesn't mean that all of them get spun up all the time. That really just flips the problem on its head, doesn't it? Yeah.
You can then take this idea and make it a slightly fancy architecture if you want. So I've seen recommendations for a Pg bouncer, which is a Postgres add-on that effectively adds a global connection pool in front of your database. So instead of each dino having its own ActiveRecordManage pool, there's like a Postgres pool. In front of Postgres that then all of your dinos talk to. So you're not configuring a per dino pool anymore.
You're just configuring one global one. It's a little bit more effective in terms of managing IO. I think it doesn't keep connections open for like the whole length of your web request. If it's a very slow web request, it happens to have a fast query at the beginning of it. So it can be a little bit more efficient there.
But also, that's the kind of thing that you really only start seeing once your products gets a little bit more scale. So my understanding is that right at the beginning, you set your connection number to your pool size, so like a hundred or something to be like, I don't care. And just let it go and never have to worry about it. Or don't have to worry about it until you're like really scaling up pretty high. I like that idea that the PD bouncer too, it sort of at least on the surface, leans into my desire to push responsibility to the database as much as possible.
I don't know if it quite applies in the same way. Yeah, it's an interesting concept that I hadn't heard about. So sort of trying to move responsibilities out of rails and more into the infrastructure. Yeah, I think so. That sounds like a thing.
Have you ever tried to debug an issue in production while switching between your error tracker, log viewer and APM tool? Maybe you know how painful it is when you can see the error but can't find the relevant logs. Or when you see slow performance but it can't connect to the root cause. Scout monitoring is all in one platform, built to make your life easier. With log management, performance tracking and error monitoring coming soon.
All of your data will be together at last. It'll go from bug to fix in one place. The result? Less context switching, faster debugging and monitoring that actually helps you ship code instead of distracting from it. No DevOps team?
No problem. Scout works with your existing stack and gives you insights in five minutes, not hours. From bug to fix in one place at ScoutAPM.com. So I guess that's one of the more back-end side of things but one way that you can do that on the more front-end side of things is moving responsibilities out of rails and into the browser. An example of that might be instead of using something like device to manage your authentication, letting the browser handle it with HTTP Basic Off.
And that's something that's almost free to set up but you don't see it around that often. That's true. What are your thoughts on Basic Off? I'm really going to have to probably dig deep to come up with a time that I last used Basic Off. I feel like most of the time it is on small projects that are maybe more ephemeral, that sort of thing.
I guess it's right there in the name, right? Basic Off. It feels like something that you learn in school or learn in your first experience with the Web as a platform and then you move on from there to more sophisticated systems. But yeah, keeping close to the standard, that's something right there that's just right in the headers. I feel like I occasionally see Basic Off used on things like stating websites, where there's just sort of a global thing.
The website might have its own sort of log-ins if it has users on it because the production website would need real users. But it might also have just a global Basic Off on it to prevent randos from playing around with staging. That's true. I think it also in a sort of similar vein allows you to bypass that kind of first step of a new application of having to set up users and accounts and log-ins and things like that. You can get something kind of up and running and still give it a little bit of security or obfuscation around it and get to the real meat of your product or your application and be able to start doing the thing that is specific to your task at hand.
Are you thinking something like a prototype or something even as advanced as an MVP? Yeah, I think a prototype or an MVP, especially if the MVP is not going wide and just sort of public, depending on the use case, of course, but if it's going to a small set of trusted, more trusted users, then that's a pretty easy way to get around that bit of infrastructure setup, right? And you can get to finding out what your product actually is and getting some feedback a little bit faster. And I'm all for anything that can get you to that spot as quickly as possible. You mentioned earlier the idea of sort of easy security.
I love to maybe take into some of the security implications of basic auth, because I do sometimes see big disclaimers around it. And maybe the more obvious one is that the username and password are transmitted in plaintext. And so they should never be used on an unencrypted network connection. Yeah, absolutely. Always use HTTPS. Otherwise, people just read the username and password.
I feel like that is become something that you almost don't have to say anymore, right? Like, you should just always be using HTTPS as just the that's table stakes in the stay and age, right? Yeah, I think sometimes people will just do HTTP for sites that are more static. So somebody's marketing website or something. Now you're unlikely to want to password on that. But I think that sort of
thing, maybe there's like it's mostly static, but there's like a page or two that you want more private. And if you're doing it over HTTP, non encrypted, then that's liability. Where are the places that you have come across basic auth? And why do you think that was the choice as opposed to something that maybe has a little more security mindedness around it? I've often seen it as a sort of almost a speed bump rather than a hard security feature.
Yeah. So things like gating a staging website where we're not like trying to prevent hackers from coming in. We're mostly wanting to avoid like vandals, troublemakers. Right. That attack of opportunity rather than focused specific attack or something like that.
Right. Right. And maybe just an extent avoiding automated content. Sure. Scrapers, crawlers, that kind of thing.
Right. Right. Yeah, because there's a few of those going around these days. I hear yes. I know in three, they should respect your robots text, but they don't always.
And it's just it's a staging website. We want them to go to the real one. The staging one should be, you know, for us to test things on, but not for the general public. And is there a I can think of a few, but what would be the reason that you would put that staging site to be more accessible, like publicly accessible in that you'd need to put that little bit of the speed bump? I think that the speed bump is there because you want it not to be public, but you also don't want to create an entire other auth system that only gets turned on in staging. You want as close as
possible for the two to be the same. And so if you had a separate login page with an entire other system that only gets turned on in staging, that might feel very heavy. Whereas basic auth is usually just a config file on your server, or the case of rails. It's a couple lines in a config file as well. Yeah. And you don't want to have to require something like a VPN or anything a lot more heavy-handed to
be able to reach this thing if you're going to be showing it around, especially. Yeah. Yeah. And that may be a little bit of a difference between a staging site and a demo site, but I think they share some characteristics there where you don't want them to be totally accessible. But you also need to be easy enough to share. You don't want to require somebody to create an
account necessarily. And so having a sort of global site-wide password that's just a, hey, we're going to make you measure this before we show it to you is enough of a barrier to entry that it covers most of your needs. Yeah. I think that speed bump is something that I've seen a lot for example things or like little example APIs to play with or APIs that are maybe not sensitive data that you want to close the door, but maybe not lock it. You want someone to have the intention of coming in and using your system in good faith so that they will have had to read the docs or send you an email or something like that in order to cross that little bit of barrier of proving that they're not a robot and be that they're maybe they're for a legitimate purpose.
Yeah. I think just adding a little bit of extra friction sometimes can be a really valid choice to make. Oftentimes we talk about removing friction for users, but there are cases where adding friction is what you want to do. One thing that I think is interesting here if we're talking for more of a security perspective is the idea of threat modeling. I think it's easy to talk about security as a sort of binary thing, but more it's about thinking of what are the types of attacks you're likely to face and then how do you mitigate those? I guess if you squint, every security measure is really just
a speed bump, although some of them are very, very high. This is true. You know the only real way to be secure is to unplug your server. Get off the internet. At that point, you know, you're not totally secure either because you can just mission impossible that thing. If we're going to take it
all the way down to there is no security, nothing is real, nothing is safe. I think I'm going to need to end the call right now. So let's maybe back up a little bit more into the real world. Really? If your threat model is government actors are coming after me, then that is the thing you have to figure out. Maybe you need physical security, like a person 24 hours guarding that server that is
air gapped. Absolutely. Your MVP is probably not that. No, no. I do think one of my favorite examples that I've read about for that kind of ultra personal physical security of a device is from core doctor on novel. And he does so much research. I'm sure this was presented to him by an actual
security researcher. This person would put clear nail polish with glitter in it across their screws on their laptop. So it would be an almost imperceptible way to tell if the screws had been turned. Whoa. That's so brilliant. But also like, wow, to have to live with that level of paranoia is wild.
But there is a sort of a level where for the like average web app, there's some things you probably want to handle. Absolutely. You know, you look at your OASP top 10 is a good place to start. I think there is an element that you have to consider when you're working with basic auth. And that is its vulnerability to CSRF cross site request forgery. And that's because once you
sign in via basic auth, your browser will hold on to those credentials and then rescind them along to any subsequent request to your website. So you put them in an example.com. Every subsequent request example.com will include those credentials until you close your browser or whatever the expiration is inside your browser cache. Right. And that can be manipulated because on a third party site, you go to dangerous.com and they might have a JavaScript script that tries to make a request to example.com. It doesn't have the credentials, but the browser will automatically fill them in.
Right. And that's dangerous. Yeah. First of all, dangerous.com avoid that URL. Yeah. Yeah. Maybe don't do that. You know, when your browser says the like danger,
this site is, you know, not who it pretends to be navigate back to safety and you're like, ignore the warning. Don't do that. Which actually, I don't believe would trigger at all for anything that is protected by basic auth. So that level of browser awareness to warn the user is not going to help you in this situation that you just described. Because it could be totally legitimate. Right.
JavaScript makes API requests to third party websites all the time. That is a normal part of web development. You just don't happen to know that they're trying to hit this particular website and it's applying credentials in a way that it shouldn't. Right. There are some ways of mitigating that. Cores policies, cross origin resource sharing, I think. Oh boy. Acronyms. Right. That annoying
warning that you get in your console when you're trying to make JavaScript requests to a third party and it's just like, no, we're blocking all of them. No. Yeah. Cross origin resource sharing. You got it. Got it in one. Although it's important to note that that doesn't prevent the request from
happening. It just prevents the request, depending on the context, it prevents the response from being the response being read by your JavaScript. Break that down a little bit. The response being read by your JavaScript, but that JavaScript is still going to have access to the request. So they can still capture that credential data. Well, they don't capture the credential data.
But what they can do is issue the request. And I think there are definitely cases where the request can make it to the server. And then it's just a response that comes back and the JavaScript can't read it because it will read as a failed request. But in practice, it's just because the browser blocked it. Sometimes the browser will block the request, the outgoing request as well, if it does a preflight. But my understanding is that's not always the case. So if you're trying
to like fetch data from a third party server, then yes, Cores protects you because the malicious JavaScript can't read the data where it gets tricky is what if your goal is not to fetch data, it's to take a destructive action. So you're instead, you're like, I don't care about the response. I just want to make sure that a post request hits your server endpoint and triggers a bank transfer. Dangerous.com again. So you need to mitigate against not just reading data, which Cores will do, but you need to prevent any destructive actions from happening on request. I think the classic solution there is a CSRF token.
Absolutely. And this is the thing that Rails gives us by default. It is. Yeah. I feel like it's the thing I never have to think about, except occasionally when I had to disable it in APIs.
Yeah. I think there's disabling it in APIs. And then there's every now and then when you want to maybe do something a little bit out of the box and use Rails most of the way, but then take over or something like that, you can forget to pass those tokens along or think about the tokens. And it's an example of going outside the Railsy way is actually going to be harder to do because Rails says, in this instance, it's maybe not because it's falling outside of the convention over configuration, but it's because Rails has thought of this layer of security and kind of taking care of it for you ending up with you not having to think about it too much. And for users who are not familiar with the concept of how CSRF tokens work, specifically in Rails, Rails will automatically insert a hidden field in all of your forms, all of your post forms, and add an auto-generated token in there. And then any endpoint where
you're submitting that form to, there's a middleware, I believe, that checks that token is valid. So it's a way of saying, hey, did we generate this form for you rather than some random and the internet creating the form? Because CSRF doesn't have to be JavaScript. You can just have somebody else on their site making a form that hits your endpoint, and they can just manipulate that form to have the fields they want. Yeah, absolutely.
Server should never trust that input comes from clients that they expect. And the CSRF token is a way of validating that yes, you are one of our clients, not a Rando. Right. It's another layer or aspect of remembering that any code or anything that you have sent down the wire no longer belongs to you at all. And everything that you are giving to the user to fill out in forms and everything like that is letting someone know a way that your server is expecting some information back. And so just by being open into the world at all,
you are exposing a little bit of your process, your infrastructure, your architecture, right? So it's common to disable CSRF tokens in Rails when you're doing an API rather than classic HTML forms, which means we're no longer, your API doesn't have to mess with CSRF tokens. Why is that safe? And do you think it would be safe to have an API that's disabled CSRF protection and is protected by HTTP basic auth? I think, again, it's safe to a point, right? You have to think about that in the trade-off.
Are you allowing destructive actions? Then maybe that's not going to be enough of a guardrail. Are you just having data fetched and maybe it is public data, right? And so it's not going to be as vital that, you know, where the origin of the request is coming from. Maybe it's something that's meant to be used as a third-party service from JavaScript or something like that, right?
Yeah. So I think an important thing when we're talking about CSRF tokens is that this is something that usually only applies to non-get requests. So Rails puts that in your post forms or your Rails doesn't fancy things to simulate patches and deletes and things like that. So those all get the CSRF token, but get forms and links, things like that don't. So even with all the protections, this only applies to the subset of things that are destructive. I think I would argue that if you
don't have CSRF tokens in your API and the authentication on your API is basic auth, then you are vulnerable as CSRF because then anybody could trigger a request to your site and this could be via browser, but like it could also be via curl. I guess that doesn't curl would be safe because the attacker is running it rather than having it run on the victim's machine. But the victim, if they're in a browser and they load a malicious website, it can kick off API requests to your site and it can do that via JavaScript, but it can also do that via other mechanisms like an image URL, the browser will try to load. Ooh, it's getting fancy. Yeah, and it will fill in the credentials.
And even if core blocks the response from being read, if it's destructive, that request will still go through and do the bank transfer, delete all of your users. And I think that's because of the fact that the browser will include those credentials on every request. I'm not quite sure what the term is for that thing. I think I've maybe heard ambient authentication, the idea that sort of some credentials are in the browser and it just sends them on all the requests automatically. And I've heard that term before. So I think if you're using basic auth, you have to use a CCR
ref token on your destructive endpoints to be safe. But then that maybe leads to the question, is that true for all APIs or just ones that are protected with basic auth? Yeah, it's going to be required, right? If you want to consider yourself secure for something that's protected by basic auth, are there other places though where you would be a little less concerned about where the origin is if you've got other safety controls, other security controls behind that, then I think that's absolutely a way that you can operate. Yeah, I'm thinking like APIs typically don't do CCR ref tokens. But that's because they already are passing tokens around. So you've got something
like an OAuth token that's effectively a bearer token, or maybe you even have like a browser session with a cookie. Those sorts of things are already sort of, you're already doing the thing where you ask a server for a token and it gives you a token and then you send it on subsequent requests. Right. So you're kind of doubling up. Yeah. It's a little more visible to the person that's
developing that too, right? You're not relying on kind of built-in browser operations, it's going to be whatever package or protocol that you're communicating over. Right. If you're doing something like OAuth, and a third part of dangerous.com website won't have your OAuth token to put in there, and your browser won't automatically supply one, which is the whole point of this attack. And so the CSRF falls apart. If your API is using something like OAuth. I want to say you're
still fine if you're using cookies if you have things like same site restrictions on. Yeah, I think that would be true. I'm trying to think now. Because cookies have that same feature that basic auth have in the browser, which is the browser will send the cookies along for every request to that server, which is why we have the same site configuration on the cookie to say, hey, browser, only send this cookie from an origin that is from my own website. Never send it from a third party.
Now I'm trying to think of if there are instances where like clickjacking, could you maliciously embed an iframe and get the browser to send something that is from the origin that would send the cookies? I believe iframes are their own context for the purpose of the same origin policy. Although don't quote me on that. Yeah. This is, you know, the the fun but also the danger of the podcast format is that there's not a thing where we can like read through the spec ahead of time and like come up and present you with a here's the things. And yes, of course, here's the policy on iFrames and the same origin policy.
Yeah. And then there's always new edge cases to that you might think be might would be locked all the way down. But then the more and more edge case you get, there's always the possibility of something that you hadn't considered or the spec hadn't laid out right in the first couple of paragraphs or whatever. I feel like it's a little bit the history of the web, right? We start with all these features and then we've had to like lock them down more and more as we've gotten through. So
things like iframes, a really cool feature, but we've found all these ways to exploit them. And so we've had to really lock down what you can do with an iframe cookies really cool. But then again, you can do all sorts of nefarious things with them. And so browsers have allowed servers to sort of specify, Hey, I want to really lock down cookie only do these things with them. And this is all still of course relying on the browser doing the thing that the user wants, right? If you're using an insecure browser, then kind of all bits are off.
Right. Right. So you never want to trust that. The problem with something CSRF is it's not a malicious user doing things. It's a victim user who's getting their browser tricked into doing things or not even tricks. The browser's doing the like standard behavior. It's just that when you have a
general purpose client that can make requests to multiple different servers at the same time. And you've got simple rules like anytime you're trying to access example.com, if you have the credentials for example.com send them up automatically, a clever attacker can take advantage of that. Yeah, taking advantage of that standard behavior. And then a little bit more of the responsibility is put on the user to understand what's going on. And that's that's a huge attack factor right there because most users don't have that. They don't know what's going on the browser.
I mean, even for someone who understands, right? Like if there's a CSRF vulnerability and I'm browsing the web, I understand CSRF. I'm not going to be digging through the network panel on every website I use to see if it makes a third party request that I might not want. You don't wait, you don't. So it's, you know, I think it's part of the utility of the browsers and general purpose client and sort of requesting it blended across the web. But it does mean that you have to be really
careful about that in a way that if every website had its own dedicated client, the way that you typically see with, let's say, mobile apps, where every mobile app is sort of its own little mini dedicated client that talks to a server, now you can hard code things into there. You don't have to worry as much about some of these polluting things. So you're not going to go to somebody else's website necessarily with your app, you know, web views excluded. Right. Yeah. And I think that's,
we've moved away from the little walled gardens of the internet being a major way that people have you know, accessed the network. I guess we moved away from that like 30 years ago. But yeah, that's a little bit of the power of that all purpose client. And again, power and convenience trade off with security. It's an arms race. Yeah. And the fact that the, the web can do all of that
is what makes it so easy to build for, easy to distribute, easy to discover. It's great. But it is a thing that we as developers have to think about. Yeah. So if you're, if you want to use something basic off simple, but I think if you're using it for more than just a like very basic speed bump, I honestly, you probably shouldn't use it for real security. But if you are, I think the
things you have to absolutely make sure are happening are one, you've got to be on HTTPS connection, two, make sure you've got a correct course policy set up so that nobody can read data that comes down, three, make sure that you're using CSRF tokens for any destructive actions. Right. And while you're at it, maybe make sure that all your destructive actions are semantic HTTP. Don't use get to make destructive actions. Oh, absolutely. Because that then, you know, gets around some other security
things that are assumed that you're using the correct HTTP semantics. Right. That's a whole other ball of wax. It also just make it so ephemeral and low stakes that it's not really going to matter too much. Anyway, I guess maybe that's the reason that you don't really see HTTP basic off in in production where or very rarely. Yeah. That and the fact that, you know, it's built into the browser
so it's ugly. GitHub's interactions using basic browser defaults would disagree. And I think there'd be a lot of folks that would disagree with that, especially on accessibility concerns. But that is an episode for another day on that note. Shall we wrap up? Let's do it.