Hi there, this is Jeremy Howard from Answer AI. And I am here with Carson from HTMX. And Carson's probably not going to like this if I introduce him in two glowing terms, because he's a very humble man, but I can't help it. There's just a few people in the world, very few people in the world who I assign the epithet genius to.

And Carson is one of them. He's one of the very few. He looks and sounds like a little league baseball coach. And that's because he is, I'm sure he's a very good one as well. But that is not the genius that I wanted to talk about today. I wanted to talk about HTMX.

So Carson, welcome. Thank you. I appreciate that. You know, I appreciate you saying that. But no, I can't agree with that. I do. I do look like a baseball coach. Are you a good one? Do your little league say that you do a good job? I you know, baseball makes people crazy.

So I have a lot of people that like me and then a couple of people that don't. And so I'll leave it at that. I love it. And I feel like I know about your your other life. Yeah, it is definitely pretty funny. Sometimes I'll just be like, man, this is very different than my online.

That's great. So well, something we both share in common is that we live a long way away from everybody else doing what we're doing. And we do things in a really different way to everybody else. So that's where I wanted to start, you know, HTMX is like, the most misunderstood piece of technology I've come across in my God, how long I've been coding for 40 years of coding.

So I wanted to help people understand it. And sure, I think the best way for people to understand it would be to read your damn book. So I'm just going to share like that on the screen. But that was short for a pretty short interview. So here's your damn book.

I'm not just you, you and Adam and Dennis. hypermedia.systems called a main name. And the whole thing's free for God's sake. What are you trying to do? You're like, yeah, you're not gonna actually this right now. Books are not a good way to make much money in general. I know.

Yeah, you know. And even worse, I uploaded the EPUB lib gen. So if people, if people want, if they don't want to pirate your book, they can they want to pirate, they can do so with my blessing. No, but they're not going to do that now. Because part of getting stuff off lib gen is like, you know, sticking it to the man.

And if you're like uploading it there yourself, it's like, why even bother? Yeah, exactly. Well, you know, I figured someone was gonna do it anyway. So might as well be made. So yeah, but yeah, there's a hardcover that's, if you really if you want to spend some money on a physical artifact, the hardcover, it's pricey.

And my understanding is it's hard to get in Australia. But it, it has a really cool cover that was done by us graphics. Really, really happy with that. And then we just released the soft cover to Yes, which on Lulu with a beautiful song. And that's, yeah, that's got a pixel art cover that we're super happy with.

It's we there was a, a pixel artist on fiber named ash. And he did an unbelievable job with it. So super happy with that. Yeah, I love it. And one of the few pieces of software were released recently that was initially available only on floppy disk. Yeah. Yeah, we did that for a couple weeks.

We had a we have floppy disks. I don't think they're available on the store anymore. But you can buy them for a little bit. So yeah, we have some fun. So it's all have some fun. An interesting thing about your book is that actually the entire first part, not just the first chapter, but the entire first part isn't about your thing at all.

It's about Yeah. It's about HTML and HTTP, I guess. So I wanted to start there because some of the like, so I've been coding for a while. And I hadn't quite noticed until recently that there's a whole generation of people who are competent full time coders that are not familiar with any of the basic concepts of the web because they program at a totally different level of abstraction, which is like, you know, React and JSX and all that.

So I thought like it might be fun to go back to a an existing web 1.0 web page is Richard Storman's personal current website. Oh, yeah. Could you like just teach us a little bit about what's going on here? What are the underlying things? What's the buttons like? What are the what are the affordances provided by the web that Richard's using here?

Yeah, yeah. So this is very much an old school, very, very old school web page, you know, and there's always been this tension on the web, like, is it a document? Is it? Is the web about documents? Or is it about something more than documents? And how and if so, how much more.

And so here, you can see sort of a standard web 1.0 style web page with a bunch of links or anchor tags that link to various things and let you click on them. So I just click here. So inspect. So here is an anchor tag. So it's an anchor tag.

Yeah. And so the important, the important thing here is the href attribute. So that href attribute, which specifies another URL, that when you click on the on the text that's included inside that tag, the browser, which is a hypermedia client is going to issue an HTTP GET. And it's going to take whatever the hypermedia response is to that and then load it into the browser.

How it's loaded can be affected by a bunch of different things, affordances. So there could be a response header that tells it to do something specific, maybe do a redirect or something like that. Well, let's take a look because you know, we can something I definitely encourage people to do is to kind of watch their browser, doing that, which you can by popping up here.

And if I refresh, we can see. Yeah, you go ahead and Yep, exactly. So you can see this is the response that came back from that GET request. And so you can see the request URL that was made to and just a bunch of these are these are headers, these are basically named value pairs.

And there are some that are sent as part of the request. And then there are some that come back as part of the response as well. And that's, that's all tied up. And that's actually the body of the response. But I guess we should look at the response headers.

Yep. Yeah, yeah, these are the response headers. So you know, there's an E tag in there. And that's what they actually all this. Yeah, that's what it looks like when it writes raw. Yeah. So HTTP. So the way you're looking at here is sort of a partial representation of HTTP, which is the underlying transfer protocol, the hypertext transfer protocol, it's what HTTP stands for.

That's the that's the core network format for the web. And that's how web browsers in general make requests, even when basically, so I was just gonna say, so we basically have two affordances here, right? One affordance is like, underlined things I can click on just the links or anchors.

And the other is a form I can fill out with a button. And one of the interesting things you point out in your book is, in terms of like, HTML itself, that's it, the entire set of affordances provided to interact with a web page. Are those two things? Yeah, yeah, affordance is a it's such a broad word that I think people could could argue about that.

But those are the two primary interactive affordances. Or another term I would use for those is they're the two main hypermedia controls, interactive hypermedia controls in HTML. So, so taking a step back again, when you've got so how does the web work? Well, you've got documents, let's just start with documents.

And this is a, this is an HTML document stored somewhere. And when that document comes down, embedded within the presentation information, are these interactive elements, the control elements is what Roy Fielding, the a tags and the form tags, a tag and a tags and forms. And you can also argue that like an image is a hypermedia control, because it's going to drive another request that downloads an image element that's then inserted.

And so there's a you can get into the weeds and that kind of stuff. It's not interactive to use your terminology. Yeah, it's not it's not something that the user selects, you know, when Fielding talks about what makes the web special, he, he talks about users selecting actions based on Fielding.

Sorry, Roy Fielding, Roy Fielding is the guy who wrote the famous or somewhat famous, it was much more famous, I guess, in the past, dissertation on the web architecture. And that's what gave us the term rest. Yep. So that dissertation, he and I'm going to be honest with you, the dissertation is a little hard to read.

But, but one of these core ideas with the web has always been the embedding of interactive information directly in the document in the presentation information. And so you have this mixing of concerns between the presentation as well as the, the network stuff you can do with the presentation now in a document like, like fieldings, like, you know, it's hard for a lot of people.

It's like, these are just links, they're just links to other documents. Yeah, that's true. But then that form starts to get at what really, you know, I think HTML two added forms, and when forms were added as a hypermedia control, that really is. Yeah. And so you can see there, it's action rather than href.

I don't know if that's good or bad. There's a lot of inconsistencies in HTML. It's a very, it was grown very organically. And so as the text, but yeah. Yeah. And so forms are much more complicated, because they, you know, the the form of the request that's made depends on the state of the inputs inside the form and all this other stuff.

You can also issue posts. So you see there, it says method equals post. So it's going to make a, it's going to make an HTTP POST request rather than a GET request, which is what we saw for the links. And so the forms when forms were added in HTML two, I think that's when the web went from really sort of a traditional hypermedia system, like the old school documents, like the way the web kind of grew up was it was, it was more of a document oriented system.

And when this form came along, it was sort of like a spark that made it possible now to build app web, what we today call web applications. And I don't know how much thought went into that, like how revolutionary that was. I mean, I remember at the time it happened, it was, it was exciting, because like, going behind the scenes as to what happens, like when a POST request happens is the contents of that form gets sent to your server.

And then at that point, you can run any program you like, do anything you like, and send back a response. And so I remember it was like an exciting time for the internet, because suddenly, you could compute on these things. Yeah, they really converted the web from a document, you know, a document based, like kind of like gopher, and I go and go for wasn't a great example.

But there were a bunch of these sort of document oriented hypermedia systems that were around even, you know, low, just purely local ones. But when once you got forms that now you have a distributed application architecture, and now and not necessarily a good one in many ways, but but had some real big advantages to it.

The primary one being that there was this sort of universal client, the browser that was available everywhere. And so to give your application to people, you just had to give them a URL. And that was it. And that's, you know, that's one of the that's one of the reasons why the web, despite all the problems with it, has has done so well.

Yeah, well, let's talk about those, like, limits or constraints or whatever. So I will, you identified them, and you list them in the book very eloquently. So I'm just going to go ahead and tell you what you told me. So, so some key limitations here of these interactive affordances.

Okay, number one, there are only two types of things that can interactively generate a request. One is the anchor tag. The second is the form. Number two, anchor tags can only call get request. Forms can only call a get or a post request. So they're pretty limited in what they can do.

So they're limited in terms of the elements, then they're limited in terms of like what, what interaction can cause a request. And so, in this case, only clicking a link or clicking a button can cause a request. So things like scrolling, you know, moving a slider, scrolling something into view, typing on the keyboard.

And then I think perhaps the one I found most interesting, because it just seemed such a such an obvious implicit thing to me, I'd never realized it was a constraint, is that when you click on a button, you know, yeah, or, or a link, the information that comes back from the server, there's only one thing that the browser can do with it, which is to replace the entire web page.

