Building APIs with Deno and Oak - Some Antics

Episode Description

Anthony Campolo returns to Some Antics for a fourth time to walk through building and deploying a simple web server using Deno and Oak.

Episode Summary

In this hands-on stream, Ben Myers and returning guest Anthony Campolo explore Deno, a modern server-side JavaScript runtime designed to replace Node.js by embracing web standards like ES modules and the Fetch API. Anthony explains why Deno matters — not as hype, but as a signal of how the web ecosystem is evolving — before guiding Ben through building a basic HTTP server, then upgrading to Oak (a Koa-inspired framework for Deno) with routing and HTML responses. They walk through Deno's security model, which defaults to zero permissions and requires explicit flags like --allow-net, contrasting it with Node's more permissive approach. The pair then deploys the server to Deno Deploy by linking a GitHub repo, demonstrating the smooth git-based workflow. They briefly experiment with JSX via Preact's renderToString, running into a minor hiccup that reveals the difference between the Deno CLI and the deployctl tool. Throughout, Anthony emphasizes that while Deno isn't ready to replace Node for everyone, understanding it helps developers make informed tooling decisions. The stream closes with discussion of Deno's origin story — Ryan Dahl's famous "10 Things I Regret About Node" talk — and a look at Anthony's upcoming work with StepZen and Redwood.

Chapters

00:00:00 - Introduction and What Is Deno

Ben welcomes Anthony Campolo back for his record fourth appearance on Some Antics. They quickly recap Anthony's previous visits covering accessibility, Redwood, and Vite before turning to the day's topic: Deno, a server-side JavaScript runtime built to modernize what Node.js started.

Anthony lays out the core pitch for Deno — it's a ground-up rebuild of the Node concept using web standards like ES modules and the Fetch API, giving developers a server-side environment that feels much closer to browser JavaScript. He draws a parallel to how modern build tools like esbuild and Vite improved on webpack, and cautions that while Deno hasn't replaced Node, keeping an eye on emerging tools helps developers make informed choices rather than just following defaults.

00:04:17 - Setting Up and Installing Deno

Ben shares his screen and points viewers to Anthony's Dev.to article on Oak, which serves as the session's loose guide. Anthony explains that Oak is to Deno what Express or Koa is to Node — a framework for handling HTTP requests and routing — and notes the playful anagram naming conventions in the Deno ecosystem.

They walk through the installation process, discussing the curl-based install script, alternative methods like Homebrew, and how Deno Land serves as the centralized package registry. Anthony highlights the structural difference from Node's ecosystem: unlike the separate NPM company, Deno's registry is tightly integrated with the core project. Ben mentions he pre-installed everything to avoid live-stream install disasters, and they briefly cover deployctl for local testing of Deno Deploy.

00:11:28 - Building a Basic Deno Server

The pair begins coding, starting with a minimal Deno HTTP server using the standard library's listenAndServe method. Anthony introduces URL-based imports, explaining how they make dependency versions explicit without needing a package.json file, and walks Ben through writing a simple function that returns a "Hello from Some Antics" response.

They discuss Deno's security-first design philosophy, rooted in zero-trust computing — unlike Node, which grants all permissions by default, Deno requires explicit flags like --allow-net. Anthony references the recent UA Parser supply chain attack as a real-world example of why Node's permissive model is dangerous. After a quick fix involving implicit arrow function returns, the server runs successfully, and both note how minimal the code is compared to an equivalent Node setup.

00:19:04 - Introducing Oak and Adding Routes

With the basic server working, they transition to Oak by importing Application and Router from the Oak module on Deno Land. Anthony guides Ben through creating an Oak application instance, setting up middleware with app.use, configuring the content-type header to serve HTML, and defining multiple routes for a home page and an about page.

Ben appreciates how familiar the patterns feel to anyone who has used Express or Koa, and Anthony emphasizes that this is intentional — Deno and Oak aren't trying to reinvent established conventions but rather modernize the underlying technology. They register the router's routes and allowed methods with the application, and after a quick server restart, both routes work as expected, delivering styled HTML responses.

00:30:43 - Deploying to Deno Deploy

Anthony shifts the conversation to Deno Deploy, the company's serverless hosting platform. Ben creates a GitHub repository using the GitHub CLI, and they install the Deno Deploy GitHub app to link the repo. Anthony explains the git-based deployment workflow where pushing changes automatically syncs to the live project.

They walk through creating a new Deno Deploy project, linking the raw GitHub file URL, and successfully deploying the Oak server with both routes live on the internet. The process is fast and straightforward, which impresses both of them. Anthony notes that Deno's Rust-based core contributes to extremely fast cold starts and that companies like Netlify are already using Deno under the hood for their edge handler infrastructure.

00:43:22 - TypeScript, JSX, and Developer Experience

Ben raises the question of editor tooling, noting that importing TypeScript files via URL doesn't automatically give type completions. They discover the official Deno VS Code extension with its dedicated language server, which provides autocomplete and error checking. Anthony shares his candid take on TypeScript quirks he's encountered, particularly with different CDN sources causing obscure type errors.

They then experiment with JSX by renaming the file to .jsx, importing Preact's renderToString and h functions, and writing a simple component. The initial attempt fails because the JSX example was designed for Deno Deploy specifically, not the standard Deno CLI. After switching to the deployctl run command, the JSX renders successfully, demonstrating how Deno can handle server-side rendered components out of the box.

00:51:43 - Deno's Future and Closing Thoughts

Anthony shares his excitement about Deno's growing ecosystem and the healthy competitive pressure it puts on Node — noting that Deno's ESM-only stance likely accelerated Node's own ESM adoption. He recounts the origin story of Deno: Ryan Dahl's 2018 JSConf talk originally titled "Design Mistakes in Node," which the conference organizers rebranded to the more provocative "10 Things I Regret About Node" despite the talk not actually containing ten regrets.

The stream wraps with Anthony previewing his work at StepZen on an upcoming GraphQL Studio and the anticipated Redwood V1 release. Ben announces upcoming Some Antics streams covering accessible SVGs, the Web Audio API, and building a Basecamp clone with Remix, while noting a brief hiatus as he transitions to a new role at Microsoft. Both thank the audience and sign off after a productive hour of live coding.

Transcript

00:00:00 - Ben Myers

Howdy, howdy, y'all. Some Antics is back. Took a few weeks off, but we are back and we are joined by Anthony Campolo. Anthony, it feels kind of poetic that you would be the first stream back.

00:00:16 - Anthony Campolo

