Deno 2 Ryan Dahl
===

Tejas: [00:00:00] Hi, and welcome to PodRocket, a web development podcast brought to you by LogRocket. LogRocket provides AI first session replay and analytics, which surface the UX and technical issues impacting user experiences. Start understanding where your users are struggling by trying it for free at LogRocket. com.

I'm Tejas Kumar, and today we have Ryan Dahl, co founder of Deno and creator of Node. js, here to talk about Deno 2. Ryan, welcome.

Ryan: Hey,~ uh,~ glad to be here.

Tejas: I'm so excited to talk to you,~ um,~ me personally, because,~ um,~ it was, I think it was 2017 or 2018 when you had this talk about,~ uh,~ Deno at JSConf EU, a very long time ago. That was the first conference talk I ever gave in my entire life. I was there, ~and~ to watch you,~ um,~ deliver this talk, introducing Deno to the world,~ uh, was a real, um, and so, ~as we begin our discussion, I'd love it if you could maybe start by explaining what Deno is, why does it exist,~ um,~ and what problems it solves.

Ryan: ~Uh, ~yeah,~ um, well, ~it started a long time before that, actually, like in 2009,~ uh,~ when Chrome came out,~ uh,~ and with the V8 JavaScript engine. And I was working on non blocking web [00:01:00] servers and trying to think about how,~ uh,~ web servers could be done more easily. ~Um, ~and,~ uh, kind of ~came up with this epiphany ~that, ~that,~ uh,~ client side JavaScript actually works really well ~for, ~for servers,~ uh,~ and,~ uh,~ created the Node.

js project. ~Um, ~that project,~ uh,~ was pretty successful. ~Um, ~and ~is, ~is,~ uh, is ~running a lot of websites, most websites, all websites,~ uh,~ at this point,~ um,~ and is,~ uh, uh, You know, clearly, ~clearly something useful ~for, ~for people in the world. ~Um, ~I ~kind of ~went off and did other things ~for, ~for some years ~and, ~and ~kind of ~came back ~to, ~to JavaScript,~ uh,~ around ~that, that, uh, around that, ~that conference ~that, ~that you were talking about,~ um,~ and,~ uh,~ was ~kind of ~frustrated ~with, ~with what I was seeing where node had come,~ uh,~ over, over the time that, that I had left it.

~Uh, you know, ~It had evolved. It had gotten more stable. It was great. ~Uh, ~it was being used by many people, but a lot of things were ~kind of ~just stuck in the same world. ~And, ~and,~ uh,~ the Deno project ~was, was really kind of is, ~is really my continuation ~of, ~of the node project, ~kind of ~trying to ultimately make it ~very, ~[00:02:00] very simple for people to program things.

~Uh, and. ~Specifically web servers and,~ uh,~ things related to, to web development. ~Um, ~so yeah,~ uh, ~to answer your question,~ uh, D ~Deno is server side JavaScript. ~Uh, ~it is,~ uh, ~taking. ~Uh, you know, ~a fresh look ~at, ~at this and really trying to close the gap between what browsers do ~you know, uh, where, where, ~what client side JavaScripts does,~ and, ~and the server side JavaScript.

And so, you know, in, in the past that that has meant using, uh, web APIs like fetch a

node.

ECMAScript modules,~ uh, ~instead of common JS modules,~ uh, uh, ~things that are specified ~and, and in the, ~in the browser themselves,~ um, ~taking a pretty hard stance on security ~as, ~as browsers do,~ and, ~and really utilizing ~the, ~the sandbox that V8 gives you. ~Uh, and ~not ~just, ~just allowing people to do anything and everything with JavaScript, but ~kind of ~giving them the controls to potentially,~ uh, ~not allow any access ~or, or only, you know, ~for example, only allow ~it, uh, ~file system access, but not network access.

~Um, uh, ~[00:03:00] And I guess kind of the third pillar of this ~was ~is TypeScript. TypeScript,~ uh, ~is essentially like the next version of JavaScript in my mind. ~I mean, it's, ~it's JavaScript with types,~ um, ~and building that pretty deeply into the platform so that there's nothing to configure. ~You can, ~you can just ~kind of type, ~type out TypeScript natively ~linked to ~link to other TypeScript modules ~and, and, uh, uh, just, ~just ~kind of ~have this,~ um, ~Batteries included,~ uh, ~setup where you can ~just, ~just start programming ~with, with really, ~with really out any,~ uh, ~additional tooling.