Although in this case, it looks like maybe Richard Stallman's site search button actually doesn't work. But oh, yeah, here it comes eventually. So what you what you just saw there is one of the problems with the web, right? There was no visual before, like the browsers have actually gotten much worse at this, telling you hey, something's going on, like, wait.

Yeah, so the result came back from the browser. And the result of that, in fact, I guess we could do the same thing we did before, right, which is we can go into our network tab. And if I refresh this, it should be an option to refresh the post request.

And we should be able to see it here it is. So there's the post request. And the request headers include, you know, various things. But I guess the interesting one is the payload, which is the form data. The response thing comes back, which is HTML. That's the body of the response.

And so the server, yeah, tell us about what happened then really on the server when it received this HTTP. Yeah. So the server received that post request HTTP is a very simple network format. If you've done if you've ever studied any sort of networking at all. It's very simple.

And so the those name value pairs were encoded in the body that was sent up. And so one of the one of those values was the search term. And then on the back end, there's some program that executes and figures out which pages have that term that you've passed up on it, and then constructs URLs to link to them and then presents that beautiful search result that we saw in the in the screen.

And it's sort of a full page thing. And there. I noticed that they did not use the very common, first of all, they used a post rather than a get. And arguably, that's not correct. Because for a search, you're not you're not asking it to mutate anything. And so you probably would using a get would actually make like the input values would end up in the URL, and then you would have a copy and pastable search, URL and so forth.

And so I noticed that they also didn't do a redirect. So when you hit refresh, you saw another post. Yeah. And depending on exactly what the post does, that can be a bad thing, right? Like it buys a ticket, you know, it could buy another ticket. So it's, you know, just this is sort of like the old school grunky web that we're looking at.

Okay, so yeah, so this is the thing that blew my mind, Carson is that you identified these four specific constraints of what a web browser can do. And those constraints are determined by the specs themselves, right? And somehow, and we'll come back to how later, I don't know how, but somehow, you realized, or asked the question, what happens if we remove these four constraints?

You realize that we can using JavaScript, and then with the right script, it's almost like a polyfill for the browser. It's almost like saying, let's pretend the browser didn't have those constraints. And like, so just adding a single script tag, it's like, okay, now the browser doesn't have those constraints.

And so that is HTMX, right? HTMX is like the polyfill, where we say, let's pretend the browser doesn't have those constraints. And so you have then a bunch of examples here, right, such as click to load. And it is still, let's find it here. Okay, so you've got a table, right?

And in this table, when I load more agents, it loads more agents that it did not refresh the screen. And, you know, the actual button here, which is in the last row of the table, we've got a new one now, but here we are in the last row of the table.

Yeah, it'll call span, good old center tag and call span three. Here it is. Now you're not, you know, this button, it's, you know, it's not in a form. It doesn't do a submit. It's like, but it's all still just HTML. And on these examples, I love that I can actually click show.

And it actually shows me the HTTP request that happened, right? The HTTP response that happened. And so we've got something that looks, in a lot of ways, a lot like Richard Stallman's website. But it behaves like a modern, you know, SPA style app. So I guess like, I was thinking like, well, maybe we should, like, how do you think this is best to explain?

But like, how is it like, what are the constraints that we've kind of removed here? And how is removing those constraints, in this case, allowing this button to do this thing? Because... To do some magic. Yeah. And actually, maybe before we do, I'm going to switch over to a version where we get to see the server.

And of course, I then get to show off FastHTML, which is like an extremely simple wrapper, largely around the genius of Carson's work, and also the genius of something called ASGI. And the details don't matter. But here, this is basically says, this is a route. So when you go to slash, call get, it's going to return a table with a table header with name, email, and ID, a table body with five copies of making a row, which has an agent and a null.org and an ID.

And at the bottom, it's going to have that button that we saw. And so if we run this, I think it's kind of fun looking at it on the server, because we can now see the server running. So if I go there, you can see something looking pretty similar, and I just do one at a time, load another agent, click.

Sure. Click. Yep. And yeah, it's it's actually calling when I click this button. It's actually calling more. And more is just returning, you know, another row plus, yeah, add row. And if we look at the network tab, when we click load another agent, we can see more. And it looks very similar.

It's a get request, it's to a URL, it's got headers. But the response is pretty weird looking. So yeah, where do you want to start? How do we how do we learn about how these? Well, let's go look at the let's go look at the button. Look at it.

I think you just inspect it. And we can go through each of the attributes on it. So basically, HTML consists of attributes, they put in your HTML, because that's how HTML has worked, you know, you use attributes to specify network interaction behavior. And here, there's three attributes. So HX get HX target and HX swap.

So they've all got an HX dash on the front. So does that mean Yeah, all of the stuff you're adding is always going to be have this pretty Yeah, yeah, we use the HX prefix to namespace it effectively. You can also some people prefer using data dash HX because that's more that's in spec.

But I've been told by the browser people that this will never break a browser. So so I like the shorter version of it. But what HX HX get says it's effectively the same as a trough. It's saying, here's a URL that I want you to interact with, like, here's a here's a hypermedia endpoint that I want you to interact with.

And that endpoint is then specified as slash more, which you've set up a handler for. In fact, let's just take a look at that. So here's my more. So when Yeah, so when somebody clicks this button, it's going to send a request to and a get request. And now I get and this is the thing that I find a lot of people don't understand people like are you using PyScript or wasm?

Or like, how are you getting Python in the browser? And it's like, we're not this is running on the server. Yep, yep. Yeah, everything's it's it's much it's much more like the traditional web application where your HTML I don't want to say it's dumb, necessarily. But it's it's just everything specified in terms of what I would call hypermedia interactions, rather than in terms of, you know, sort of programmatic interactions, where you're consuming an API and building stuff sort of locally in the browser.

So that first attribute hx get is specifying sort of where to send the request to and how to send it. So you can do hx post if you wanted it to be a post for some reason, or whatever. But hx get makes sense here. And then the next attribute is hx target.

And this is really I think, this gets at that last element of I think, yeah, probably. Yeah, I agree. I think it's the most important one. What this lets you do is say, okay, you're going to get back some HTML from this slash more URL from this request, this get request you make to that URL, where do you want me to put it?

So normally, it would just be like, just replace the whole page. And I call that a full the full page refresh. That's the normal. Exactly. So that and that's what links and forms do by default in HTML by default. And so this allows you to say, okay, when that HTML comes back, I want you to put it here.

I want to put it here it is here is hash replace me. So you're using CSS, select a syntax there. Yeah, exactly. So we decided to reuse the CSS, like just it's universal people understand it. Yeah, we do. And so that tells that tells htmx where to put the content that comes back from the server.

And then the the next attribute, which is hx swap, tells htmx how to place it. So in this case, we want to replace the entire table row with two new table rows. Right. And so that that so there were two new table, actually, maybe we should just look at that network tab again to see the two table rows.

Yep. Okay, so here's the response we get back, there's the table row for the new agent. And there's just a copy of right, basically the one we just saw. Yeah, same button, right. And it's gonna replace my name, same element, and so forth. Yep. And so, you know what, with this, this new HTML is now going to replace the entire existing table row.

And so that's what because of that, and that's going to replace the entire thing. Now, there's there are other options. So for example, you could say, let's use one, let's use one now, because actually, I think we could like, simplify this a little, right? If we took the table, and if we gave the table an ID, okay, so we give that there.

And then like, we could just like, say, Alright, let's like, can we kind of like do something like this, where we just return one row, maybe like return it just before the, I would change that to a, I would change. Let's see, how would I do this, I would, I would make add row no longer in the table, I would put it after the table.

Yeah, exactly. So let's just grab the button. Grab that button and move it out of the table. And let's just do exactly. Okay, and so we don't need add row anymore. And we can take the ID off of it. Okay, that makes sense. Body, I kind of like these little lines that VS code can add.

So you can kind of see this is where the T body is. Okay, I would put it on the T body. T body. Okay, well, in that case, I'll do that, too. Because that's where that's where we're gonna, that's where we're gonna append the thing, right? Ah, okay. All right, we can do that for sure.

So okay. We've now got T body, we've got these rows, add row, ID equals agents. Okay, that looks pretty good to me. Okay, so now we don't have an add row anymore. That's easy. Sorry, I'm learning fast HTML as we go. Please, absolutely. Yeah. The interesting thing about fast HTML is because it's a direct mapping, like one to one mapping.

So in fast HTML, the it kind of there's a almost unique thing about Python, which is in Python, you can have positional and named parameters. And here you can see this doesn't have a name. And so you can have as many of these as you like, and they become positional parameters.

So they're children. And then you can have as many of these as you like. And as you can see, these are named keyword arguments, and they become attributes. So it's kind of like the mapping between HTML and Python function syntax is almost uniquely perfect. Yeah, yeah, yeah. Okay, so now what we want to do is we want to change HX target to be agents, because we're going to target that T body with the response.

And then, rather than outer HTML, we're going to I'm gonna have to go look this up. HX. I gotta say the reference for HTMX is great. I just type HTMX reference. And it's really nice. And here they all are core attributes. Yeah. So we want to we want to for if you look at HX swap, we want before and that's the terminology that the DOM API uses to insert something before it because we want to insert this new row before the end of the T body, not after the T body but like, as its last child effectively.

So before and as the right HX swap for that, I think. Nice. So I think that should work. And now what's going to happen is there it is. Yeah. And if we Amazing. inspect, not at all. Then we should see I'm always a little shocked when my stuff works.

So now we've just got one thing coming back. So I think this is a great example of like, what happened here. So maybe just talk us through this revised button here. Well, so we moved it, we moved the button out of what we were replacing, like previously, we were replacing the button with a new version of itself.

And that makes sense when you're doing things like for example, loading another page, because you want to update the you want to update the URL with like the next page. So when you load the second page, you want the button to then load the third page. And so you want to have a chance to update the URL.