Yeah, I think I'm definitely — I mean, I had the record on my last stream, but I'm solidifying my record here. This will be my fourth time on Some Antics.

00:00:27 - Ben Myers

CyberShock, thank you for the follow. Yeah, this will be your fourth time. We've had you come in for various accessibility things, particularly around the Redwood space. Then last time you were on, you showed me Vite. You've got this fascination with build tools. It seems like today we're here to talk about Deno. What is Deno and why should developers care?

00:00:57 - Anthony Campolo

Sure, this is going to be a little outside of your typical wheelhouse, but much like the Vite episode, part of the reason why I suggest it is because I know that you have a deep love and appreciation for web standards and projects that build upon web standards instead of just inventing their own nonsense to do whatever they want to do. And Deno is a replacement for Node. So Node.js is a server-side implementation of JavaScript. Most people think of JavaScript as a language that runs in the browser, but it can be run really anywhere you want. So if you want to create a backend server, traditionally you would use Node.js. Some people may know that Node.js is not exactly the same as the JavaScript that runs in the browser because they've built up some of their own standards over the years in terms of their own module system and things like that. But Deno is this idea of what if we could rebuild Node from the ground up, but using core web standards. So we'll be using ES modules — we won't be using this today, but you can use the Fetch API, just the regular old Fetch API, you don't need to use something like node-fetch.

00:02:16 - Anthony Campolo

So I would say that the main thing it gives you is a more modern, more updated way to write server-side JavaScript that is more in line with the JavaScript you were probably already writing in the browser.

00:02:32 - Ben Myers

It almost sounds to me like Deno is to Node what esbuild and Vite are to webpack. Right? It's like building on the lessons learned from those tools, but using more modern standards and tech. Is that a fair assessment?

00:02:53 - Anthony Campolo

Absolutely. Yeah. And that means this comes with all the same caveats we gave that episode, which is this is newer, there's going to be bugs, there's going to be hiccups. But I really think it's important for developers to be aware of, like, what is the new thing coming up? Not to, you know, follow the hype train, but to acknowledge the fact that these aren't like laws of nature. There was a time when webpack didn't exist. There was a time when even Node didn't exist. So all things shall come to pass in terms of these tools are eventually going to be replaced by something newer. So I think it's always good to keep an eye to the future in terms of what are the things that are being introduced that may become the new standards that we use now. Deno is, of course, not the standard right now, has not replaced Node. And whether it even will or not is really still up for debate and we'll see many, many years from now, probably. But I think that it is good in terms of giving you an idea of how is the web evolving, what are the trends to kind of pay attention to?

00:03:58 - Anthony Campolo

And then when you're in a position where you may have to decide between one or the other, you can at least make an informed decision and not just say, okay, well, I want to start a Deno project. I guess I should use Deno. It's like, well, no, you should learn what Deno actually is and what are the actual differences. And then you can make an informed decision about whether to use it or not for your specific project or use case.

00:04:17 - Ben Myers

I love that. I love that. So let's go ahead and start diving in right now. I've just been showing our faces, but now I'm sharing my screen and we're looking at your Twitter. Go follow Anthony on Twitter. Because, I mean, first of all, your shitposts are great, but also you've been like, just the whole time I've known you, you've been such a prolific author of many, many Dev.to posts, and I'm guessing every single one of those gets promoted here. Speaking of Dev.to, you've got an article that covers a lot of the same stuff that we're doing today. It's a first look at Oak. So Oak is not Deno. Do you want to walk us through what we're doing and how Deno and Oak fit together?

00:05:03 - Anthony Campolo

Most people who do know Node and have worked with Node know that you usually will use some sort of framework for HTTP requests, Express being the most well known. And it's a wrapper on top of the core HTTP module in either Node — or in this case, it's going to be Deno. And so there's a slightly different version of Express known as Koa. And so this is really influenced more by Koa than Express. And so some people may realize that Deno is the letters of Node kind of rearranged, and Oak is the letters of Koa slightly rearranged.

00:05:45 - Ben Myers

Ridiculous.

00:05:45 - Anthony Campolo

Pretty clever there. But that's all it really is. Oak is going to be a slightly nicer abstraction that is going to allow us to create a web server that can take requests and give responses to those requests, whether it's pure text or JSON or HTML, whatever it is that you want to respond to requests that you get.

00:06:08 - Ben Myers

All right, yeah. So let's go ahead and dive in now. I put the link to this in the chat. If you were planning on following along, you should definitely go to this article, because, full disclosure, I will not be installing Deno on this stream. Anyone who's done any streaming knows that the single most likely thing to take down a stream is having to install something new. And so I installed Deno and this deployctl ahead of time just to make sure that everything worked on my machine before hopping on the stream. So we have already gone through these steps, or I have, rather, on my machine ahead of time. Do you want to talk through these steps first?

00:06:53 - Anthony Campolo

Yeah. This is just one way to do this. I also gave some links here to other ways to do this, because with any downloading thing it's going to depend on what your operating system is. Are you on a Mac? Are you on Windows? And so this is just a basic curl command that installs an install script from Deno Land. And as we go on, we'll actually talk about this a little bit. How Deno Land is kind of like the home base for where you get Deno packages. There is no NPM for Deno. There's a tight integration between the company that is building Deno and the company that is maintaining Deno Land. So there is like an actual Deno company. So this is actually kind of interesting because back when Node was created, there were different companies that were kind of building it together. There was Joyent, which had kind of the main team behind it, and then there was npm, which was a completely separate company where all the Node packages were. So that's actually one of the kind of more meta concerns here, which is how do we also get this code in a place where people can get it? That install script —

00:08:04 - Anthony Campolo

you can just go to Deno Land and look at that script and see exactly what it's doing, if you want. But there's a whole bunch of install instructions — you can use Brew, you can use really whatever you want. This is the install script that will run on your computer. Then the main thing you want to think about is just like what is your operating system? And so there should be instructions there for whichever you use, whether you're on Windows, Mac, kind of whatever. So the main kind of install scripts that I put in there is the first one, the one that they recommend you use.

00:08:40 - Ben Myers

Joe in the chat is asking if I could at least start the download and then pull the prepared download out of the oven in the classic "here's one I cooked earlier." I do enjoy this pivot. Some Antics is now no longer about the web. It is the cooking show you've been looking for. I am going to have to update my Twitch stream category real quick to cooking. But yeah, so those are the installation steps. I found this fairly straightforward. There were no concerns I had with running this, but if you're looking to follow along, that is a thing that you will need to do.