Tejas: Fantastic, I'd love to double click on many of those things you mentioned, but maybe starting at one of the earlier things you said,~ um,~ you mentioned client side, so Node. js came from this epiphany for me. That, hey, client side JavaScript is really good for servers. I believe that's how you put it. What about client side JavaScript makes it really good for servers?

And I've seen a lot of servers implemented with Golang, Rust,~ um,~ etc. ~What, ~what was it from client side JavaScript that had you going, Hey, this would be really great ~for, ~for servers and for,~ um,~ a runtime like Node. js?

Ryan: So we have to rewind back 15 years ~to, ~to like 2008.~ Uh, ~the typical way for [00:04:00] servers to be implemented back then was a thread per request. ~So you, you would, ~you would kind of do blocking IO and Have a single thread per request. The problem with this ~is, ~is that each thread has its own stack ~has, ~has memory associated with it, it becomes ~kind of ~a heavy handed way ~of, ~of building servers,~ um, it's hard to do kind of. ~

~Events, uh, acing. Well, let's just put it there. There's a better way there.~ It's long been known that ~there's ~there's a better way to do this. And that's ~kind of ~using a poll and event loop driven systems. ~This was very, uh, There's only only you had to program this and see ~there was only a small group of people that ~kind of ~knew ~how how this was ~how to program ~these~ these sort of servers ~back ~back then.

~Um, but the and ~it really required ~kind of ~a mental switch in how you did things. You could no longer do things ~kind of ~sequentially and in a blocking way, ~but ~but rather ~kind of ~you had to structure everything as callbacks ~and and, uh, Uh, kind of ~think in terms of,~ uh, ~events happening ~on, ~on the server.

~Um, ~and this was, ~you know, ~really a different way ~of, ~of programming the system turns out that client side JavaScript. looks very similar to this. So for example, you might have a button and when you click that button, you get a callback. ~Um, ~when you have, yeah, there's just like a lot of kind of event handling callbacks that, that happen [00:05:00] in,~ in, ~in GUIs and in client side JavaScript in particular, that turns out ~is, ~is exactly how you program.

~Uh, uh, ~high performance web servers. ~Um, and, ~and those two things ~kind of ~clicked very nicely and people were able to take what they knew of client side JavaScript, IE, ~you know, here's a, ~here's a button, here's a on click handler,~ um, ~instead of having an on click handler, I have an on request handler, or, ~you know, I, ~I have an on packet handler,~ um, ~on data.

~Um, ~and,~ uh, you know, ~suddenly ~you, you, ~you have this situation,~ uh,~ where Client side JavaScript programmers were now ~the best, ~the best server developers around like ~they could, ~they could suddenly throw together event driven,~ uh,~ web servers ~or, ~or TCP servers,~ uh,~ pretty quickly ~with, ~with,~ uh,~ no JS.

Tejas: Incredible. I had no idea about all that context. ~Thank you so much.~ I do see how callback and event driven architectures can lend themselves well to non blocking network I. O. Because it's just ~like, ~do this thing and then call this function back whenever you need it, whenever you're ready. And this is, as you mentioned, a far cry from how things were at the time, which was mostly sequential and blocking.

Thank you so much for that. [00:06:00] You mentioned also, one of your goals with Deno,~ Um,~ after coming back to the Node. js project and not fully liking what you saw,~ was,~ was Deno's goal is to make things more simpler. He said, make it more simple to program things. ~Um, ~I have used Deno, and one of the things that stuck out to me ~in the, ~in the beginning was,~ um,~ these absolute import URLs.

~Um, which was, ~there was friction there. ~You know, ~for me it was like, okay, I'm just used to writing imports a certain way. ~Um, ~and now ~it's, ~it's no longer relative paths,~ but, ~but absolute. And I was like, ~this is, ~This is different. And so with novelty comes complexity. And ~I, ~I struggle thinking about that as simple, mainly because it's just new and there's going to be friction for those who are used to writing things in Node.