So it makes a lot of sense in sort of a click to load more scenario. But here, when we're just like adding new rows to to a data structure, it doesn't make as much sense, you kind of want it, you're hitting the same URL over and over again. So in that case, why not move the button outside of the target area.

And this is the same, you're just going to HX get is the same. The target is a little different. We target the T body because that's where we want to put the new content. It's not we're not replacing a parent. Yeah. And and then that beforehand says, okay, when you get a response, I want you to stick it before the end of that T body.

So that's the that's the DOM way of saying like at the end of the children. So I think something that I didn't understand at first is how extremely small the surface area of what HTMX touches is, you know, and it's basically the core attributes. And there's also, I just having a look.

Yeah, there's a few more here. Well, some of them are really obvious, like, oh, this is just the same thing, but a different verb. Yeah. Almost none of those I've used. So I can say confidently, this is basically the surface area that normal people like me need. Yeah. And then like you kind of said, the, even the contents of them are like, copied and pasted, like to the name, the semantics, everything to like how the DOM works.

So it's like, right, kind of like very direct mapping. And even then you've also like got two versions of swap or B or not two versions of select or B or not. So there's like, it's a very small little set of stuff to know. And when you know the basics of how the browser and the web works, it's super natural.

That's my experience with it. It well, I think it rhymes really well with the web, like it goes with the grain of the hypermedia infrastructure. And so if you're familiar with and comfortable with that, which as you pointed out, a lot of younger people aren't a lot of younger web developers, I should say, aren't, then I think you come across as being very foreign, you know, so I think that's why you see some of the misunderstandings around HTMX, just like, Oh, this is terrible.

Like, why would you do this? Everything has to be a network request. Well, not everything. Yeah. So I think it's not, it's also like, surprisingly fast, because the kind of full page refresh, I think, often it feels slow, and it is slow, it feels slow, because you see the whole thing flashing and changing.

It is slow, because it requires like the browser reparsing the CSS and rehandling any JavaScript and relaying everything out. But when you just insert, so this is what I noticed, you know, when I was showing the CEO of Vercel this, you know, and he was trying it out. And particularly because like, Vercel has this kind of edge caching thing working.

And he was just like typing and hit enter. It's like, boom, boom, boom. He's like, his mind was blown. He didn't, you know, he was like, I didn't know this is what the hypermedia application can feel like. Yeah, it can feel really good. And the browsers are very good at displaying hypermedia.

Some would argue that's what they're designed to do. And so, you know, I think, yeah, the, you know, obviously parsing, like little bits of HTML, that's something that browsers incredibly fast at and inserting it into the DOM is also very fast. Yeah. And so if you're not trying to do a bunch of like reconciliation logic, like a lot of SPA libraries do, you can be very fast, you don't, you are, you know, to an extent, you're more dependent on network, like network latency.

I guess you're in Australia. So I have the worst, because I'm using American servers, and I'm in Australia. And so the speed of light basically means our ping is 70 milliseconds plus. Right? I gotta say, it's not bothering me. Can we can we pick another one maybe? So we've looked at like, okay, the what's maybe the most important, which is, you can arbitrarily update the DOM of the existing page just by passing back an HTTP response.

Maybe another one to talk about then would be like we can respond to events other than clicking something. Is there a good sample here for? I'm gonna always point at active search as being well, we could do lazy loading, or do active search, which one? Okay, so here's active search.

And this is I have to say this. Yeah. So like AES is what I always do. Yes. Okay. And I didn't hit enter. So I'm just typing backspace, backspace. Hey, yeah. And let's have a look. We've got so I've typed five things that resulted in five requests. And so now interestingly, it's obviously done some debouncing because I typed AES fast enough, it just sent one request.

And then I started typing backspace, wait, backspace, wait. This time I typed it slower. And so I can see it's basically it looks very normal from what you've described. So far, we've got a post, it's got some data. Yeah, this response. So should I look at this element to see how I would I would go up and we can look at the highlighted code.

It's a little easier to explain if you go to the top there. Okay. Let's zoom in a bit. So this is that's a obviously a pattern people are familiar with from like Google and like a lot of more advanced web apps. And I called it active search. I think I forget what Google calls it.

But and this is achieved with four htmx attributes, really three plus one, we'll talk about at the end. But we once again have an HX post here we have HX post instead of HX get because we're issuing a post I in an ideal world, this should be a gap, but I won't go into the reasons why we don't need to see the the server side code for this.

But like it's pretty obvious what it would do or take the right data, it would do the search and it would return the HTML that we just saw. Yeah, exactly. And really the big the big difference here, the thing that's new here for for people who are watching this and have never done any I've never seen htmx before, is this HX trigger attribute.

And what that HX trigger attribute specifies is the event that's going to trigger a request. And so it's the event that we use as input. And then there's a couple of modifiers on input. The first one is changed. Let's just go back. So tell me what is the event input?

Is that a normal grammar knows? Yeah, exactly. Input is a is a standard DOM event that you can look up like on Mozilla on MDN. And it basically corresponds to a key up. But when it's it's when when the input changes in an in an input of some sort.

So it's going to be triggered by checkboxes like when you check them and uncheck them. With text boxes, it's triggered whenever the text changes. And this is something I really like about htmx is when I want to know how to do something, you know, and it's nearly always like, Oh, well, this is just doing this DOM thing, then the doc, then the document I search is like, you know, Mozilla web docs.

Yeah. It's not like, oh, here's the special dashboard abstraction that Carson wrote, or whatever. It's just like, no, it's just the web, man. Yeah, yeah, I tried very much to lean on existing ideas. So you know, again, as you pointed out, the HX swap attribute uses the standard DOM name, like they're not the names I would pick, but I just figured, you know, we might as well stick with as much as possible with what the standards are.

Yeah. And so we tried to do the same thing with fast HTML, you know, like I say, like, you know, there's a lot of people who have tried 1000 different functional HTML builders. And I thought like, well, you know, HTML is kind of XML, their tags, they have a name, they have positional parameters, they're called children, they have keyword arguments, they're called attributes.

Python has those things. So it's just those things, you know, it's kind of like, I think this thing of like, embrace the technology you're working with is a theme that I think we're both going for here. Yeah, like, I like the term rhyming, you know, make it rhyme. Yeah.

And so I don't know, but that just appeals to me. So in any event, yeah, input is a, it's a standard event. And it could be any event, you know, you could even use and people do do this, you can use custom events to trigger requests, if you have done that was very helpful.

And you could delete all this. This is like a bit of extra. Yeah, extra coolness. But all you actually need to make this work is just this one word. Correct? Yeah. And so the next two things are modifiers for that event. And so there's the change modifier, and then the modifier.

And the change modifier tells HTMX only issue a request if the value of this input has changed. So you don't want to like if someone hits an arrow key, for example, that's not a reason to issue a new request. And then the delay, you notice that there was some sort of D bouncing going on.

And that's what that delay colon 500 milliseconds is doing. Yeah, that's saying basically, when an input occurs, wait 500 milliseconds. And if another input hasn't occurred, issue the request. Otherwise, just reset the timer. So Carson speaking as like a user, something that I like a lot about this, but at first made me nervous is a lot of the code I saw, including on your website, had like, a lot of unfamiliar words in unfamiliar syntax.

And I thought, I'm not clever enough to understand this. But then I quite quickly realized, like, you can delete most of them. And it still works. The bits I recognized, which is like respond to this event, like a fine. And so I actually found it suited me quite well to gradually learn these extra bits.

And your book is great at this. So the entire first section is about web 1.0, you have an application branch. All of section two is about HTMX. And you introduce it like, super gently, you know, right. And just one little bit at a time. So you know, I would encourage people to just go through this book.

And then the other thing to say is the mapping between just like the mapping between HTML and fast HTML functions is a simple one-to-one mapping. The mapping between HTMX attributes and fast HTML attributes is also a one-to-one mapping. You just literally replace the hyphen with an underscore. Yeah. So like, you know, folks could go through, I think folks should go through this book and build applications.

And if you're a Python programmer, you don't have to learn any JavaScript. But in the process, you'll be learning a little bit about, you know, JavaScript things and HTML things like HTML. But you know, this book is a really great way to gradually build up to understanding these like optional extras, in my opinion.

Right. Yeah, no, it's always tough to balance like, you know, you want to you want to be useful for the advanced users, but not too hard on the new users and so forth. So it's, it is tough. I do think the book is pretty good at making it a general introduction.

I appreciate you saying that. So and then there's a comma in there. And then there's so the events are comma separated. So there's also a search event. Okay, so this is event number one, which is an input event, but only if it changed. And only if there hasn't been one within 500 milliseconds.

And this is like or, yeah, or this is a search event. What they search event, search event is triggered. For example, scroll down to the UI. So what browser are you using? You're using Chrome? Okay, so that little x on the side there. Yeah. When you click that, a search event occurs.

I don't know an input may also occur there. I need to actually because it was Yeah. And that's because like, there's a lot of stuff in HTML nowadays, including this type equals search. Yeah, exactly. And so so that search and there's I think there are other like keyboard shortcuts.

I don't know the details of it. But we felt like, okay, we're gonna, we're gonna issue a request on the search event as well. And like I just showed example here. So we use this thing by default, you can use whatever styling we like, but by default, we use this thing called Pico, which I'm sure you're familiar with.

And one of the things I like about Pico is it really leans in also to the idea of like, just embrace, you know, the web. And so here's a rather nice, reasonably, you know, reasonably nice looking search box. Right. And as you can see, it's an input with type equals search.

Yep. And a button, you know, and in fact, the source code for this is literally form of equal search. So yeah, I think by like embracing the stuff that's available in HTML, and then joining it together with things, other things that embrace that like Pico and like HTMX, you can have very kind of, I don't know, it feels like the stuff you learn as you put this together, all joins up together.