00:09:15 - Anthony Campolo

Yeah. And then for deployctl, what that is is this is going to be for Deno Deploy, which depending on how much time this takes as we go, we may or may not get to this step. But there's also a hosting service that goes along with Deno Land where you can deploy your Deno or Oak server much like you would Netlify or Vercel, kind of a front-end static website. You have a way to sync it to your GitHub repo. And so deployctl is a way to locally test the service that will be deploying your thing. So this is also a big thing with cloud services — how do you get a local dev experience? There's usually tools that are designed to emulate the hosting provider that's going to host this. So when we get to this point in the project, when we run deployctl, it's going to show us the exact same thing as if we're just running the regular Deno command. But the idea being it'll let you know if something's going to break before you actually deploy it.

00:10:16 - Ben Myers

Gotcha. And you mentioned that it's analogous to Netlify or Vercel. I would also say it sounds like if you've ever done Heroku, right, because Netlify and Vercel, you're not really running the back-end stuff there. You're not really deploying full APIs. You're maybe deploying like serverless functions, but Heroku would be, I guess, the analog that I would have for the back-end services.

00:10:44 - Anthony Campolo

Yeah. And the reason why I mentioned Netlify and Vercel is because they lean into the git-based deploy workflow. But you were correct in the sense that you're not running static assets on a CDN. You're running basically a serverless function. This is actually funny. When their service first came out, I tried to just deploy a Deno server to it and it didn't work. I went into Discord and I'm like, what's happening? And they're like, dude, read the docs. It's not what it's for. You don't just run a server on it. It's actually for creating a serverless function that will export your project. So it's kind of this weird mid-ground between a server and a static front end because it's this whole serverless function thing, which can be a whole huge other conversation we really need to

00:11:28 - Ben Myers

get into for sure. Then the next step here is create the project files. I think at this point maybe we diverge a bit from the doc and have you be my guide.

00:11:40 - Anthony Campolo

Yeah, totally. You already have a project up and running, so why don't you just create an index.js — and this is a thing that you may have heard, that Deno is for TypeScript. And it's true in the sense that if we wanted to make this a TypeScript file and start writing TypeScript, we wouldn't have to configure anything. We wouldn't need a tsconfig file. But what's really cool is that you don't have to actually use TypeScript. If you just write JavaScript, the JavaScript will work as well. So we're going to stick to JavaScript land here. And before we start using Oak at all — and Jason, who just hopped in, is asking in the chat about Oak framework. Oak is going to be a framework that builds on top of Deno, but I actually wanted to start by just doing a simple Deno server.

00:12:31 - Ben Myers

Yeah.

00:12:32 - Anthony Campolo

So we're going to import — this is going to be ESM, so import. And then in curlies is going to be listenAndServe.

00:12:41 - Ben Myers

Are those lowercase camel case? Listen, Serve. Oh, listen.

00:12:46 - Anthony Campolo

So the one word, "and." Yeah, and then capital S. Yep. And then that's going to be from https://deno.land/...

00:12:56 - Ben Myers

Deno land. Okay, I'm typing URLs in here. I'm not used to that.

00:13:02 - Anthony Campolo

std@0.111.0/http/server.ts — and so this is, if you were following Next.js Conf, you may have heard about this. URL imports. And everyone's like, "ooh, URL imports, that's really interesting." This is something that only Deno does. This is how you actually import things in Deno — you pop in this URL here. And what's cool and what I like about this is you are being explicit about the version of your dependency. You're actually telling it which specific dependency and which version we are importing here.

00:13:52 - Ben Myers

In theory, I could import another method from another version of standard, it would seem.

00:14:02 - Anthony Campolo

Yeah, you can do another version or you can leave the versioning out and it will default to the newest one. If you're someone who likes your CI constantly breaking.

00:14:13 - Ben Myers

Very cool, very cool. Okay, so this is getting me a listenAndServe method here that we can use. Can I already start to, like, use this?

00:14:25 - Anthony Campolo

Yeah, absolutely. Go to the next line and then just call listenAndServe. So you don't need to say function, you can just do — we're calling it listenAndServe. Then inside of there you're going to have quotation marks and then colon 8080. That's going to set the port, and then do a comma after that. Then now we're going to do an anonymous function and then arrow, and then we'll do new Response. And then inside that response you need to say "hello from Some Antics" or something like that.

00:15:10 - Ben Myers

Hello from Some Antics, like that.

00:15:16 - Anthony Campolo

And then outside of that function entirely, we'll do a console.log and then you can just say "server running on 8080" or something like that.

00:15:26 - Ben Myers

You got it.

00:15:30 - Anthony Campolo

That should be all we need to do to get this response back. Now if we do — you should go back to the blog post real quick and look at the run command right after that server we created. We see this, and this is worth pointing out. This may look obnoxious, but there's a very, very good reason for this, which is that Node itself is like a huge security disaster. For anyone who is kind of not aware of this — because Node is able to basically have all permissions at all times, if you download a malicious Node package, your whole computer is owned. Effectively, it's done, it's over.

00:16:13 - Ben Myers

And this happens occasionally. Just recently the UA parser library had a malicious version and it was a dependency of dependency of dependencies for a whole bunch of projects like Eleventy. And so it was like installing a crypto miner, I think was what it was doing.

00:16:30 - Anthony Campolo

Crypto mining software — it would also export like all of your computer's passwords. It was a huge, terrible breach. And so Deno is created to be secure by default. So there's this concept called zero-trust computing, which is that instead of starting with all permissions and then adding security on top, you start with zero permissions and make the user explicitly say when they're giving permissions. So that's why we have this --allow-net, because that's basically saying we want to give the ability to run this script. And then the --watch command will be for just watching the server. So I think this means we're not going to need nodemon or anything like that. We'll see if that actually ends up working or not. And then the --no-check is something I just include because if you don't, you get weird TypeScript errors all the time.

00:17:28 - Ben Myers

Okay, so just go ahead and run this.

00:17:31 - Anthony Campolo

Yeah. And then that should work for us. And then we'll see a little output saying, server running. That's good. So then let's go open up a browser and take a look at our localhost 8080 and see if the magic happens.

00:17:49 - Ben Myers

Okay. It doesn't look like it. Do I need to return the response?

00:17:53 - Anthony Campolo

So what I was gonna say is get rid of the brackets and just put it all on one line. Yeah, like that.

00:18:02 - Ben Myers