js way. So all this is, I guess, my long winded way of asking, how does Deno make it simpler to program things? ~Right. The~

Ryan: ~So the original version of Deno, uh, had the mindset that we only, ~so there has to be said, there's these two, two different module systems ~in, ~in JavaScript, there's common JS and ~there's, ~there's ES modules. ES. Modules are standardized. ~They are, they are, ~it is syntax that web browsers understand. Common JS is.

A thing that I largely invented,~ uh, in, uh, ~in no JS and has ~kind of ~just persisted [00:07:00] by way of,~ uh, historical, uh, ~historical reasons,~ um, uh, ~is not supported ~in, ~in the web browser. ~Um, ~so the stance ~of, ~of Deno ~is, ~is that, ~you know, let's, let's be, ~let's be spec compliant and,~ uh, ~thus use ECMAScript modules. In ECMAScript modules, there's no concept of NPM modules, ~there's no, what, ~what you can import is relative paths, or you can import absolute URLs,~ um, both, ~both of which work, ~work in, ~in web browsers,~ um, ~and Deno 2k this stance of what if we built ~a, Uh, ~a whole software ecosystem on top of HEP imports.

~Uh, what, ~What if everybody could just host their code on any sort of web server? ~Uh, ~and,~ uh, you know, that, ~that makes it very easy to link to. You don't need to publish it to the NPM registry. You can instead just put it on a gist. You can,~ uh, ~put it up on your own site. You could put it on,~ um, a, ~a special website for, ~you know, uh, ~a registry dedicated to, ~uh, Uh,~ HEPS, ~uh, uh, ~JavaScript modules,~ um,~ that ~is, ~is one of the major things ~that ~that is changing ~in ~in Deno two.

~Um, ~this is incredibly simple because there's no module system, essentially, like all you do is [00:08:00] import HEP, ~uh, uh,~ imports. On the other hand,~ um, ~like in terms of the implementation, I should say,~ it's,~ it's incredibly simple its NPM.

On the other hand,~ uh, it's, ~it's a big switch for a lot of people ~and, ~and people are used to,~ uh, uh, you know, ~adding react ~to their, ~to their package, JSon file and just importing,~ uh, you know, ~the bear specifier react and,~ uh, ~saying that, no, that is not allowed,~ uh, ~it needs to now be ~on, uh, ~somehow available over an HEP,~ uh, uh, on, ~on some web server somewhere.

~And, ~and it all needs to be,~ uh, ~ES modules is. Unfortunately, like a bit more ~than ~than people could chew on a lot of people liked this and it works really this kind of original module system of Deno works really well for small scripts because you can just open a single file. Put a little url in at the top, ~you know, start ~start coding for kind of small projects.

~This ~this worked really well ~Um, ~but as you ~kind of ~scale up to larger and larger javascript projects ~Um, ~yeah, ~I mean ~people ~just ~just have ~Let's, ~let's call it like an impedance mismatch problem with, ~with, uh, with, uh,~ [00:09:00] JavaScript ecosystem. And,~ uh, ~one of the major things that we are addressing ~in, ~in Deno 2,~ is, ~is this ecosystem problem.

And,~ uh, ~these days, Deno supports. NPM modules and Node built in modules pretty deeply. Although these are,~ um,~ not supported ~in, ~in a web browser,~ uh,~ they, they are, it is still,~ uh,~ ES module module compliant in that,~ uh,~ you import, ~you know, ~node colon FS, or you import NPM colon react. ~Um, ~these are still URLs,~ um,~ and, or URIs, I~ I guess, uh, ~more precisely.

~And, ~and,~ uh,~ As such ~are are ~are allowed ~by the ~by the,~ uh, yes, ~module standard, even though they aren't allowed in will not be interpreted properly ~and ~in web browsers. So we've ~kind of, um, uh, ~become more pragmatic. ~Let's ~let's say,~ uh,~ but because of that,~ like,~ people are essentially able to pull in,~ uh,~ effectively any NPM module now into Deno.

And get all of the other great benefits that, that come along with,~ uh, this, ~this,~ uh, kind of ~batteries included single executable runtime that we've got.