It's very different to learning like, this dashboarding system, and you want to use a different dashboarding system, throw away everything and start again, you know? Yeah, no, I agree. I think that's a good thing about HTMX. And Pico CSS is a great library as well. And that it's just it, it, it does, you know, again, rhyme with like, and tries to reuse the existing concepts of the web or other than imposing a bunch of new sort of mental categories on top of it.

So yeah, okay, so that Okay, so either search or input. All right. And then target we've seen so the search results and this is a kind of a common pattern that I guess we see with HTMX is you kind of start off generally, let's just like close, let's just refresh this, you kind of start off with so you've got a table, if you open that table up, there's a table body in there that's got nothing in it, but it has that ID on it.

Yeah. And so we're targeting that that that T body, and the default swap is going to be inner HTML. So what HTMX is going to do is take the response that comes back and then put it inside of that element. And so that works for this. So yeah, that's the that's the idea there.

And then there's a last attribute, which is kind of a new one, the AJAX indicator, I haven't used this yet, but people rave about, okay. Yeah, you use that it takes a CSS selector, and that you can point it at an element, and it'll basically show that element while the request is in flight.

And that addresses that issue you saw on Richard Stallman's web page, where you click the button, and it seemed like nothing happened for a second, because it was Oh, I see that searching thing popped up. Yeah. And so I see it. But yeah, yeah. I was so sometimes I make this slower.

So that like, yeah, I can see the indicator. Yeah. And then people complain that HTMX is slow. And then I speed it up. And then they don't see the indicators. Okay, great. Yeah. Let's that's what that's there for. Do you have a hard stop at some time? I just want to think how much time to spend on different things.

I don't I can talk. So let's look at the lazy loading one, then. That's okay. So here's that demo. Tokyo. So here, refresh, refresh. Okay, refresh. And you'll see like, this is a big indicator. And then I see. So if I scroll with let me just I think I understand.

So if I make this smaller, yeah. And then I do that. And then I scroll to it. I see it's kind of happening in the background. And yeah, okay, cool. So the reason for that is, if I wanted to, like, have something I could start reading, or else something else was busy calculating underneath.

Is that what's happening? Yeah, this is a this is a good pattern for when you have some some information that is maybe even even if it's important, it's something that you don't want to block the rendering of the first render of the page, you don't want it to block that first load of the page, because it's going to take a while.

So this is just I mean, it's just a dumb image, like, but it's a stand in for Okay, here's some complicated stuff that we did to compute, you know, Tokyo's climate or whatever. Yeah. And so the important thing here is that the rest of the page renders very quickly.

And then, and then we can issue this request, sort of when the page loads to sort of have a second error request, it's going to bring in the expect the expense of computation. So looking at this div, we want to once again, have an HX get where we're going to issue a request to URL that's going to make presumably take a while because it's expensive.

And now this presumably would be basically returning an image tag or like a div with an image tag, an image tag or whatever. Yeah, whatever. And then that'll get loaded into wherever the target is. Yeah. And I guess in this case, the target is itself. Yeah, the target is since we don't specify a target, the default target is going to be the div itself.

And just to come back to your last thing, you said also that the default swap is the inner HTML. So this is going to be swapped out. Exactly. Okay. And then the trigger here is load. And that is, unfortunately, that is not a standard. But I just I couldn't resist making a specific event called load.

Okay, so you've got HTMS events here. And we can scroll through them to see there's quite a few events. And here is yeah, load. Yeah, this is actually if you go to the docs, it's not I don't think it's this is a this is triggered when an element is loaded.

But it's in the docs I mentioned. And if you go and look on htmx.org slash docs, there's a there's a section on events. Oh, actually, well, if I go to trigger, I guess that would be the best way. Yeah, it's probably in there as well. Yeah, there's a couple of special ones in there.

Cool. So I'll just search for load. Here we are non standard events. Great. Yeah. So we have load we have revealed and intersect revealed. And like, have you ever worked with the intersection observer in JavaScript? No. Okay. The the way JavaScript handles sort of like things scrolling into view is pretty complicated.

And I wanted to declare the API. And so I just kind of put and the same with loading uses, I forget the name of the event. It's a big, ugly name. And so for these three things, I was like, look, I'm just gonna have like my own obviously named events for this stuff.

And we'll, we'll just have to deal with it. And so make sure I kind of clarify both myself and for other people are just confused. There's two of these two different load events htmx colon load versus Yeah, this load. Anything that starts with htmx colon is an event that htmx itself triggers as a custom event.

Yes. These are these these three events are synthetic events that htmx makes work as if they were real DOM events. Okay. htmx colon load before. Because like I like to set up things so that when I'm working with a JavaScript library, that when htmx adds something to my page, the JavaScript library can run on that as well.

Exactly. Yeah, that's exactly what it's useful for. So maybe not the best name in the world, but it is what it is. Okay, well, this is pretty straightforward, then, isn't it? So you've got this div targeting itself. And when it's Yeah, when load is done, it's going to go ahead and stick the graph in here.

Yeah, exactly. And that's so this can be very, a very good way. Like if you have a part of a web page that is expensive to compute, and it's making that web page, the first paint of that web page very slow, you can just move that that chunk out to a new URL, and then use this pattern.

And then suddenly, that web page will load very quickly. And you know, the other stuff will come in when it's ready, but the user can still interact with the page, they can still click on links, or if they get sick of waiting, or whatever, they're not stuck there waiting.

Like we were for that search result on Stallman's page, just wondering when this was ever going to come back. Right. Exactly. So okay, great. I, I wanted to just maybe show folks how then all this works together with, like, CSS and JavaScript and, and all that stuff, because like something else that I found interesting is how the fact that HTMX removes those four constraints doesn't really impact at all, how I use styles or JavaScript, you know, right.

So like, I'll just share a couple of things. You know, to maybe make that more clear for folks. So for instance, the other thing I found interesting, Carson is like, combined with fast HTML, and also combined with this really nice deployment service, we've been using called Railway, where you can run as many things as you like, and they cost two or three cents a month, you know, unless lots of people are hitting them.

And so there was this interesting thing where I wanted to create this little mini page, you know, where I talk about things like HTMX and HTTP and memes and stuff. And I, what was wild to me as I started doing this was I like realized, I kind of created this thing, which has like all these like little things like this auto updating kind of side and like things that wave over when you go over them and they're very bold.

It's like, oh, like some blogging content framework and I'm like, actually, no, you know, this is just a fast HTML page. The source code for this page is like, you know, it's just marked down with like a tiny bit of code. And all the work happens actually, in Bootstrap, you know, right.

And so like, with Bootstrap, you know, I was able to basically create this tiny little thing for this page, probably here, called like a Bootstrap page, you know, so overview basically says return a Bootstrap page, it's page number zero. So that's why it knows which one to make bold.

This is the title of it. These are the sections like there's all these nice little things in HTMX. Like, if you return a title tag, as one of your partials, it actually changes the title of the page, which is sweet. You know, like what's a section? Well, section is just like, you know, just a div, you know, with, so like, all the CSS is just really normal.

And then like the JavaScript, and I think this is the bit people get the most confused about, is also really normal. So if you look at, you know, we have fasthtml.js, for example, for markdown, if you create, have a marked class on anything, and then you basically add a markdown.js component to your page, then it runs a bit of JavaScript.

And now all of your markdown is automatically done. Or, you know, you can do the same thing for highlight to get syntax highlighting, or my favorite ones, sortable. Yeah, this one like, actually, I much prefer my version, because it's less clever than yours. It's much easier to see. This is my version of sortable.

That's the entire thing, is you just got sortable create. And so it's down there, drag and drop. Yeah, you end up with this, this ability to drag and drop. And the cool thing is that behind the scenes, it's telling the server what the new order is. Yeah, yeah. So yeah, this is a great example.

Like, you know, sometimes I've heard a lot, especially now that htmx is getting more and more popular. And the JavaScript community can't ignore it anymore, or make fun of it like they used to, is people say things like, oh, htmx is for people who hate JavaScript. And there's some truth to that.

Obviously, if you're not a big JavaScript fan, htmx can give you a lot of oomph. But also to really to take advantage of htmx, like the events, the fact that it uses events and integrates, like with the DOM via events, means that it should be able to play very well with JavaScript.

So like, let's run this little, so I've got this kind of like idiomatic app I've created with like, most of its comments, you know, and so like, you know, here's the bit, here's the bit that makes it drag and drop. Describes how that happens. And so if we run it, and then I say like, okay, let's show prioritization, drag it to the bottom.

Missed, drag it to the bottom. There we go. And if I now refresh, it's still at the bottom. And yeah, it's magic, you know, and like the, like, how does that work? It's like, I think this is really interesting. It's like, okay, well, we include this library, which as we described, is literally three lines of code.

And I added this tiny thing, Carson, which is just a little JavaScript thing that just basically does a htmx for each onload kind of thing. So it causes this to happen on all new things as well. And then sortable, it's kind of amazing how all these things you made just come together.

So we have a form. And so the to do list itself is actually inside a form. And so that form is triggered by the event that the sortable docs say is triggered, which is the end event. I didn't have to do anything. And then it just calls slash reorder.

You know, and then reorder is two lines of code, you know, it updates each to do to the new priority and returns. This is the reason my code simpler than yours is because it's less efficient. I returned the whole to do list. You know, it was just fine. Yeah.

So sometimes that's the right thing. JavaScript is such a delight in htmx, because I only have to use it for the bits I need it for, you know, right. And that's so you know, I say htmx is pro JavaScript because of that, for that very reason, it takes the pressure off of JavaScript to be the entire infrastructure for your web app.