To handle implicit returns. Got it. Yeah. Okay, let's try this. And it should. Because we did the watch command, it should just rebuild. So this we would think would work.

00:18:15 - Anthony Campolo

Try rerunning the server real quick.

00:18:17 - Ben Myers

Yeah, There we go.

00:18:23 - Anthony Campolo

There we go. Yeah.

00:18:24 - Ben Myers

Cool. Awesome.

00:18:27 - Anthony Campolo

So that is your Deno HTTP hello world. And once we kind of add in Oak, we'll show how to actually do HTML, we'll show how to do some routing. But this is just the most basic way to give a response from a Deno server. So it's less code than you would do for, like, a Node server. And it's got everything kind of built in for you — you don't need to bring in other packages or anything else. And we didn't even need a package.json because we're importing from the URL. So that's awesome. Hello, world.

00:19:04 - Ben Myers

That is incredibly cool. Very ergonomic. That's all I need. I don't even have to tell people, "oh, run the npm install command to get this set up." It feels like that's just a nice, sharp onboarding experience.

00:19:20 - Anthony Campolo

Yeah. Yeah. So that's why, you know, just installing Deno is kind of the big thing to figure out — once you've got it executable on your computer, then you're basically good to go. And this is one of the reasons why the team has worked very hard on keeping this as a single lean executable binary, because then this is very useful for putting it on other servers and running serverless functions and doing all that kind of stuff. So we can actually get into the Oak stuff now. So instead — you can leave most of that stuff up there for now. For the import, you can delete the other lines. So we'll just kind of modify this import. Instead of listenAndServe, we're going to import Application, just one word, capital A.

00:20:08 - Ben Myers

Okay, capital A, Application.

00:20:14 - Anthony Campolo

And then where it says — so keep https://deno.land/ and then delete everything else. Okay, yep. And then do the letter x and then forward slash. And so these are now going to be third-party modules because there's a standard library that we're importing from, and those are also kind of like blessed third-party modules. And Oak is from essentially the same team that does Deno, so you can feel pretty confident that it's going to work well. And just type the word oak and then v9.0.1 and then /mod.ts.

00:21:00 - Ben Myers

Like that.

00:21:02 - Anthony Campolo

Yep. Yeah. So that should be our Oak dependency. And then what we're going to do will be similar to Express or any of these things. You're going to do a const and then create a variable called just app, all lowercase, and then = new Application. Yep, just like that. And then go to the next line, leave that just like it is. And then we're going to do app.use. Yep. And then parentheses, and then another parentheses and write ctx for context. And then outside of those parentheses do an arrow function. Yep. And then — yeah, just like that. And then we're gonna do ctx.response.body. Okay, so this is just pulling out the body in the response. And then we're gonna do =. And then in quotes you can say "hello from Oak" or something like that.

00:22:11 - Ben Myers

All right, great.

00:22:13 - Anthony Campolo

And then that's all good. So create a whole other line now outside of that. And then we'll do app.addEventListener. Okay, so going back to browser APIs, we're just adding an event listener. And then in quotes do listen and then comma after that and then do an arrow function. Then inside the curlies do console.log. And then you just say "server running on port 8080" or something like that.

00:22:55 - Ben Myers

You got it.

00:22:56 - Anthony Campolo

And then outside of all of that we will then do app.listen. And then parentheses, and then curly braces inside the parentheses.

00:23:07 - Ben Myers

We're destructuring a parameter.

00:23:08 - Anthony Campolo

Okay. Yeah, so you just need one of the parentheses.

00:23:14 - Ben Myers

Oh, I see.

00:23:16 - Anthony Campolo

Yeah. Parentheses, and then par. Yeah, you got it.

00:23:18 - Ben Myers

Oh, oh, we're — we're got it. Not destructuring. We're just passing in a configuration object. Okay.

00:23:23 - Anthony Campolo

Yeah, so it's going to be port: 8080. So this is where we actually tell it the port. Yeah.

00:23:28 - Ben Myers

And that as a number and not a string.

00:23:32 - Anthony Campolo

Yeah, just like that. That should do it.

00:23:34 - Ben Myers

Okay, so we're going to tell it to listen on port 8080 and then once it knows to start listening, or once we tell it to start listening, it's going to log this and then once we hit it at port 8080, then it's going to return Hello from Oak. Okay, I'm just going to rerun that then.

00:23:56 - Anthony Campolo

You see what's happening right now is it's actually getting your dependencies while you do that, and then checks the file and then now is actually running it. So those are your Deno Oak dependencies, specifically.

00:24:09 - Ben Myers

Okay, so it's doing that whenever I run this. Does that mean it's going to do that every time I run it? Or is there any way that Deno caches those dependencies in any way?

00:24:20 - Anthony Campolo

So I know that just when I'm working with it, it doesn't have to do that every single time. So I'm not exactly sure how that works, but it does cache it somehow. So, yeah, this is an interesting thing with the import URL stuff is just like, how does any of this stuff actually work under the covers? I'm not entirely sure, but it's a thing.

00:24:45 - Ben Myers

All right. Well, it seems to be working. We're now getting hello from Oak, so everything seems to still be working.

00:24:53 - Anthony Campolo

Yeah, this is good. Right now we haven't really done anything different. We've just created our Oak server now and had it do the exact same thing that our Deno server was doing. But now what's really nice is we can start adding in some more complicated stuff if we want to. Now, let's say we want to send some HTML instead of just sending plain text. So inside of your app.use, under the context response body, you can leave that there, add another line, and this will be ctx.response. Then you see, header will show you a lot of stuff that we can do here. We're going to do the headers and then do set. So it'll be headers with an S, headers.set.

00:25:41 - Ben Myers

Okay.

00:25:42 - Anthony Campolo

Yep. Then we'll do in quotes, "content-type." Pretty familiar to anyone who's done this type of stuff before. And then in quotes, "text/html." All right, now for the response body, we can throw some H2s or anything like that just around it and it'll interpret the HTML correctly. "Hello, HTML."

00:26:15 - Ben Myers

Okay.

00:26:16 - Anthony Campolo

Yeah. And that should be all we have to do. You should be able to save that and then go back to the browser. And now this will be nice and large.

00:26:25 - Ben Myers

Something about the watch mode doesn't seem to be working.

00:26:29 - Anthony Campolo

Yeah, I wasn't really sure about that. So that's one of the — there we go. Still probably ironing out the kinks on that. But yeah, so there is now our HTML, which is pretty cool.

00:26:42 - Ben Myers

Pretty snazzy.