Tejas: Fantastic. Thank you for that. That was,~ um, ~exactly ~what I, ~what I hoped,~ um, ~the [00:10:00] answer would be. And I love that Deno 2 ~is, ~is ~sort of, ~as you mentioned, ~as you put it, ~becoming more pragmatic to enable just a broader set of use cases and probably also easier migrations to it, right? ~Um, ~let's talk a little bit about Deno 2.

What prompted the transition to Deno 2? Deno 1 was around for a while. ~Um, it, ~it introduced concepts like HTTP imports and JSR and import maps, et cetera. ~Um, ~what was the moment that said, okay, we need to do Deno 2?

Ryan: ~Um, ~so~ I, ~I don't,~ uh,~ build on JavaScript because I love it specifically as a language. ~It's, uh, I, I ~it's,~ uh,~ I'm not sure that anybody necessarily ~like ~loves it ~as, as, ~as a language. ~There's, ~there's a lot of, Warts on it. It's,~ uh,~ it's ~kind of ~nasty in many ways. ~Um, they're, you know, I, ~I think Ruby, for example,~ is, is, ~is a more elegant syntax.

We use JavaScript because everybody uses it. ~It's, it's, ~it's the default programming language. And because it is tied so deeply into the web, ~I mean, ~it ~kind of ~sits at the same level of importance as HTTP or CSS or HTML, it's like a protocol that builds the web. And because humanity is so deeply rooted on [00:11:00] websites at this point,~ right,~ you interact with your library on the web, you interact with your bank on the web.

Those things ~That, that it's, ~it's very likely that the web is not going to go away next year or the year after that, or five years from now, ~you know, ~who knows what's going to happen in 20 years, but ~like, it's, ~it's possible that the web is ~like ~very deeply rooted in humanity for the longterm. ~And, ~and ~I, ~I am relatively confident that AGP is not going away in five years and similarly that JavaScript is not going away.

So the, I guess what I'm trying to get at ~is. ~is that we build on JavaScript because it has a lot of users and, ~you know, is, ~is ~kind of ~the default programming language. The point is many, many,~ uh, ~people can come to it and use it,~ uh, ~very easily. And if we are building a system that is only usable for small scripts and small niche situations, ~then Then that's not, uh, well, I, I mean, ~that's ~maybe, ~maybe a interesting problem ~for, ~for some people, but that's not an interesting problem for me.

Like ~I, ~I want to build software for the millions of developers and I want to really level up [00:12:00] JavaScript and TypeScript and ~kind of ~build a solid foundation ~for, ~for the next 20 years, because I think this thing is going to be around ~for, ~for a very long time. And so.~ Uh, you know, ~I think Deno 2 ~is, is, uh, ~looking at what we've built and adjusting it so that we can make it usable ~in, ~in all the many,~ uh, ~various ways people are using JavaScript, which is like anything and everything basically.

And, ~and to,~ to support all of those many use cases where we can't be,~ uh,~ Super religious about,~ uh, uh, ~say not supporting NPM, like you ~kind of kind of ~have to be able to pull in, say,~ uh, ~GRPC modules because ~we're, yeah, ~if you can't, you need to interact with some API that uses GRPC and you don't have a module to do that.

And Deno doesn't support that. Then,~ well,~ Deno's just not a solution to the problem that you're after, and that's just, that's a shame because,~ uh, you know, ~otherwise it would be a great solution. And ~so, you know, ~I think ~Deno, ~Deno 2, is, ~you know, after, ~after many years of working on this, really ~kind of ~thinking about how we can make this,~ um, uh, ~more [00:13:00] widely,~ uh,~ adaptable,~ uh,~ approachable ~to, ~to a wider range of problems.

Tejas: So do I understand correctly then that the prompt for transitioning to Deno 2 is really just to help boost the interoperability between the Deno runtime and native JavaScript?

Ryan: ~Uh, ~yeah, that's one way of putting it,~ um, boost the, yeah, ~boost the problem set ~of, ~of things that, ~that, uh, uh, ~people can address,~ um, uh, yeah, I mean, it's, ~it's more than just the NPM support,~ there's, ~there's kind of a wide range ~of, ~of things that we are doing ~in, ~in Deno 2,~ um, but, uh, ~I think the ~broad, ~broad strokes of it are, ~you know, making, ~making sure that, that, Deno is not a niche tool for small scripts,~ but, ~but actually something that can be used for,~ uh, ~large scale projects.