And so it can be used for these situations where it really can add a lot of value. So drag and drop is something that's not baked into the web out of the box, at least not well by default. And so these, you know, sortable JS addresses that and provide some really good functionality.

And then htmx can integrate with it via events really cleanly. So a really that's a another great example. I think of htmx being being used the way it was intended to and sort of playing well with other things, you know, it's designed to be, especially with it's a focus on events, it's designed to plug in reasonably well with other libraries, as long as they, you know, as long as they play well with the DOM to triggering events, and then using inputs to communicate information out to the remote systems.

So let's switch topics a bit if we can. And the reason that I, or a reason I use the much unappreciated epithet, genius is because the most things that I come across, and I say, like, that's clever, I can immediately think like, oh, I see exactly how they came up with that, you know, but like, my friend, Chris Latner, for example, who's created like LLVM and Mojo and Swift and other things, like, very often I have conversations with him, where he describes the thing he's created.

Having described the thing, I can say like, yes, that is the right way to do that. And then I'm like, but I don't know how you could possibly have known that I only know it now that you've told me now this thing you've done, like, there are four constraints, we can remove them with a polyfill.

Once we do that, we can reprogram the web. Like, where did that come from? Because like, this goes back to like, like 10 years plus ago that you kind of first implemented this. And I hadn't, I've not seen it. Yeah. I mean, there were, you know, there was a there was something called pjax back in the day.

I don't know if you ever heard of pjax. Yeah, there was pjax. And then there was a in jQuery, there was this I think it's called fetch, or load, load, I think it's a load. And it does something similar, you give it a view, you just give it a CSS selector, like in the dollar sign syntax, and then you say dot load, and you give it a URL, and it'll issue a get and just load the response into that thing.

Yeah. And so there were some, there were some little things like that floating. Yeah, well, we were one of the first jQuery users when it first came out, actually. And so it was fun to watch those things kind of get added. And definitely Risik, Risik's a genius. You know, yeah, for sure.

Yeah, he's, oh, yeah. And so I think, like, you know, I saw that, I've told the story before, but I was just having trouble with a performance issue. I was trying to do sorting in JavaScript, in like 2009, or eight. And it just was too slow, because the runtimes at that time were so slow, and non standard and all the rest of it.

And so DOM manipulation was very slow. And I ended up, I don't know if I use the jQuery dot load method, but I did something, I think I might have seen it and did something similar, and then kind of started making that more general using the jQuery AJAX function.

Where, you know, I was like, Oh, yeah, I didn't. So I had a UI, I was trying to sort, it was too slow to do in JavaScript. And out of desperation, I tried doing it on the server side, and then just slamming it into the UI. And that turned out to be really fast.

Like, to my surprise, it was pretty desperate move on my part, I didn't think I was gonna be able to do it. Well, but, but it worked. And I was like, Oh, this is great. Okay, I didn't know you're allowed to do that. You can just put right, you know, you put HTML wherever you want.

That's cool. Yeah. And, and then so that turned into like a little function that I had for a while that was kind of more in the jQuery style of like, you look things up and hook in functionality. And then I saw Angular one. Yes, I didn't like I didn't like much of Angular one, except that they use attributes to specify behaviors.

Yeah, I was like, you know, this is, this is a lot like, like the href stuff, like links and big hit YouTube video was an angular. Okay, yeah. Yeah, I don't want to throw it through. I don't want to throw any shade at Angular. I've got no beef with Angular, and it's fine.

But it wasn't what I was looking for. And what I was trying to do, but I did like how they use attributes. And I realized, okay, I can use attributes to hook this behavior in instead of instead of using a jQuery selector. And, and so that sort of turned into that just very organically turned into intercooler.js.

And I've got to be honest with you, like a lot of the academic stuff came afterwards. Yeah, I didn't understand hypermedia very well. Yeah, when I did when I initially did all this stuff. It was just, you know, look, that's that doesn't shock me at all. You know, my, my friend and co founder, Eric Reese wrote this book called the lean startup, which is actually a lot more than just about startups, you know, this idea of the MVP.

And it's actually the basis on which answer AI is created, which is building things that way, which is like, iteratively, bit by bit, you know, and then later on, you kind of look back and you're like, Oh, I kind of built something kind of cool here. I wonder how this thing I built actually works.

And then you're like, Oh, I guess it's hypermedia. And I guess it's actually these four constraints, we actually ended up removing them. And yeah, I think it makes it less intimidating to know that you don't have to invent this new universe in your head all ahead of time, and then implement it.

Yeah. Yeah, you know, there's what's the saying, like, existence brings essence into being like, you have to do the thing first, and then you can talk about what the thing is. Yeah, it's kind of got to be there first. And then you can say, Okay, what what just happened?

You must have had some kind of intuition at some point that there was a direction forming that felt like you were enthused enough about it, you wanted to invest in. Yeah, I you know, to me, it was more just an unwillingness to deal with the complexities of like, you didn't knock out JS at the time.

And, and things like that. I just, I was like, man, I just don't want to deal with all that. No, I just, I just, I just want to be able to put stuff in the DOM. And, you know, I think when I first did it, I went through there was a within this is with the intercooler, the predecessor to HTMX, which is very similar.

It's just it's basically a jQuery implementation of the same stuff that HTMX does. I went through and I started doing examples. And then I started realizing like, whoa, you can do infinite scroll with this. Whoa, you can do active search with this. Like, yeah, this is cool. You can do a lot with this.

And so that, but that was, I discovered that, you know, I didn't think about that up front, I discovered the fact that, hey, with these abstractions, you know, with the limitations on HTML removed, you can actually do a lot of cool stuff. So yeah, it was very organic. And I definitely not like me thinking things through.

Yeah. So, no, I mean, it's, it's interesting to me, because I'm sure I've never created anything as clever as HTMX. But I've definitely created things that are at least as bloody minded as HTMX, you know, like you've kind of been like, you know, it's interesting, you mentioned Knockout, for example, most people listening probably won't remember it, but it was very popular back in the day.

And it came out as, as we were building Kaggle, which is one of my earliest startups, and some of the folks were like, we've got to do Knockout. And I was just like, we just so don't have to do Knockout. And yeah, it's interesting, you have this reaction to complexity.

It's not a reaction to like, it's not a kind of classic conservative, like, we have to do things the same way. It's more like, no, we have to make things accessible. And we have to, like, you know, appreciate what's good about what exists and take advantage of that. But yeah, it's interesting.

Like, I feel like maybe, like I said, at the start of this interview, you don't look or sound like a tech genius, you don't live in a place full of tech geniuses, you know, you're, you know, and I'm also not a tech genius. So it all checks out. Teaching kids baseball, you know, like, you, you know, and, you know, so I guess, you know, I would consider myself an outsider, you know, would you kind of consider yourself an outsider?

And would you say that's part of why you can create these somewhat bloody minded things that push back against what everybody else is trying to do? Right? Yeah, I definitely was an outsider in the Bay Area, because I was from Sacramento. And I've been like one thing I realized about my, my, particularly when I was younger, as I was very naive about, like, everything, pretty much everything.

And so, you know, the problem with being naive is when bad stuff happens, you can get pretty embittered. And so I went through that whole naivety, embittered cycle on the Bay Area, and so forth. And so, so there's definitely some people who don't know. So Sacramento is like, three hours or so inland of San Francisco, and it's like, it's pretty hot.

And pretty kind of like, it's not. It's not at all like San Francisco. Yeah, it's very agricultural or was it's the Central Valley is filled up because the Bay Area has gotten so expensive. So what I grew up in has been is very different. Now, the area I grew up in, but, but yeah, I was just not, you know, I just wasn't a barrier person.

And I felt that like the entire time was there, even when I went to Berkeley and Stanford for grad school, and just was very much an outsider. And that's fine. I'm also, you know, a little bit of a contrarian, I guess. And so that, you know, and that's good and bad, you know, it's been good parts of my life and bad and of course, but I do think like something you sort of touched on there is there doesn't, in tech, tech, technology is so forward looking, that we don't do a lot of looking back at what people had before, right, or what was done before.

And I think that's one reason why we're constantly reinventing the wheel, you know, in many ways, sometimes worse, you know. And so the with with HTMX, and with intercooler before that I really was trying to once I understood once I got my feet under myself and understood what was going on, is I tried as much as possible to rhyme, you know, that's the way I would say it is, you don't have to be the past, you don't have to dress or like, you know, act or whatever.

But like, if you can rhyme with that stuff, like, there's probably some good ideas there. And I think that's one reason why HTMX has a pretty high power to weight ratio is that it just builds on these really, like CSS selectors, and like the basic DOM APIs and events, like, you know, the, the DOM being an event bus, like, that's, those are all concepts are already there.

And HTMX really just like, is built on top of them. I mean, that's why I think I spent months, a year or two ago, teaching people, APL notation originally developed in the late 50s. Yeah, like, I definitely appreciate this idea of recognising when really deep thoughts have been had in the past.

And when you can take advantage of that. Yeah, present and combine them with new things. Yeah, like, what's a new take on that? You know, that's that can often be one example I bring up a lot is the visual basic six debugger was like the best debugger I ever used to continue so good.

Yeah, you can it was like, you could do whatever you wanted. You could drag the program count, like you could drag the pointer wherever you wanted to during execution. It was unbelievable. And my understanding is dotnet has that now, but I work on the JVM a lot. And it's got nothing like that.

Nothing close. Yeah. And it's like, and if you look back to get back, if you go back further to Microsoft Access, you know, the thing it had with these like reports and stuff was basically flex grid, you know, HTML programmable back and I was doing that, I guess, in the early 90s.

Let me just again, switch then to kind of like talking about something which I've seen with you, and I've certainly experienced myself. I very intentionally do a lot of things extremely differently to everybody else. Because I like to experiment with like, what happens when you try things differently. So I'd be able to think about nbdev, which is where you do all of your assist software development inside Jupyter Notebooks.