00:26:44 - Anthony Campolo

Yeah. All right, so the next question most people would ask is like, okay, well, is there a router, though? Because with things like Express and Koa, what you're really getting is not just the nice conventions and the syntax — you're also getting a router built in for you as well. So if we go back to our index.js, along with importing the Application, we're also going to import Router. So just one word, capitalized, Router. And then above the app declaration, we will have const router = new Router.

00:27:25 - Ben Myers

Do we pass it any configurations or anything?

00:27:28 - Anthony Campolo

Nope. Okay, no need. Not yet. Well, we will in a second. But first, what we want to do is, where it says app.use, change that to say router.get.

00:27:44 - Ben Myers

Okay, so this is router.get.

00:27:48 - Anthony Campolo

Yep. And then before the context object, we're going to add quotes with a forward slash. So it'll know that here, that'll be — yep. And then a comma. Yeah, there you go. And then that should set that all up correctly to now respond on our home route.

00:28:08 - Ben Myers

And then, so we could do something like this. Again, I'm just guessing here. Free form here. I could do something like this. I rerun. Hello. No middleware.

00:28:32 - Anthony Campolo

You're on the money with all of that. So then after that, above the event listener but below the router, do app.use and then pass in router.routes and then add some parentheses after routes. Yeah, and then one more line separate from all that. And then app.use and then pass in router.allowedMethods.

00:29:04 - Ben Myers

And is this also a method that we call.

00:29:07 - Anthony Campolo

Yes.

00:29:07 - Ben Myers

Okay.

00:29:08 - Anthony Campolo

Okay, now we should be all set.

00:29:15 - Ben Myers

All right, seems to be running. So if I hit this, it still shows my basic HTML here, but then I can go to /about and it says "All about Oak." Okay, so we can get multiple routes going. That's awesome.

00:29:29 - Anthony Campolo

Yeah, that's pretty cool. This is our hello world of how to do basic routes. If you're someone who's used Express or used Koa before, everything we're doing should be fairly comprehensible. This is one of the things that I really like about Deno and these libraries — they're not trying to totally reinvent the wheel. They're like, we still want to give people the APIs that they expect, but we want to build in newer, more modern tech around it and just make some slight tweaks here and there. To me, if I was someone who was learning web dev today, this would be really nice because you get to leverage things like already understanding event listeners and already understanding the ESM syntax, but then you just have to add on a couple more things to actually be like, okay, but how does this Deno back-end thing kind of work? But it's already in the same wheelhouse — things you're learning as a front-end web developer. So there's a lot more synergy between the two different things you'd be learning.

00:30:35 - Ben Myers

That's awesome. Okay, so what is next for our humble little server here?

00:30:43 - Anthony Campolo

Yeah. And if anyone in the chat has any questions about what we've done so far — hopefully this is all fairly straightforward so far. Now I want to get into the Deno Deploy stuff. Okay, so if we go to deno.com/deploy, then we can check this out.

00:31:03 - Ben Myers

Deno.com or land — deno.com.

00:31:07 - Anthony Campolo

Yeah, so Deno Land and deno.com, they're both — this is still all the Deno company, the same people behind it. But this is something that was made after Deno Land. Deno Land has been around for as long as the project has been around, whereas Deno Deploy — I think maybe like six months old or so. It's not as long-standing as the Deno project itself. But this is — once they got VC dollars and they're like, what are we actually going to do with this thing? We'll build a deployment platform. Obviously that's what everyone does. Now if you see on the right, we have this hello.js. Which is not exactly what we're going to be building, but it's fairly similar in terms of — we see we have the listenAndServe, but what they're doing — actually that's kind of cool — is they're showing that you can just throw JSX in if you want. And so if you click "SSR JSX" on the top. Is that an actual example or —

00:32:13 - Ben Myers

Oh, okay. That's where I was. Okay, got it.

00:32:16 - Anthony Campolo

Yeah, yeah. So they're giving you nice conventions to basically build your own kind of Next.js clone if you want, because they have SSR and then they have JSX parsing and they have all this stuff already built in. We're not going to get into any of this today, but for people who do find that interesting, I actually have a Deno Deploy blog post where I get into that a little bit. So this is going to be taking a little bit of that post, but just to actually deploy the Oak server. We're not going to get into any of the JSX stuff. Okay. So what we want to do now is we want to get our project that we created up on a Git repo.

00:33:05 - Ben Myers

Got it. Okay. Yeah, can do. Let's see. Do I have access to the. Okay, cool. I do have that in here. All right.

00:33:13 - Anthony Campolo

I love the GitHub CLI — I use it all the time now, mostly just to create repos, but even just for that, it's really nice.

00:33:21 - Ben Myers

Yeah. Create an oak server.

00:33:27 - Anthony Campolo

Okay. I've been talking about earlier in the stream that Deno Deploy is set up to just sync to a GitHub repo, which is really nice because then you get this nice workflow where you can just push changes to your repo and then it automatically gets synced on your live deployed project. And there's just a couple things that you kind of have to do to get it to work. We're going to end up installing kind of like a Deno GitHub application, I think. So let's first give this a look.

00:34:05 - Ben Myers

Yeah, it opened it up in Opera — forever. My problem. I know, I know. But we should have a new repo and in fact, I might actually be

00:34:19 - Anthony Campolo

contractually obligated to use Edge now.

00:34:22 - Ben Myers

You know, it's a great question. Probably not — for folks in the audience who are new, I'm going to be starting a new role at Microsoft soon, so super excited for that. But I don't think they require us to use Edge. I'd have to check in with some folks I know there. Okay. So now everything's been added and I actually probably will need to have this open in Opera because I am not signed in on this browser profile.

00:34:55 - Anthony Campolo

That's funny. Do you actually use Opera?

00:34:57 - Ben Myers

I do, I do. It's my day to day browser for some reason. I don't know. I'll probably move away shortly.

00:35:04 - Anthony Campolo

Yeah. What's the pitch for Opera?

00:35:08 - Ben Myers

So this is Opera GX, or I have Opera GX, which is pitched as a quote-unquote gaming browser because it's supposed to give you more fine-tuned control into the performance internals, which I figured would be nice for streaming. It's got some extra extensions and plugins — like, you can sign in with your Twitch account and it'll show you who's actively online and stuff like that. There were reasons I went with it, but I don't know that I'm going to stick with it.

00:35:34 - Anthony Campolo

Okay, so let's go to — now, let me see. If you go to GitHub.com/apps/deno-deploy.