And so that might mean, for example,~ uh, ~workspace support, which is also coming ~in, ~in Deno 2, or,~ uh, Uh, ~even something that's not even a technical feature, but like long term support versions,~ uh, ~just ~kind of ~backporting security fixes and having promises ~of, of kind ~of API stability ~is, ~is another way that,~ um,~ helps people adopt,~ uh, ~Deno and use it in more situations.

~Um, uh, ~because if you don't have [00:14:00] stability guarantees, ~well ~then, ~you know, ~you can't really use it ~in, ~in certain ~say ~enterprise settings.

Tejas: ~Yeah, okay.~ So it sounds like you just want to address a broader set of applications and help people realize that they can build full, robust web and native applications using this runtime. ~Um, ~on the spectrum of, ~you know, ~just a very niche runtime runtime to run a handful of scripts because of its strong opinions, to the other end of the spectrum being this is a full drop in replacement for Node.

js, but better because it has better security guarantees. It's easier to build things. ~It, ~you can,~ um, ~Choose what you give it access to the network, the file system, et cetera. ~Um, where, ~where does Dine 2 land? Does it aim to be a, like a full drop in replacement or is just maybe something shy of that?

Ryan: Drop in replacement isn't exactly right because Deno ~is still, um, you know, ~still takes the mindset that we're trying to level up JavaScript and so we are not just rebuilding node in rust,~ uh,~ that would not be a useful endeavor. In my mind, ~that's, uh, ~that's pretty boring. We're trying to build ~kind of ~the foundation for the next 20 years of [00:15:00] JavaScript and just really having ~kind of ~a stable foundation.

Now. In many situations, you can take existing node code and run it in Deno. Deno understands package.json, you know, understands NPM modules. ~Um, ~but Deno is going to be a little picky,~ uh,~ about stuff. So ~if, ~if you're using common JS in your note and package, JSon,~ uh, it's, ~it's going to want you to use ESM.

~Uh, so, you know, it is, ~it is. Pushing you ~towards, ~towards ~kind of the, ~the modern JavaScript stuff. So drop in replacement is not correct, but you know, you're talking about the spectrum,~ uh, you know, ~I say it's like 90 percent of the way there. ~Um, ~when you're just importing NPM packages, the support is great.

~Like ~essentially you can pull in any NPM package. ~Uh, it's, ~it's going to work just fine when you're dealing with a existing code base or framework of stuff. If it is. ~You know, ~very old and using common J s. ~Uh, ~there is some amount of,~ uh, ~updating to ~kind of modern, ~modern standards that you'll have to do first.

But if you're using, [00:16:00] say, a node project that ~is, uh, ~is ~kind of ~modern in the sense that it's using E. S. M. And,~ uh, ~using node colon imports instead of importing, like the You know, ~in, ~in node, you can do import FS. ~Um, ~Deno won't allow you to do that. It'll give you a nice error message and say ~like, ~please import node colon FS because FS is not specific enough ~for, ~for what we want.

So there's little things like that ~where, where it, it, ~it will just ~kind of, uh, uh, ~push you to modern practices here. And yeah. By the way,~ in, ~in Deno, you can actually do Deno lint dash dash fix. ~Uh, ~and it will ~kind of go, ~go through and, and kind of update those things for you.

Tejas: Awesome.

Ryan: So ~not, ~not a drop in replacement,~ but, ~but pretty dang close,~ uh, ~like ~where, ~where it matters.

~It, uh, it's, it, ~it can work.

Tejas: Close enough to a drop in replacement, but ~just, ~just not close such that it compromises on the quality of JavaScript.

Ryan: ~We, we won't, ~we won't let you use require. Yeah,~ we're, we're, ~we're not going ~to, ~to go that far.

Tejas: Okay. ~Um, ~where I think, ~you know, ~we're both well aware of, Capitalism ~and, ~and ~the, ~the culture around building software and,~ um,~ most companies ~with, ~with large products and projects built on Node. js, which, by the way,~ how, how, how much~ [00:17:00] I want to get into a whole separate discussion of how that even feels like inventing Node.