And I've written most of my software like that for the last few years. And it turns out, the affordances provided in notebooks are actually amazing. I've, you know, I've created an AI thing called fast AI, which kind of when everybody was trying to build big foundation models, I was focused on like fine tuning.

And now with fast HTML, when everybody's focused on Svelte, React, Vue, whatever stuff, I'm like, let's lean into HTMX and hypermedia and Python instead of JavaScript. Something I've noticed a lot is, and I've seen there's a psychological phenomenon, where when human beings are presented with change, there's like literally a chemical reaction in their brain that is identical to physical pain.

And I see that with how people react to HTMX as well, which is I often see people respond with an enormous amount of anger. You know, almost like this kind of desperate anger. And yeah, I'm kind of like, and so it's interesting how, what, you kind of have these two really different directions.

One is like, you're literally a university professor, like you say, expertly Stanford, and you create these like, incredibly academic things, looking back at Roy Fielding and HATEOAS and everywhere else. And then there's the other Carson, which is like, trolling, memeing, you know. I guess like, yeah, it's like, is it like, partly that you're kind of reacting to the bullshit earnestness of this world and trying to like, not take it too seriously?

Or like, is it kind of like an intentional thing you're doing to try to deal with the reaction people are having to this psychological pain of seeing change? Or, you know, what's the yeah, how do you see all this? I will. So I think you're right. And I'm sympathetic.

There's a reason we're like that, right? Like, there, there's nothing about us that is not there for, for some reason or other. And so change is hard on humans. So we should make, you know, allowances for that fact. Humor is for me, I've always been kind of a joker, and last clown and so forth.

And I grew up on the, you know, on the forums in the late 90s and early 2000s, kind of pretty rough and tumble back in the day. And so I got I got good with memes. And I just always preferred joking. It's funny, you know, I just I don't know, I end up like a lot of memes.

And, you know, I think they're, there's, they're good. They're, you know, a picture is worth 1000 words, and I mean, maybe worth like 100,000 words, like a good meme, and really got through a lot of stuff. And so that's it. That's one. That's one by Alex. That's pretty funny one.

So I really like humor. So like, it's so on point, like, like, it's literally what we're talking about. It's like, I was like, hey, if you do this stuff, you're just doing the foundations. And you keep doing the foundations, and they all come together. And suddenly you're like, you're really good at building web apps, you know, yeah.

And like, you know, Daniel Roy Greenfield, one of the co authors of two scoops of Django, which is one of the best programming books of all time, within 45 minutes of trying fast HTML, and he'd never also used HTMX, he had rewritten his entire blog system. Yeah, his his wife, Audrey, the other of the two scoops of Django co authors saw him do that.

The next day, she was doing a hackathon. She had never used fast HTML before she decided that morning that she was going to use it for her team in the hackathon. They won the hackathon. You know, like these people who have like learn the basics, and then they get something that rhymes.

Yeah, they zoom in. But so these memes, they're like, they're funny, but my god, they're like, they're cut to the bone as well. You know, yeah, yeah, I think I'm pretty good writer, you know, the book, I was actually better at English, like I scored better in standardized tests on on English than I did on math.

And I've always just liked, you know, I like I read a boatload when I was a kid. And so I, you know, I just, it's just a knack I've got for me. I don't know. It's not this isn't Shakespeare, but it's very effective communication medium, combining a picture with a, you know, with a short and pithy statement.

So well, I mean, when I wanted an explanation for HTMX, I, I used to I used one of the memes because it is, yeah, it did a better job of explaining what was in my head, I could use words for which is like, yeah, and actually, so Eric reason I were talking about the kind of days of when we were starting coding PHP, you've got a shell home directory, you dump a file in there, you've got a web app to show to your friends, you know, and so it was even simpler than like your 2004 model.

And yeah, you know, we were both saying like, Oh, you know, it's so painful to create an application now, right, you know, and so yeah, the picture does tell 1000 words a day does it doesn't humor works, people like humor, the people who get mad about them, like they're probably the people that you want to get mad anyway.

So, you know, I don't know, it's been a good way. I've gotten much better, though, like, you know, if you if you were talking to me 10 years ago, I would have been much more embittered about things like much more sarcastic, you know, there's, and there's a part of me that's still like that.

I just really, you know, I was about it was about 10 years ago, I just kind of was like, you know what, I can't live like this. Like, I'm not I ever got to be more positive about things. There's a lot of good things. It's so easy to be negative.

And, you know, especially with the information overload we have now. And I you know, I just was I just sort of committed to being more positive about it. And so to does it help to be away from the Bay Area, you know, living in rural Montana, probably it's, there's less financial pressure.

That certainly helps. You know, Montana is very beautiful. And like, there's a lot of nature also, you can freeze to death. So that gives you some perspective on life, like, Oh, wow, it's minus 40 outside. I don't know. I really hope the power. I really hope that the minus 40 Fahrenheit, I really hope that the power doesn't go out, because that would be bad.

So you know, I think that helps. But I think, you know, when I look back, I think I could have handled the barrier much better than I did. If I had just been a little bit more, just been more positive, you know, early on, it was early on, what do I want to say, you know, for a long time, to me, people who were sort of Pollyannish were, like, I just would, you know, like, Oh, that person's just positive.

My role is fake. And now I'm much more I tried to be much I tried to be almost fake positive, because it's not going to change so much is not going to change anyways. Right. So like, yeah, you know, you can control your, like, there's a lot of stoicism, I can't handle stoicism, because it's often very sort of like, morose.

And I just can't be like that. And so I like the more Joker. I think also, like, it, like, I've always felt like, the internet's a big place, you know, and I always feel like my, my job is not to market my weird shit to other people. But to find the other people who appreciate my weird shit, and let them find me.

And so then you end up with a community of people who appreciate your weirdness, and you don't have to spend time trying to convince people to do something they don't want to do. Yeah, well, and that's, you know, I didn't know this was gonna work as well as it did.

You know, I had, like a year ago, we basically, you know, we were gonna release the book, and I've been messing around on Twitter a little bit more, I'd taken some time off Twitter, because it just gotten so crazy. And so, but I came back and I was like, and I about a year ago, I committed, I was like, Okay, I'm gonna really like, I'm gonna engage on Twitter.

And I'm just gonna go crazy and be like the crazy person that I want to be on Twitter, and have fun with it. And if that works, great. And if it all goes down in flames, also great, like, I don't care. And I think so, you know, there's probably some authenticity there.

But there's also a bunch of risks, like, you know, this could all end in tears, probably will. But, you know, I just, I don't know, I just I really, I tried, you know, I gave that talk to big sky DEV CON, where I talked about trying to be more positive.

And I think that's been the big change for me. About 10 years ago, I just was like, I need to be more positive about things. Yeah, still be a joker, still be myself. But just don't emphasize the negative stuff so much. Don't go on it so much. No, I mean, you can find like, you can be you'll continue to be authentic whilst finding different facets to highlight internally and externally.

For sure. Yeah. Yeah. We all have those facets. Right? I'm not sure I can recommend what I did for other people. But it worked. It worked this one time anyways. So, you know, I guess the thing I'd be interested to kind of wrap up on unless there's other stuff you feel like is worth talking about is like the kind of where to now, you know, if it seems to me, you've highlighted how browsers ought to work.

I don't see any reason they shouldn't work like this. And in fact, if this stuff was built into the browser, you wouldn't probably need the HX dash pieces, you know, maybe some of it could be have a bit of a streamlined developer experience in ways that you couldn't do.

I guess like, I mean, not that it feels like a matter hugely to me, if whether that happens or not, I don't mind sticking an HTML script to the top of my pages. And in fact, fast HTML adds that script header by default. But yeah, I guess I'm curious about like, what's, what's in your head now?

Are you thinking like, there's other things I could do with this? Are you moving on to something else? Are you feeling like you know, your, the browsers might actually pick up on some of these ideas, you know? Yeah, well, I think, I think we'll, I know that the browser people are looking at HTMX and are interested in the idea.

It's a big process to get anything like that into the browser, especially coming from more of an external source than sort of the internal, you know, sources. And also the most important bit, the fourth one, the like, update any part of the DOM that feels like it would be hardest to Yeah, yeah.

So there's, there's already, it's kind of there a little bit, you can actually, there's a target attribute on anchors and forms. And that takes an ID, but the ID has to be of an iframe. So nobody uses it. So there's like, there's the infrastructure is there, it's like almost there.

So I don't think it's, I don't think it's too far of a jump. And one of the HTMX team members is working on a more formal proposal to get some of these ideas, not the full HTMX API, but some of these ideas, and HTML. And you know, I mean, it could happen.

That would be a very long term process. I do think HTMX is pretty much done as far as like what it does, and the API provides, if new technologies come out in the browser. So for example, the transitions API came out, and we integrated that into HTMX. So I would expect to, you know, do some things like that, as browser technologies improve, but I don't think HTMX is going to change a whole bunch, just fixing bugs and, you know, improving it, hopefully not.

At this point, I want to not ruin it. Like, let's I'll put it that way. So I'm going to try and keep it pretty stable. And people Yeah, it doesn't feel I mean, that's kind of partly what I was asking. It feels like it almost feels like you discovered something.

You know, you discovered the thing, and you should, you know, and then you show the people the thing, and then you've written down why the thing's good. And you've provided examples of the thing. Like, yeah, dude, where do you go from here? Oh, man, what's a well, you know, I've got other projects I work on.

There's, you know, idiomorph, which is sort of a DOM morphing algorithm that I think was an improvement over the state of the art. Okay, well, let's go slowly here. Okay. So htmx, idiomorph, because I know of this thing. But maybe you could like just quickly teach me about it.