00:35:48 - Ben Myers

I do need to be logged in on GitHub for this, right?

00:35:52 - Anthony Campolo

Yes.

00:35:53 - Ben Myers

Then let me actually open this up in Opera. GitHub.com/apps — what did you say?

00:36:02 - Anthony Campolo

deno-deploy.

00:36:05 - Ben Myers

You know, dash-deploy.

00:36:06 - Anthony Campolo

Okay, that's funny. Someone's mentioning Vivaldi in the chat — I was listening to, I think it was JS Party, they had like a competition between the Syntax host and the ShopTalk host. They had like a trivia game and one of the questions was about browsers, and there's like one final browser they were trying to get, and someone says Vivaldi — it ends up being Vivaldi and they're like, what?

00:36:30 - Ben Myers

Incredible. Anyways, I'm proud to represent the population of one person who uses Opera GX. I am that person. You found them. All right, shall we, I guess, install this application?

00:36:51 - Anthony Campolo

Yeah. And so if anyone doesn't know what GitHub apps are, these are just a way to very simply configure your repos to work with some sort of outside service. So in this case you're going to be giving read access to metadata and read and write access to some other stuff. So for people who are crazy about security, you may only want to give this to a select repo. We only need to access this one repo here. So that will be totally good. Make sure — yeah, we got that selected and then — yeah, so that should all be set. I'm always wondering how much these permission things matter. There's such a huge amount of things I've given access to my GitHub at this point. All right, so now we are in there. So now if you just log in — so I think you already are logged in, it looks like. So try just clicking "new," see what happens.

00:37:56 - Ben Myers

Yeah, there we go. All right. New — new project.

00:38:01 - Anthony Campolo

Yeah, yep, new project. Great. And then give it a — I would probably just give it the same name as my repo.

00:38:09 - Ben Myers

Yeah. Does it need to be like globally unique or just unique to my own projects?

00:38:18 - Anthony Campolo

No idea.

00:38:22 - Ben Myers

We'll see if that works. Seems like it works okay.

00:38:25 - Anthony Campolo

Yeah, that should be fine. Cool. Then we will scroll down to where it says "deploy from GitHub." It gives you some just basic things you can do. But we already got a Git repo so we know we're going to do that. Hit "continue" on deploy from GitHub. This part might be a little bit tricky because I think they actually may have fixed this, but in the past you had to use the raw link, but right now it's saying you can just do this. So I'm actually kind of curious if that will work or not. So it's not letting you click the link. So I think you need to actually put the raw one in. So if you go back to our GitHub repo and then just look at the actual index.js file. Right. And then click "raw" next to "blame." So if we grab this. And I think the reason why is because they just need the code. So, cool. So now we're going to go ahead and link that and this should be all we need to do. And the reason why this works is because I kind of created the example from the start already looking at the Deno Deploy example.

00:39:42 - Anthony Campolo

So if you just write a regular old Oak server, you may get some issues like I did when I very, very first tried Deno Deploy. So you should check the actual Deno Deploy docs if you want to do this and they'll let you know how to actually get a correct configuration for your server. So if you just try and run a regular server, it might not work, but I think that they're converging on a way towards basically just making it work no matter what. So let's now click "view" and I think we should be live.

00:40:13 - Ben Myers

Okay. Yeah. Well, excellent.

00:40:16 - Anthony Campolo

Check the about.

00:40:18 - Ben Myers

Very cool. Very cool.

00:40:19 - Anthony Campolo

Yeah. So this is a really pretty simple workflow, essentially getting a whole server.

00:40:26 - Ben Myers

That was a very pleasant onboarding experience for sure. Yeah.

00:40:30 - Anthony Campolo

Okay. It's great. They've done a good job of kind of honing the UX of using it. So I'm a big fan. And I think that if you're someone who really likes playing around with new deployment platforms like I do — I was super impressed by it and I was like, oh yeah, this is actually something I can see myself actually using and building with.

00:40:53 - Ben Myers

I'm also just appreciating that Deno owns deno.land, deno.dev, deno.com — probably dino.pizza if I had to guess.

00:41:03 - Anthony Campolo

Yeah. If not, I know what URL I'm buying.

00:41:10 - Ben Myers

Travis in the chat: I am curious how Anthony gets involved with tree-related projects. Yeah, between Oak and Redwood, trees are apparently your thing.

00:41:21 - Anthony Campolo

So one of the things that has become a signature in my blog posts is I'll put some sort of ridiculous comment in my initial commit. And so the initial commit on the Oak one is "finally another project named after a tree."

00:41:36 - Ben Myers

Incredible. Jace wants to see your forest of projects. I love it. Chat, continue to deliver on those tree puns, please.

00:41:46 - Anthony Campolo

We need 18 more massive tree puns because I'm out of code.

00:41:49 - Ben Myers

Yeah, we're not out of the woods yet.

00:41:53 - Anthony Campolo

Yeah, so — we're done. That's kind of the whole thing that I wanted to show, so.

00:41:58 - Ben Myers

Oh my goodness.

00:42:00 - Anthony Campolo

The fact that we were able to kind of do all of this within the span of not even a full stream is a good example of, one, the speed of these tools that we're using. Because one thing we didn't talk about is that Deno is built on Rust, and if you're not aware, Rust is fast. Rust is very fast — one of the reasons why people love Rust so much. So we have an awesome, super fast, super speedy dev experience and then once we actually get it deployed as well, there's like no build times as far as I can tell. I'm not sure if that's just because they already have infra just spun up for you. An interesting kind of side note here is that Deno itself is now being used to build serverless function platforms. If you have heard of Netlify's edge handlers — not very well advertised, but Netlify just launched it. Netlify edge handlers are built on Deno, so Deno itself — they have a serverless deployment platform. But if you wanted to actually build your own serverless deployment platform, Deno is now a tool to do that with. So we've got super quick cold starts and it's just well optimized for having a server up and running really, really fast.

00:43:22 - Ben Myers

Awesome. One question I've got is because everything's being pulled in from URLs and such, I noticed that we've been pulling in TypeScript files and yet because we're pulling in from this URL, my editor doesn't seem to know about any of the type completion. Is there anything I can do to improve that dev experience? Do you know?

00:43:45 - Anthony Campolo