js and like watching the whole world build on it. But anyway, maybe for another time. ~Um, ~when companies have built ~years and ~years and years on Node. js and legacy, And, ~you know, they, ~they consider, hey, maybe we should switch ~to, ~to Deno 2. ~Um, it's, it's, it's arguably, ~it's arguably faster because it's built with Rust, but also it helps push them towards better JavaScript.

~Um, ~but then ~they, ~they may recognize, ah, but ~we, ~we started this in 2009, and it's going to cost a lot to migrate to Deno 2. ~Um, How, how would you,~ what advice would you give people in that position? ~Um, ~is it worth it? ~Should they, um,~ or should they slowly incrementally maybe ~get the,~ get to the most modern variant of Node.

js and then switch to Deno 2? Is there value in switching to Deno 2 at all at that point?

Ryan: ~I mean, it's, it depends, right? I mean, ~it's going to depend ~on, ~on a number of factors. ~Uh, you know, I, ~I think if you have a large legacy project,~ uh, and it's, it's, you know, uh, ~The switching costs ~may ~may be too high ~for ~for somebody to undertake ~that that's ~that's going to be a totally valid situation. And by the way, you mentioned, arguably, ~the performance is better, ~the performance is better across the board.

And undoubtedly, ~it's Deno ~Deno ~is ~is very fast. ~I think, uh, uh, ~yeah, it's going to depend [00:18:00] on, ~on, you know, ~the project, the size of the project, what people want ~out, ~out of this thing. I think where Deno really shines is especially when you have Engineers coming from other programming languages that might not be super familiar with JavaScript and TypeScript might not know that say prettier is the thing that you use to format your code or that you should use,~ uh, uh, uh, I'm just not ~ESLint instead of TSLint~ TSLint~ for your linter, right? There's all these things that that, you know, us in the JavaScript space ~like ~internalize and think as ~like ~second nature. But you know, somebody coming from Java or swift ~or ~or some other ecosystem ~come ~come to this and ~just like there's ~there's ~a ~A lot to learn to ~kind of ~get up to speed on stuff with Deno.

It's pretty great because it is literally a single file. It is literally an executable that comes with the code formatter that comes with the, the,~ uh, ~language server that integrates with ~your, ~your VS code that comes with, with like all the tooling ~that, ~that you need,~ uh, it comes with your.~

Tejas: test runner?

Ryan: Comes with the test runner, comes with type checking, comes with,~ uh, ~TypeScript out of [00:19:00] the box,~ uh, ~comes with everything you need to program JavaScript,~ um, ~and that is, ~you know, there, ~there's something to learn in that you need to run Deno help and learn that you run Deno format,~ uh, for, ~for formatting, but ~it's, ~it's all there in ~kind of ~a single,~ uh, Uh, ~platform,~ um, ~and that is simplifying ~in, in, ~in a certain way.

You don't need to bring together all this disparate tooling,~ uh, ~and know the right kind of constellation of configurations to get this all working ~to, ~to know what the right settings in your TS config file are and like, Oh, God forbid you like set this one and not that one and all of this stuff. Like Deno, Deno is pretty opinionated and is opinionated in the sense that ~like, ~You should not have any configuration file.

You should not think about this at all. You should open a file and start coding. Obviously ~this, ~this programmer from ~Java,~ Java is going to need to learn the syntax of JavaScript. But beyond that, like things should feel very vanilla, like ~very, ~very ~kind of ~generic JavaScript and like ~all of.~ All of this stuff should just work, right?

The code formatting will just happen [00:20:00] in their VS code editor because of the language server integration. So there's really nothing to set up. There's nothing to configure. ~Um, ~and ~so, you know, ~in terms of ~like. ~Converting existing projects,~ it, ~it should largely come down to first modernizing and then deleting configuration files.

~Uh, ~and at the end of the day, hopefully ~you, ~you have,~ uh, ~a setup that is less code,~ uh,~ and more approachable to people. And ~just, ~just has ~less of the ~less of the boilerplate.