Because it's like, is this like when you say a DOM merging algorithm? Is this kind of like what Alexia live view does or something like the thumb diffing? Like, you should explain maybe from scratch what basically, the fundamental problem and the original library. Yeah, well, I mean, the original, the original problem is, you've got a DOM, which is a tree of stuff.

And you've got a new tree that you need to take this tree and like, change it into this other tree. And you want to do that with as few changes as possible. And so that that's called morphing. That's what the way you've got that thing with like the Rick Astley video that you get playing or something is that that's is that one of these examples?

Yeah, it's not it's not in the examples. But if you go to the bottom of the idiomorph page, there's there's an example that shows that. Yes, down there somewhere. So if you watch this gif, like that top is what basically what happens is if you if you watch the top, top one, the video keeps playing, or the top ones resets and the bottom one doesn't.

And so like, yeah, morphdom doesn't work. Yeah, that's refreshing. Yeah. And so I don't want to get too much into the weeds on this. But basically, idiomorph is an improvement on morphdom. It uses something called ID sets to do a better job of matching up elements when it's trying to add.

So basically, I can return a bigger chunk of a bigger HTML partial into something where some of what I return is the same as what was there before. And it won't actually replace what was there. So to be kind of more efficient, it won't update the state. Exactly. It doesn't make mistakes higher in the DOM, because it has these things called ID sets.

So I don't know. And then there's and then there's hyperscript. Don't show anyone. I mean, you say this, because like, you know, a few weeks ago, I asked you about this. And I was like, should I learn hyperscript? And you're like, no. And that was the end of the conversation.

And then since then, I've like seen people using it. I'm like, wait, this looks amazing. Somebody on the discord yesterday had like, literally like a spreadsheet written in hyperscript. So I actually want to try it. That was pretty incredible. Yeah, so hyperscript is another project. And it's basically a scripting language.

So it's an alternative to JavaScript. And it's based on an old scripting language called HyperTalk, which was a scripting language for HyperGuard, exactly. Which is also what AppleScript was based on, you know, same. Yeah, AppleScript has given a lot of people a bad taste for that style of language, because AppleScript is so bad, which I agree 100%.

But it's, it has a lot of interesting features. I teach compilers, and I like programming languages. And so, you know, I enjoyed reading the source code to this, actually, like, it's, yeah, it's, yeah, I thought like, okay, I can see you're an academic who you probably must teach this shit, because it's pretty hardcore.

Like, I yeah, it is. Yeah, it's a it's a standard recursive descent parser and all that sort of stuff. But you can see like these things, it's just like on click toggle disabled until, you know, it has a very English like syntax. And then the really interesting thing about it, if you go up to the top, go up to the where's the nav, or excuse me, go to docs is scroll down on the left hand side, go down to us, keep going, keep going, what's called keep going.

Keep going. Keep going. It's async transparency. So if you're, if you're, if you're into languages, this is one thing that's pretty interesting about HyperScript, which is the it, the way the the runtime works, like you don't have to resolve promises, the runtime effectively resolves all the promises. I hate this.

So script code, you know, it just makes me miserable. Right. So instead of like this callback style, or doing a wait, you know, there's a if the thing you're working with returns a promise, you can do in a wait on it, but then you have to mark it as a sink and all the rest of it.

Like in HyperScript, you just Yeah, in HyperScript, you just you can put like, wait one second, and it'll do it does all the stuff for you. It like it, it waits for that two seconds, and then starts executing the next thing. And so that's a, that's sort of a, it's an interesting technical thing.

Like, if you scroll down a little bit further, there's keep going toggle loops, this one. So this scroll up there, that loop, this is a this. So one of the neat things about the, the runtime infrastructure of HyperScript is that you can have event driven loops. So this, this is, this is a loop that's saying loop until you get this event.

Right. So on click repeat until events stop. And so and then send and then there's another button that sends the stop event. So if you click on that, click meet a pulse button, yeah, it's gonna pulse, and then it'll keep pulsing until you click cancel. Yeah. Which is when you click cancel event to a particular element.

Yeah, to the previous button. And so it's sending it to that button. And what's interesting there is that if you watch the pulse, it finishes it, the pulse finishes. And that's because it that's because it's in this loop, that only after the loop is finished as a check, did I receive the stop event.

And so it's like, it's event driven control flow, which is pretty interesting, like when you're working with the DOM. So I don't know, this is definitely a passion project, I have a hard time recommending any, anyone watching this or listening to this, check it out. But it's got some cool ideas in it.

I know those kinds of projects, like I, I'm a bit the same with nbdev. You know, when people are like, should I use nbdev? I'm like, I don't know. I'm like, I like it a lot. I've written all my software for the last few years. And that, you know, people keep asking me, how come I'm so productive?

And I'm like, I think a lot of us because of nbdev. But should you use it? Oh, I don't know. It's pretty weird. Everybody's gonna think you're weird. Yeah. Right. It's funny, though, like, you know, this kind of parsing compiling stuff. I happen to have been lucky enough to have a few friends in my life who, you know, have, who are amongst the best in the world.

They're like Terence Parr, who created Antler, was a colleague at the University of San Francisco, and Chris Lattner, obviously, and then years ago, I, back in the Perl days, I used to spend some time with Damien Conway on Perl. It's such an interesting space, you know, like, like, getting down to the hardcore of these algorithms, and then implementing a language.

It must have been super fun for you just to make this. Yeah, yeah, for sure. And it's all written in JavaScript. So the parts, it's all it's all in JavaScript, which is going to be a little bit dodgy, I guess, like it has to. I would not write a Yeah, I would not write a Bitcoin miner in it for sure.

But I think for what is designed for, like little interactive elements, like where you embed the code, like it's designed to be embedded in HTML, like it's supposed to be and very readable. Like, that's one thing there's an essay, I think, what, there's an essay on the HTMX website about that about, I think it's right click view source extremism, I think is what I call it.

Hold on, hold on. It's that last one. And so this is a kind of riffing on something like Cory doctora, who's a real good writer. Yeah, right about guys very passionate about the web. Yeah, yeah, 100%. And he talked about how, like the early web, you could always look, you could be like, one of the reasons why the web was so great is you could, if you saw something cool, you could right click and view the source and see what was going on.

Yeah. And, and so that's one thing that I think HTMX and Hyperscript kind of have that. Yeah, like, I believe in that ethos, though, like, exactly. It's not open source. It's not open source. It's view source. It's no, no, exactly. Yeah. And in fact, you know, I really kind of leaned into that with, like, one of the things I created for fast HTML is like, I really love being able to like, even just view, you know, view HTMX or HTML or whatever source.

And so one of the things I kind of show people in our very first video is this idea of like, copy outer HTML, paste it into HTX. And now you've got, you know, the fast tag tag ready to go. It's like, I really wanted people to be able to grab stuff that's out there.

Yeah. Yeah, yeah, there's something that we've definitely lost in the web now that everything's like a huge massive, you know, either it's a bunch of like, you know, if you want to cry, like go and look at go to google.com and right click view source, and then go to the Wayback Machine.

Oh, I know. And go to google.com and like 2002 and view the source of that. And it's just like, guys, what are we doing? You know, like, it's just crazy. Say that the current I don't find the current Google a better experience to use than that's not I mean, it's a little better in some ways.

But you know, I do I do like the, the openness and that's one of the reason I'm on this kind of riff is just because Hyperscript is designed to be part of that. Like, yeah, you put the code in, you put the code directly in there. And you know, there's another one, I don't know if you've tried it at all.

Which is a surreal JS, which is actually what what I am after you convinced me not to use Hyperscript. Yeah, I don't know. It's almost as weird, but not quite. But it's a similar idea. Yeah. So there's this like nice example here. Yeah, you know, where you can inspect these things.

And yeah, they're just like, right there. And it's just, yeah, it's just a script tag right next to the thing. Yeah, yeah. And, you know, also this really beautiful CSS, like, not like this is 320 lines, you know, yeah. And then the CSS one is like 50 lines or 40 lines or something.

But it's like, yeah, in many ways, it takes tailwinds us, you know, you just have like me, yeah, in your styles. And then it works really well with the fast HTML approach that we were trying to create Python components, you know, where it's just Python functions, and the Python functions are self contained.

And so with something like HTMX, or with the surreal approaches, you know, everything is like, you don't need web components anymore, because right, the servers generating the components. So I'm really in that direction. Yeah, I think it's a good one. I it's, you know, and that's a quick, I mean, I guess, like, maybe a last question for you is, how's, how's fast HTML treating you?

So you got a couple of negative content, it's always easy to focus on the negative stuff. But I've seen a tremendous amount of positive stuff, too. So yeah, it's been less than a week. Let's see, we've got 2.7 1000 stars on GitHub. So it's like people definitely gravitated to it.

It was number one on Hacker News. Yeah. The reaction has been, yeah, it's interesting. Like, we get I get reactions to a few different things, right? So like, a lot of the people reacting to fast HTML aren't reacting to fast HTML at all. But actually, like, so for example, I use a different programming style guide, which I wrote fast AI style, instead of the one that most, pretty much everybody else uses called pep eight.

Okay. And it's based on like, literally 60 years of study, you know, in other communities, like, it's not bad, right. But because people see my code looking different to what they used to, a lot of people just react like, this code is wrong, or it's bad, you know, although the other thing I've seen people react to is, like, wait, it's 91% Jupyter notebooks, it's actually worse than that, because the other 8% is auto generated.

Like, yeah, it's like, it looks wrong. It's written wrong. It's written in the wrong system. So you know, I get a lot of that. I did. I get some of that too, with HTML. So yeah, doing it wrong. And then people are like, well, you know, you're never going to be able to create something that looks nice with like tailwind and stuff like this, you know, and I'm like, dude, this is like a fast HTML application right here.