Yeah, that's a good question. And this is where I think there's probably going to be a Deno extension. I would guess so — if we check "VS Code Deno extension," it looks like they have a dedicated language extension with the Deno language server. So I have to imagine this would give you that, or else I don't even know what the point of this would be. So we look at that — we're seeing in the preview there, it's giving some autocomplete, errors, and things like that. So I would guess that this is probably going to be what you would want to get all that. It's a good point. I am a little bit TypeScript-averse, so I tend to avoid even thinking about these types of issues. But it is built on TypeScript, so we should actually be figuring out how to get the benefit of TypeScript. We see here we're getting autocomplete and while it's trying to mess with the URLs, you can get an error there.

00:44:44 - Ben Myers

Yeah, so if I just [unclear], it probably wouldn't be happy with — oh, I may need to restart the editor for some of these things to take effect, would be my guess.

00:44:55 - Anthony Campolo

But yeah, probably.

00:44:57 - Ben Myers

Yeah. Okay. So there are tools for getting that kind of dev experience.

00:45:04 - Anthony Campolo

Yeah. And also because I had added the --no-check — that's why we weren't getting type-checked when we ran our server. But you can also get type-checking in that as well. The only problem is I found that I get weird type errors sometimes, depending on where I'm importing it from. Because you don't necessarily have to import from Deno Land. There are other CDNs. There's one called esm.sh — I think it's some ESM CDN. And I went down this huge rabbit hole with this other Deno project, getting all these weird type errors. And I went and opened an issue and they're like, "oh, that's an issue with esm.sh." I'm like, "well, but it's your project, so it's an issue for you too." And this is why TypeScript just always adds weird bugs that I don't understand and don't know how to deal with. That's why I sometimes just chuck the whole baby out with the bathwater, which I'm sure is probably not a super smart thing to do. But if you add --no-check, you will avoid these weird, obscure type errors.

00:46:09 - Ben Myers

So totally fair.

00:46:11 - Anthony Campolo

Little tip.

00:46:12 - Ben Myers

Okay, so I guess are there any other things you can think of that we might want to show off or do with the time that we've got left?

00:46:24 - Anthony Campolo

Yeah, I mean, we could try doing some of the JSX stuff if we want. Let's check out my Deno Deploy example — I dropped that in the chat not too long ago.

00:46:41 - Ben Myers

Pulling that up. Let's see. Here it is. Okay. All right, let's see. I see some — yeah, Response stuff that feels very familiar.

00:46:57 - Anthony Campolo

Yeah. So the one thing you're going to want to do is first you have to rename your index.js to index.jsx.

00:47:05 - Ben Myers

Okay. Yeah, it's probably possible for me to. Yeah, I'll do that. Yeah, I'll do that.

00:47:14 - Anthony Campolo

Here.

00:47:16 - Ben Myers

Create extra files.

00:47:17 - Anthony Campolo

There we go.

00:47:19 - Ben Myers

And so now I think I saw I needed an extra import somewhere to be able to handle that. Like with the h, I would just

00:47:27 - Anthony Campolo

go back to that blog example and then just grab the whole code block towards the end. So that big old code block right there. So what this is going to do is this is going to create an App function that's going to return the JSX, and then we have this renderToString method that is bringing in Preact. So this isn't technically React — technically it's Preact, but basically the same thing. And then I think the h is for hydrate, I would guess. But this should be basically all we need to get this going. So — that's not entirely right because you should have an extra curly in parentheses after the response.

00:48:21 - Ben Myers

Like that.

00:48:22 - Anthony Campolo

Yeah.

00:48:23 - Ben Myers

Okay, cool. Yeah, let's. Let's give this a shot.

00:48:27 - Anthony Campolo

It looks like we're not using the h method at all. So that's probably just because I copied this code example from somewhere.

00:48:32 - Ben Myers

So my understanding of h as it comes from Preact is — it's like when you have to do import React from 'react' to get the JSX parser to recognize that React is in scope. So it knows what to do with the JSX. Because all of this has to be transpiled into function calls. And so having h in scope is Preact's equivalent to having React in scope to know what the JSX actually gets transpiled to. It's an odd thing.

00:49:06 - Anthony Campolo

Yeah. Travis in the chat is saying h is Preact's equivalent to React.createElement. That makes a lot of sense.

00:49:14 - Ben Myers

Oh, it turns out I have to run the specific file. Turns out that's important.

00:49:22 - Anthony Campolo

Yeah. And then we see here we're getting a couple different dependencies downloaded now. Okay, so this might be because — so are you still passing --no-check in there?

00:49:37 - Ben Myers

Yes.

00:49:39 - Anthony Campolo

Okay, interesting. All right, this might be then, because dependencies have changed since the last time I did this. So let me see if I can get this running on my computer, see what happens.

00:49:55 - Ben Myers

If not, I'm not terribly worried, but it does seem like you can do some really cool things with this.

00:50:03 - Anthony Campolo

Yeah, I'll just check this real quick on my computer. If it doesn't work, then we'll just say screw it. But yeah, it's one of those things where, as I said at the beginning, this is a newer project — there's going to be some weird bugs and stuff like that that could happen. So always be careful when you're trying new tech and start first with just a basic sample project on your own computer. And don't just try to actually migrate anything important — it's just not the thing you should be doing. But as you start testing newer things out and start getting into the habit of always seeing what the new cutting-edge stuff is, you start to get kind of a barometer of how ready things actually are for production. So it's like, don't be afraid of things breaking — embrace the breakage, but at the same time be smart about how you're using this stuff.

00:50:58 - Ben Myers

Absolutely. We have a question in the chat. How does Deno handle peer dependencies?

00:51:06 - Anthony Campolo

Yes. So the idea is that every dependency should have everything it needs and should be just a single kind of executable. If you're pulling in the oak dependency like we were, that is just a single thing that you're pulling out. There shouldn't be any peer dependencies. Now, I'm sure in practice when people are actually building these projects, you end up with lots of peer dependencies, but I think when you're just using the kind of like blessed modules, they should have everything they need. So that is what I believe is the case with that.

00:51:43 - Ben Myers

Sounds good, y'all. If you have any other questions, feel free to drop those in the chat. We've got a couple minutes left and so we might be able to get to a few of those. In the meantime, I'm going to ask you: what are you most excited about in Deno's future?

00:51:59 - Anthony Campolo