Tejas: ~Hmm. ~Fantastic. Now I'm convinced,~ um,~ I'd love to,~ um,~ build something ~with, ~with Deno 2. What are some upcoming features and capabilities that either people aren't aware of or that's just completely novel,~ right,~ in Deno 2? ~Um, ~I know there's talk of WebGPU and,~ um,~ Deno running in Jupyter notebooks and a lot of this.

~Um, ~what are you excited about coming in Deno 2 to the developer community?

Ryan: Yeah, ~I mean, ~the big one I've already mentioned that has been like, ~you know, ~90 percent of our time is just this backwards compatibility. ~Like, ~you have no idea how much work has gone into making it possible to import like any NPM module. ~That goes, ~it feels very simple. You just import npm colon express and then you [00:21:00] have express and ~you know, ~along with that, all of the docs and the types and stuff just ~kind of ~magically come along with that.

There's ~no, ~no using the definitively types and all of this stuff. ~Um, ~So that has been a big bulk of it. ~Uh, uh, ~the compatibility we've talked about that. ~Um, yeah, ~Jupyter notebooks ~has, has, uh, is, is, you know, ~Deno has this,~ uh, ~philosophy that you should start with a single file. ~Um, ~and that means no package, JSon, no manifest, no configuration files.

~That ~you can literally just ~open, ~open a file and start coding that lends itself really well to notebooks where you, ~you know, you're, you're just ~have a single cell and you just import,~ uh, you know, uh, ~NPM colon observable plot, and then you have your plotting library, ~right? ~You don't need to actually set up this ~like ~separate manifest ~or ~or configurations and, ~you know, ~being able to do that with TypeScript kind of out of the box is,~ is, uh, it's~ pretty sweet.

~Um, ~WebGPU, you mentioned ~Deno, ~Deno has WebGPU built deeply into it. It's been around ~for, ~for a couple of years now,~ uh, ~can actually build games in Deno that ~don't ~use the web browser, can actually use Deno compile to take that WebGPU [00:22:00] game, compile it down to an executable. You can actually cross compile with Deno compiled.

So maybe you're writing this in Macintosh and you want to cross compile this to windows and ~get a, ~get a game. exe and transfer that over to a windows computer,~ uh,~ open a little,~ uh,~ We actually have a great flappy birds,~ uh, ~demo that, ~that I'll, ~I'll give you a link to, that you can maybe put in the show notes.

~Um, the, ~the bigger stuff though ~is, ~is our standard library that ~is, uh, ~just reached 1. 0 version,~ uh, ~and the standard library is, Really nice audited utilities ~in ~in javascript that you can just,~ uh, you know, ~for example, maybe you need to parse a yaml file, right? ~Uh, ~stuff like that is all sorts of little utility functions that we have worked for years on now in Deno are actually making this available not only to just, ~Deno~ Deno but to other run times to,~ um, ~this standard library is I think really needed in JavaScript,~ uh, you know, we, ~I think we've suffered for a long time by having just ~too many, uh,~ too many random, you know, is even modules on, [00:23:00] you know, left, left pad modules on NPM,~ uh, ~Written by random people on the Internet that actually in itself is a security problem, having a kind of core set of libraries that you can pull from that, you know, are secure ~that ~that are audited that, you know, are at version one and are not going to change their interface.

It just makes things that much easier and ~kind of ~lends itself to our overall goal of leveling up JavaScript. Let's build this for the next 20 years here. ~Um, so, ~so, yeah, we've got our standard library and we've got the JSR. JSR. io is a,~ uh,~ new registry where you can publish JavaScript and TypeScript. ~Uh, ~JSR is,~ um, very, ~very easy to publish too.

~Uh, ~if you've ever published a package in, To NPM,~ um, you know, ~it used to be great when everything was common JS and JavaScript, but now that you've got TypeScript and you've got ESM ~and, ~and,~ uh,~ NPM becomes ~kind of ~a compile to target,~ uh, and, ~and ~kind of ~getting that correct ~is, ~is definitely a headache for,~ uh,~ a lot of [00:24:00] people also on the consuming side,~ like NPM is not since, ~since GitHub has acquired NPM, like it's effectively not changing anymore.