You know, it's, here's a great example. This thing here is like something that wrote, like a standalone thing. And then now that we've got it, you know, it's just like card 3d. There it is. And this is like, there's some things where I just, it's a bit like what you're seeing with HTMX, but to a lesser extent, where like, this one.

So this is actually the current temperature. And it's like, well, how the hell are we getting the current temperature on the homepage of a really popular website? You know, and the cost of running this, you know, including the entire launch on Hacker News and all that is like, yeah, you know, it's gonna cost 20 bucks, right?

Three bucks so far. Man, I need to look into a real way app. It's and the trick is that I just used Python, right? And this is this function actually has a cache on it. And, and then I realized like, well, actually what so the normal Python cache basically is just like a memoization cache.

So it's like an LIU cache. So like, I wrote this tiny thing called flexi cache. You know, like everything I write Carson is just like tiny, right? So this is like one of the biggest functions I've ever written is like 30 lines of code. But with this cache, you can then say, you can basically define these things are called policies.

So here's a policy cache, which is just like, Oh, let's check the time, you know, and you either return none if it's still in cache, or you return the new cache time, you know, you know, whatever state you need. So there's an end time policy. So like, we have, I basically replaced static site generators now, because I just returned file responses with an end time policy cache.

So like, it literally gives you auto reload if the file changes, you know, that thing is showing if the weather has like a one minute time policy cache on it, and it's just a decorator on the function. And so now, you know, this, you know, just updates itself once a minute.

So it's like using all of Python, really, it just feels great. So yeah, so to answer your question, you know, this kind of new generation of JavaScript only programmers, you know, there's quite a common reaction, which is like, you can't do all these things. It's like, you know, Instagram's written in Python, Dropbox is written in Python, like, it can definitely create whatever application you have in your head.

Yeah. But then there's this fantastic group of like, very experienced coders, who have like, come in to our like, Discord channel and just been like, this is the thing, you know, so like, for example, Audrey and Daniel, I mentioned these fantastic authors, and you know, really great web developers.

Within like, two days of checking it out. Not only had Audrey won a hackathon, they're like, we want to fly to Australia to spend two weeks working on this with you, please. Wow, they're going to be coming like next week or the week after, we're just going to hang out here in my backyard, man.

Yeah. So like that kind of reaction of people who I really respect, who just go like, yeah, I want to focus on this as my work for a while. And they're reacting a lot to HTMX. Do you know what I mean? Like, I feel like what we're doing is we're providing this surface to allow people to create hypermedia applications.

Right. You know, and it's just cobbling together like the idea of functional components that goes back a long time in like, OCaml, Haskell, Elm, of course, history, you know, then the, you know, the HTMX approach, you know, the, the ASGI approach of like simplifying HTML a whole lot, just kind of like cobbles together these things.

And like the whole thing's like 100 lines of code, you know, and HTMX is pretty small as well, I think, right? The implementation. Yeah, it's well, I think it's, it's 4000 lines of code now, or maybe even 5000, because we added so many type annotations. I think if you looked at like actual lines of code, it's just I don't know, man.

Okay, whatever. It found zero bugs, by the way, but it's gonna say I don't do type annotations in Python, because I've, yeah, we've got a pretty good test suite. So but it's all it's fine. It's all good. People want it. And now they've got it. So but, but it is, you know, yeah, I think if you boiled it down and sort of into normal code, I bet it's a couple 1000 lines of code.

Yeah, you know, and I don't write the most efficient, like lines of code style code, I tend to write very plotting code were at this point. So but yeah, you know, I, you say it's only 800 lines of code, but obviously, it's 800 lines of code to do the right thing or a lot better than 100,000 lines of code that does the wrong thing.

So that's one of the one good thing about getting kind of old is you start realizing what the right thing might be. Well, exactly. And you suddenly discover these people who have built, built the right thing, like when I came across surreal JS, and I was like, Oh, yeah, self contained components.

It's almost like a kind of discovery again, if like, oh, there's these things that when you put them together, it creates something delightful, you know, and combine well, yeah. So I've created all these little apps now. So like this thing of the other day, I was like, I was on the plane.

And so I started writing a blog post in Microsoft Word, you know, and I was like, okay, I want to convert this to Markdown. And I was like, okay, I can't find anything that does a great job of converting it to Markdown. I write a fast HTML app to convert it to Markdown that took me like, two hours, you know, chuck it up on the web.

And I found like, this obscure little JavaScript library somebody had used. So I basically hooked up with HTMX, you know, I used HX spells, which lets you call JavaScript kind of before it passes it back to your handler. And so I was able to that way, get this JavaScript client side cleaned up thing.

And then I used a Python Markdown converter, and then use that to update. And I it's kind of funny, though, the the way I actually had it set up is that you paste into this text box. The on paste event basically is the thing that causes the handler to happen.

So it actually pastes the Markdown. So it's kind of this weird UI experience of like literally copy from Word and paste and the Markdown. So yeah, so I kind of create all these little things and they just feel good. And I think like, yeah, this is this is the right way to do this stuff.

Well, it's really good that it's scratching your like the fact that you're using it. And it's not just you kind of inventing this tool for the world. You know, I think my team loves it too. Like my friend Jono, he wrote this thing called Moodle. It's so fun. And like, so he's somebody who spends all his weekends like tinkering with I don't know robots or art or whatever.

He's a inveterate tinkerer. And nowadays, it's a good sign that he always wants to tinker with fast HTML. So he wrote this thing called Moodle, where you go to the site, and it gives you basically a Pictionary type word you have to draw. You start drawing it and then there are three different language, three different language models running in the background that are trying to guess what you're drawing.

And as soon as one guesses correctly, you're done. And so there's like a leaderboard. It's all HTML based, you know, of like, who managed to reach word get it done the fastest, right? And again, it's combining like canvas and you know, all these things with like, oh, HTML can't do that.

You know, it does the job. But exactly. And it's it's not that he like he makes isn't trying to do all that, right? It's there to work with canvas and with you know, JavaScript and whatever else it needs to work with. Yeah, we get our leaderboard and we get our like, you know, and we're using the WebSockets thing, which is nice.

And I'm about to dig into the server side events extension. That looks nice as well. Yeah. Yeah, server side events. Those are, you know, two extensions Web Sockets and server side events. I like the server side events one. It's read only. So as long as you're just consuming stuff, it's good for language models that stream the results back to you.

So you basically read it until it's finished. Totally. A lot of that, you know, being able to use that depends a lot on what your server side environment gives you too. So you know, if, if there's good support for it, using whatever your server side environment is, then you can, you can take advantage of them.

Yeah, no, I mean, with ASGI, it's all like async Python. So everything works. Yeah, pretty cleanly. I mean, not as cleanly as the HyperScript example that you showed. Sure. The other thing I like about with these things like WebSockets or server side events or whatever is this idea of like, oh, you want to like stop the connection as like, well, you literally just return a new DOM element that doesn't have a WebSocket, you know, attribute in it anymore.

Like it's like, yep. When you got a hammer, everything's a nail. Well, kind of in HTMX, everything is a nail. You know, it's like, everything's a div. No, no, no, I'm kidding. DOM elements. Everything's a DOM element. Not a div, but yeah. Yeah, I, you know, again, I feel like just what you said originally, like it's more, I discovered this than anything else.

And it does, it works for a lot of stuff, you know? And if you're, you know, like, it sounds like what you got, you guys are approaching it the right way, which is, I'm not going to try and make HTMX do stuff it's not good at. I'm going to instead, I'm going to integrate with HTMX via events.

And that's what I try to tell people. That's what in my mind makes someone a good HTMX developer is if they get that, okay, like start thinking in advance, and I've got these other tools that I want to integrate. Now, how do I integrate them cleanly? Hopefully they have a good event model, or maybe I have to impose one on top of it or something like that.

So maybe I should think that's the right way. I should talk to you sometime about my coming up plans. I'm hoping to actually create a kind of like web programming from scratch course. And I've actually now created this whole thing where I like literally it's a notebook that starts with a socket handler and builds up HTTP and then builds up ASGI.

And, you know, I'm really hoping that a lot of people will understand the pleasure of this style of web development. I also want to introduce people to things like pay five bucks a month to run your own VPS that you SSH into and you deploy things by r syncing to it.

And, you know, yeah, it's a, it's a bit of a superpower, I think, to have those. It is. Absolutely. I'm teaching, I'm teaching a class at MSU this fall on hypermedia. And so I'll be teaching sort of similar things. Will you have a chance to record any of that?

Or, you know, I've got to I've got to talk to the department. But maybe alternatively, you know, we can do something together where you could show some of your slides if you're allowed to and yeah, team up. Yeah, that sounds amazing. Yeah. Yeah, no, I'll I'll I need I just want to I need to right now it's summertime.

So everyone's gone and no one responds. But, but I'll talk to him as soon as everyone they should be back in a couple weeks or so. Well, Carson, I really appreciate it must be getting a little late in the evening for you. So I feel like it's not too bad.

I've learned a lot. And I feel like I've hopefully helped other people learn a lot. Yeah, is there anything else you wanted to say or ask or anything before we wrap up? No, I just, you know, congratulations on the launch. And I really appreciate, you know, your support. And like I said, you're unembarrassed by it, because I feel like all I'm doing is showing people what you already made.

So I hope I don't get, you know, obviously, that's not true. But, you know, the I think the Python community has been a big source of, you know, HTML, people excited about HTML, because they can stay in Python. And so, you know, I'm just I'm excited to see what you guys are, what you guys are going to be able to do with this tool looks really, really neat.

Thank you, sir. Have a great night. Yep. You as well. Bye bye.