Yeah, I am just excited about more people kind of knowing about it and trying it out and just the idea of there even being an alternative to Node, period, because it's one of those things where it's just the assumed thing to do — you are going to have a Node project and do whatever you want to do, and you don't even need to think about alternatives. But I think it's never good or healthy for our ecosystem to just have one thing that everyone has to use. So the very fact that there is an alternative to Node is what makes me really excited. And I think people have heard of Deno, they know it's a thing, but because it's still newer, people assume it's not ready — they're not really using it or playing with it. So I really urge people to just give it a try and see what it's like. I think with things like Deno Deploy now and with other serverless providers starting to pick it up, it's going to become a lot more stable, a lot more quickly, because you're going to have actual companies using it and testing it out.

00:53:06 - Anthony Campolo

So I think we're going to see a lot of these things start to stabilize. And actually, I realize the reason why this is not working is because this is designed to work on Deno Deploy. This is what the deployctl command was for. You actually want to run this with deployctl, not with the Deno CLI.

00:53:25 - Ben Myers

Let's do that. Do you have the deployctl command somewhere in here that I can — ah, look at that.

00:53:31 - Anthony Campolo

Okay, yes, take that, but don't use the raw GitHub one. Just basically replace that with just index.jsx.

00:53:43 - Ben Myers

Okay, I think I can just run that. Works on one line: deployctl run index.jsx --no-check. Like this. It seems like it's listening. Let's give this a shot. And that's gonna be at root. Hey. Okay, cool. Yeah, that — even if you're not doing very JSX-y things with it, just even simply having the syntax highlighting is so much nicer than, you know, building an HTML string yourself. That's awesome.

00:54:40 - Anthony Campolo

Wow.

00:54:40 - Ben Myers

Okay. Very cool.

00:54:43 - Anthony Campolo

Yeah, like Travis said, he's excited that they'll get better because of each other. And I think that is absolutely true. I think that the fact that Deno existed and was like, "we're ESM — full stop, only ESM" — I think that put pressure on the Node community to figure ESM out faster than they may have had to otherwise. So I definitely agree that having other things in the space working on similar stuff does push us all to continue to get better. You can't just rest on your laurels. So I think that's pretty cool. And it's great that there are people out there who want to continue to make the web better. It's also worth mentioning that Deno is from the creator of Node. So Ryan — what is Ryan's last name? I used to know this. Ryan Dahl. Duh. Yeah. So Ryan Dahl created Node. And what's funny is in 2012 he said, "Node is done. I am done. I can leave because Node is finished." And the idea of Node being finished in 2012 was like hilarious. But he stepped away from Node a long, long, long time ago. And then in 2018 he did a talk, kind of talking about what he would have liked to do differently if he could rebuild Node from the ground up.

00:56:02 - Anthony Campolo

And then at the end he's like, "by the way, I'm doing it. It's called Deno." And it's known as "10 Things I Regret About Node." And I actually found out that that is not the original talk title. I used to watch that talk and be like, what are the 10 things? I can only count eight regrets. And you can't actually find 10 whole regrets. And this is because the talk was originally called "Design Mistakes in Node" and it was at JSConf, and the JSConf people were like, "that's not an inflammatory enough title. We need to make this far more inflammatory" and changed the title to "10 Things I Regret About Node" — not even realizing that he didn't have 10 things in the talk.

00:56:44 - Ben Myers

Incredible. All right, well, I think we're about time, so I want to go ahead and shout out your Twitter again. Go follow Anthony on Twitter if you aren't already. What are you working on? Is there anything that people should get hyped for?

00:57:04 - Anthony Campolo

Always, man. Never stop working on things. Yeah. So we didn't talk at all about my job. I work for a company called StepZen. So StepZen — we are about to launch this massive new thing that we've been building for many, many months. And so it's not live yet, so I can't really show it to you yet, but within the next week or two, we're actually going to be launching this brand new GraphQL Studio, which is going to be a way to quickly connect to lots of different pre-built APIs with a GraphQL interface, basically. So there'll be pre-made schemas, it'll be configured so you just have to basically put in your API key and it'll already authenticate you, and then you can actually combine different APIs together. I've got an upcoming blog post where I'm going to show how to take your Dev.to comments from a blog you wrote and then pipe that into Google's sentiment analysis API to get a positive or negative score for the comments on your blog post. That's the thing that we've got going on and I'm really, really excited for. Our team has been just heads down for months working on this.

00:58:18 - Anthony Campolo

So it'll be very exciting. So keep an eye on my Twitter or the StepZen Twitter for that in the next couple of weeks. And then Redwood is hopefully very, very close to a V1 release candidate — within the next one or two minor releases, we're finally going to get there. We originally planned to get V1 out by the end of last year, so we're like a whole year behind, but this is so exciting. I've been working on Redwood for so long. It's really how I made my name as a developer advocate. So really, really happy to get that out. And then, yeah, obviously I've got my blog. I'm blogging all the time, but those are going to be kind of the main things going on — the GraphQL Studio for StepZen and then the Redwood V1. Follow my blog to kind of get more stuff on all of that.

00:59:09 - Ben Myers

Awesome. Well, thank you so much.

00:59:10 - Anthony Campolo

Thanks so much, Ben, for having me again. It's such an honor and a pleasure. So congrats on the new job as well. So happy for you. They're really lucky to have you.

00:59:19 - Ben Myers

Thank you. And speaking of the new job — because I start in a handful of weeks, I'm going to have to have another few weeks where I'm not going to be streaming because I'm going to be figuring out my new job schedule. So that will be like starting November 15th — that period of time, there may be a few weeks without streams. And so to compensate, I'm doing double streams this week and next, so follow Some Antics on Twitter. You'll find out what all the upcoming streams are. I'm really excited though. This Thursday we've got Carrie Fisher — that's Carrie with one R, so not Princess Leia. She's coming on to demonstrate accessible SVG practices. Super stoked for that. Next Tuesday, we've got Austin Krim coming on — we're going to be experimenting with the Web Audio API, which is incredibly rad. He's already sent me his demo, it's going to be so good, so you'll want to be there for that. And then next Wednesday, we've got Chance Strickland coming back on from the Remix team. We're going to be building — it sounds like, hey, welcome Owen, thanks for joining — it sounds like we're going to be building ourselves a Basecamp clone using Remix.

01:00:30 - Ben Myers

And so those are the upcoming streams. That's this Thursday, next Tuesday, next Wednesday, all at 12pm Central here at twitch.tv/someanticsdev. Anthony, thank you so much for joining us. It's always a delight to have you on. I always learn new things and push myself in ways that, you know, I don't necessarily do a lot of. So thank you so much for demonstrating Deno today, y'all. I'm gonna go find someone to raid, so stick around. But thanks for being here today. Bye.

01:01:05 - Anthony Campolo

Thanks, everyone.