~Um, ~and that's a real shame because,~ uh, uh, ~A code registry is a place that should have auto generated documentation. It should have some sense of how well this, how, some sense of ~like, uh, uh, ~score for the packages. Like how, ~you know, how, ~how well ~is, ~is this package up? Is it following best practices? ~Um, ~should have, have kind of security mechanisms ~to, ~to know ~that, ~that this package was published by this author,~ like, Uh, kind of ~cryptographically,~ um, all, ~all of these thoughts ~have, ~have been, and many more actually ~have, ~have been put into,~ uh,~ JSR,~ uh,~ JSR is not attempting to replace NPM.

~Uh, that's, ~that's a,~ uh,~ fool's errand,~ uh, I've, ~I've realized now,~ um,~ so JSR packages can depend on NPM packages,~ um,~ it's ~kind of ~a superset ~of, ~of NPM,~ um,~ and just generally makes,~ uh,~ everything great. ~Uh, it's, ~it's, it is built for more than just Deno. So ~it's, ~it's not the Deno registry, but the JavaScript registry and ~has, you know, ~we live in a world now ~with, ~with multiple runtimes, right?

There's, it's [00:25:00] not just node. There is of course the web browsers, there's node, there's Deno, there's bun, there's cloudflare workers. And other ones up and coming. ~Um, ~and ~you know, ~I think we're really ready for a world where,~ uh,~ yeah, we need a registry ~for, ~for the next 20 years of JavaScript that's ESM first that supports TypeScript.

~Uh, ~so yeah, the JSR,~ uh,~ if people try it out,~ I,~ I guarantee you, you will be shocked at how nice it is. ~Uh, ~I mentioned we have workspace support ~in, ~in Deno,~ uh,~ we're supporting private MPM registries. ~Um, ~And yeah, just generally improved performance across the board. ~Deno, ~Deno's,~ uh,~ cold start times, for example, on Lambda are,~ uh,~ second to none,~ uh, uh, ~web server throughput is fantastic, et cetera.

Tejas: Wow. It sounds like a real overhaul and ~one for the, ~for the benefit. And if it ~like ~has 90 percent interoperability with current state JavaScript. Oh my gosh, that sounds like something so extremely compelling. ~Um, ~I'd love to start wrapping up and this is the last question I'll ask you, but I think it's the big one.

~Um, ~given that Deno is now stepping into Deno 2 [00:26:00] and all of this is happening, ~what ~Where do you see Deno in the ecosystem in the next few, maybe months or years, relative to where it is today?

Ryan: ~Uh, ~where do I see it in the ecosystem? ~I mean, ~hopefully ~it's, ~it's ~a, um. ~The Swiss army knife that everybody reaches for and just knows and trusts that ~this is, ~this is being built by the creators of node ~with, ~with a real eye towards the future and, ~you know, are not making compromise, you know, ~are making sure ~that, ~that this can work ~in, ~in a lot of situations, but, ~but are.~

Are not ~kind of ~compromising ~on the, ~on the long term vision that ~like the ~ultimately browser JavaScript will always be the future of JavaScript. That JavaScript is the default programming language that has a long future in front\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\ of us ~that, you know, it, ~that JavaScript ~is, ~is essentially the best way to implement business logic.

For a lot ~of, ~of use cases and just needs this kind of solid foundation. ~That's ~that's well thought out ~and, ~and that people can ~kind of ~reach to and just know that ~this, ~this Swiss army knife ~of, ~of utilities ~is, ~is there. And,~ uh, uh, ~ready for them. ~So, you know, I, I, ~I would hope ~that, that, um, uh, you know, people, ~people ~see, ~see Deno ~as, ~as ~kind of ~their primary,~ uh, ~application [00:27:00] platform.

Tejas: Fantastic. With that, listen,~ um,~ this has been so great, Ryan. It's been a privilege to talk to you. ~Um, ~somebody who I attribute most of my career to,~ um, and, ~and to hear ~kind of ~the vision and ~the, ~the future ~of, ~of Deno,~ the,~ the runtime. Indeed, I also hope that it's a, Swiss army knife that everybody's reaching for.

I certainly will reach for it after this discussion and I can't wait to see what people build with it. ~Um, ~on behalf of myself and all the listeners, thanks so much for coming on and chatting with us today.

Ryan: Yeah. Thanks so much.