Announcing Deno 2

hi I'm Ryan doll you might know me as the creator of node.js as a programmer I like things that are simple really simple programming should be simple that's why I created note but these days note is not simple just ask Rachel she's been here for days setting up typescript is an easy 47 step process first you take a TS confus this year and add an es in front becomes a JavaScript Target don't forget Al Gore and here's Steve commemorating the 20th test framework he's recently learned please be gentle okay I'm good getting node apis to

work in the browser can be ah [Music] frustrating security is also a nightmare npm packages have access to everything go go go grab everything grab everything over here got [Music] it but you can be a faster more productive developer with Dino the simplest way to Pro program Dino comes with typescript all-in-one tooling and web standard apis so you can write once and run anywhere anywhere anywhere Dino is secure by default so every dependency doesn't have full access to your computer and you don't have to give up the packages you love from npm yeah and many

[Music] more so join hundreds of thousands of developers using Dino because programming should be simple [Music] hi my name is Ryan D creator of node.js and Dino today we're releasing our biggest update yet Dino 2 let's go check it out JavaScript is the world's default programming language it's deeply rooted in human infrastructure because it's part part of the web like hdp or css and it's not going away anytime soon it's going to be here 5 10 years from now if not 20 years from now and because of that we are building on JavaScript we want

to make it great Dino is a runtime for JavaScript development it natively supports typescript as well and and it's it's tries to narrow the gap between browser JavaScript and serers side JavaScript it uses web standards es module tools fetch API all sorts of stuff it is an all-in-one tool chain for JavaScript development that's really batteries included it has all of the utilities you need uh it's secure by default and and backwards compatible with node and we'll see that in action Dino is the simplest way to get started programming typescript you can really just open a

single file you don't need to create a package Json or have a node modules folder a single file is all you need to get started let's see that in action I'm going to create a LS program listing listing the files in in a directory and uh let's let's see how how that looks in in Doo let me just create a main TS file and uh let's open up vs code so uh to to list the files in directory there's an API called reader doo. reader this is one of the built-in uh dino uh apis and

it takes a path as an argument you can see kind of the built-in documentation working here uh and the the built-in L the built-in language server uh uh kind of giving me a red squiggly because I don't have any arguments so I'll give just the current directory dot as as the argument to start with and uh this thing uh is this this command uh this this function returns an async iterable that lists the the elements in in the the files in in the current directory let's try to Loop over these using an async await entry

con entry of doo. reader and for now let's just console log that entry out so if we run Doo main TS uh you'll you'll see the secure by default permission prompt in in action here so we're trying to access the file system Doo doesn't allow you to do that unless you explicitly give it permission you need to give it the allow read flag or say yes at this prompt if you do uh it will it will work um but often you don't want to click through a bunch of permission prompts you probably want to give

the allow read flag that lets you do this or the shorthand version of that is Dash capital r uh to to give the allow read permission let's expand this a little bit instead instead of using dot as as the the hardcoded directory that we're going to list let's actually take an argument from the command line so we'll use Doo ARS zero here and we can of course do dot or we could do I don't know a different directory that has a bunch of files in it like this one let's abstract this a little bit further

uh turn this into a function so tree we'll call it tree and let's say it's takes an argument called dur that's a string and let's say this this tree function just returns a bunch of strings in an array of of each of the file names so we'll move that Loop up here and you can see that we're getting some red squigglies here from the language server this is saying that we that we're doing a 408 Loop outside of an async function so let's let's just add an async here by the way you can see these

same errors if you do Dino check so just to back up a bit we'll do Dino check main TS where you can see these these same errors um but you know it's more often more convenient to see this in in the in the LSP it is uh complaining because I'm not returning a promise of course it's an async function so let's add uh promise there um and it's still complaining because I'm not actually returning anything du so uh con out equals empty array and we'll just push out uh and entry is actually an object let's

let's actually output the the name of the just the name of the file there and and we'll [Music] return return out at the end and then of course we need to call this thing so let's say a weit tree and we'll do doo args zero here and let's just console log out those files and I'm realizing that I'm actually not using the argument here I I should move change this to a d and um yeah red squiggly because I'm missing a parenthesis okay so how does that look yeah all right so now now now we've

kind of abstracted this out into a function as I said Dino is an all-in-one runtime and it combines a lot of disperate tooling that you need from in the node ecosystem into a single binary Doo is literally a single file so for example you might use prettier in node to format your code in Dino it's just Dino format or for type checking you might use TSC uh in Dino it's just Dino check uh or maybe you use es lint in in node you can do the same thing with Dino lint and many more let's take

a look at one of these subcommands in more detail Dino compile so this actually takes your JavaScript and bundles it together with with the runtime and creates a a binary output just called the dino compile subcommand and as you can see it has created this demo file here which is which is a arm 64 Macintosh executable file and we can just execute we can just call that like we would any other program of course we need to give a proper file name here and and it works as normal so you can distribute this without Dino

and it will continue to work indefinitely it doesn't depend on on any other files one cool feature of Dino compile is the it can actually cross compile so if you do-- target it will give you a list of possible platform targets that that you can give to it let's try to cross compile this program for Windows so we'll we'll do an x x64 windows binary if I can spell Target correctly and as you can see we now have a demo. exe file that is appropriate for running on Windows I don't have a Windows computer here

but iice it to say this demo. exe is appropriate for running on Windows but you could do all of that with Dino 1 let's talk about Dino 2 dino2 is a revamp in multiple areas ecosystem compatibility package management and Enterprise features let's start with ecosystem compatibility one of the things I've heard the most from users of Dino is that they love how simple Dino is it they don't have to have any configuration they can just get started with typescript but uh inevitably they come across some existing node project that they need to interact with whether

it's an npm library or or some uh existing uh project doo2 is is fully backwards compatible with node when using ES and doo2 understands your package Json node modules and npm workspaces npm packages are supported even complex ones like grpc or ones that use native extensions the so-called napi um this allows you now in Dino 2 to incrementally adopt Dino without doing an overnight uh stop the world full migration to see a complex node application running in Dino let me show you create next app so create next app of course uh creates kind of a

boilerplate uh nextjs application and normally you would do npx create next app uh in Dino here I'm I'm actually going to do- mpm create next app and uh yeah we're going to run kind of the creation script and let's choose all the default options here and wait a second while npm installs it takes a while because npm is slow we'll see how to alleviate that in a second possibly the internet slow possibly I don't have internet okay now I do have internet here it is actually forking out to node and using npm but uh when

when we're done we we finally have this this my app folder uh with a node modules folder in it of course and a package Json a typical create next app uh in Dino now dino tasks Dino understands all of these things so you can run doot task and you'll see a list of available commands here like doo Dev and build and start and lint let's run the dev server Now with uh dino so dinot task Dev will actually start the nextjs dev server here at Port 3000 and uh yeah you can see it running just

to kind of clarify that this is working correctly let's just edit this uh page TSX file and and uh we'll just say get started by editing and write Dino instead here and uh yeah hot module reloading works all of this is being executed by by the dino runtime it's not just next remix Astro and many other Frameworks are supported by doo in addition to full backwards compatibility with node applications all Doo programs can now import node libraries in the form of npm packages without requiring a package Json or node modules folder and secure by default

execution is maintained let's take a look at this in action with our LS example here and let's just try to make some color output using uh the npm chalk library to do that in Dino you can just do import chalk from npm colon chalk note uh Auto formatting is happening in the background and uh we can just use chalk as normal so chalk say BG blue for for a blue background and uh files is actually an array so let's let's just kind of join that with new line character so uh dino main TS running this

again will hit this permission prompt so what's happening is is that chalk is trying to access VAR various environment variables Force color here let's allow that by saying yes TF build let's allow that term CI team City version color term if we say yes to all of those we we do finally get uh the proper output here with with blue background color we can avoid those permission prompts by adding an allow n flag and then we don't get those or or just just A- capital E for for short Dino D rer but actually there's a

better way to do this in in Dino let me show you how you can get color output just as as an example of of kind of how Dino uses web standard apis how you can get color output in in a way that also works in web browsers so console log percent C actually allows you to supply some some CSS so we'll we'll do uh files join back slashin and we can just say background color let's change it to Red for and uh this this should give us our our red background uh LS for whatever reason

you you might want that this doesn't doesn't actually read any environment variabl so we can we can remove the the allow n flag from from the execution just to recap in doo2 you can run existing node applications Doo now understands your package Json and node modules folders out of the box and if you're not using package Json Dino allows you to use the full breadth of npm libraries in your Dino code without any configuration and allowing them to be secure by default and that's ecosystem compatibility now let's talk about package management with din support of

package Json and node modules we've added three new subcommands to help you manage these they're really similar to npm you should should basically immediately know what they do doo install Dino add and doo remove Dino install inspects your package Json and installs dependencies but really really fast when you have a package Json Dino will install your dependencies in the node modules folder creating one in in your project tree if you don't have a package Json it will look at your Doo Json file find any dependencies in an import map and cach those globally Doo add

and Dino remove are really simple sub commands that add and remove dependencies from from a a package Json or Doo Json file let's take a deeper look at Dino install we're back in our create next app where we have a node modules folder that create next app created actually NP M install created this create next app ran npm install this is a folder that has roughly 319 megabytes of dependencies let's see what Dino install does by just removing this directory and then running Doo install it happens really fast now we have a new node modules

folder with the same size as before and of course you can run nextjs by running Doo task Dev that's what Dino install does but if this was all there was to package Management in Dino this would be pretty disappointing which is why it's not let's talk about jsr the successor to npm jsr is a new package registry where you can publish JavaScript code and share it with people and it's not just JavaScript typescript is also supported jsr is meant for the future it is a registry that that is not just for node but for all

JavaScript runtimes and we need a registry that can support all of those different runtimes jsr only supports ecmascript modules not not common JS uh so kind of forces you into the future in a certain way and is really designed to work with npm and not against it so meaning that that packages in in jsr can actually have npm dependencies so in a sense it's a superet of of npm jsr of course provides really great developer experience for consumers and Publishers of packages and and we'll see that in a second Dino standard library has been developed

over the past four years it's a great set of utility functions in all sorts of areas and we have now stabilized the Dos standard library to 1.0 and published it to jsr also this set of of libraries is not just for Dino now you can actually import a lot of the standard Library modules in node and other runtimes so instead of needing to know all sorts of different npm packages you can actually just use this standard library and my hope is that this can serve as a base and yeah help help Level Up Ja JavaScript

so for example in instead of using just you might use testing or instead of using chai you could use expect or for command line flag parsing maybe instead of using minimist you can just use CLI or instead of low Dash use collections uh and many other packages are available let's make use of one of these standard libraries the file system library and we'll we'll try to use that to improve our LS demo so let's just go to the jsr website and search for STD fs and this is has various file system functionalities helpers for for

file system and uh let's search for walk here which gives you the functionality to kind of recursively walk through a directory tree it's really similar to the dino reader except it's recursive so it also takes a string argument and returns an async iterable let's make use of this by just copying this import here and pasting it into to our demo we can make use of it basically immediately by replacing the dino reader with with walk and uh that's all that we need to do here we can just run this code now and you might notice

that there's quite a few more files now let's actually change so it's entry. name is is just the the the file name but if we do entry. path we'll actually get absolute Paths of all of these things and you can see that it's kind of recursively jumping into like the the jsr directory in this case let's let's actually make those absolute paths into relative paths by using one of the node built-in libraries node path just to give you a sense of what it's like to pull in node built-in libraries so you can import uh relative

from node colon path a library that I assume many people are familiar with um and all we need to do here is is uh replace this this entry path here with relative uh dur comma entry path to uh actually make these uh relative paths so that's all there is to to pulling in jsr dependencies again we don't need to create any extra files there's no node modules folder there 's no installation at all it kind of happens automatically let's try to let's say we want to publish this and share this this tree function with people

let's see what it's like to actually publish to jsr so all I need to do here is go into my jsr window my browser and click publish and I'll I'll publish this under the rise scope and the package name let's call it demo and uh when you you click publish here it's going to give you a little Json snippet that you can drop into jsr Json or Doo Json and let's just create I I'll do a dino Json so I'll create a doo Json file and I'm just going to update the version here to to

version three because I've tried this before and uh yeah the the exports actually I I don't have a mod TS but a main TS file so let let me modify that and then in my main TS file I need to export this function and uh I don't actually want this this uh these two lines here at the bottom to execute on every every time you import it so I'm actually going to wrap those in in a if import meta Main and uh yeah we should be ready to publish so all we need to do is

is run Doo publish and I'm getting two errors here uh the first one is is on line one with this jsr import I don't have a version specifier so it's fine to import packages from jsr and not have a version constraint but if you're going to use those packages and and publish a library to to jsr you actually need to be a little bit more specific about what version you're depending on so so that we can resolve those packages uh concretely and and we'll depend on on version one sver version one of of that the

other thing it's complaining about here is I'm missing license field in my doo Json file so let me add license and we'll just call it MIT and let's run Dino publish again I need to authorize this publishing again I'm logged into the website and we have some security constraints on on jsr wait a second and yeah this is this is now published so uh you can see the doc generation happening here and and you can see the the tree function has been published to jsr there's no there's no actual JS doc or or documentation for

this yet and yeah maybe I'll I'll just show you what it's like to add some docs here so let me add some js docs so we'll we'll just say uh recursively list out files in a directory and all we need to do then is Bump the version and run publish again approve it wait a second and there we go now now we can see the doc string represented in the autogenerated documentation to recap package management improvements we've added three new subcommands Doo install Doo add and doo remove to help you manage package Json or or

Doo Json files the dependencies in them we we've introduced jsr a modern registry for publishing JavaScript and typescript code that supports all run times and we've stabilized the dino standard library to sver 1.0 and published it to jsr and made it available to all of these different runtimes out there that's package management we've been talking to a lot of users at larger companies about their usage of Dino and the feedback that we've received is that it's great but uh there are a couple of missing points private Registries monor repo support and stability guarantees or or

long-term support so let's talk about each of those first of all private Registries are Now supported in doo2 uh essentially in the same way that they're supported in node you can add a mpm RC file use the same syntax that you do in node and you can access your company's internal private registry server that easy as that you can pull in uh those those private mpm packages Dino workspaces is similar to npm workspaces in fact interoperates with with uh npm workspaces but essentially is is monor repo support it allows you to have multiple packages in

a single mono repo and Dino workspaces lets you mix and match uh package Json modules and Dino Json modules uh seamlessly and and has the the great developer experience that uh one knows and loves from Dino we've seen that larger more mature development teams can't upgrade at the same Cadence that we are releasing Dino minor releases we release every six weeks so to help support those teams we are introducing long-term support Branch uh LTS releases this is going to start with Dino 2.1 which will be released uh in October and we will be backporting critical

bug fixes to this Branch for 6 months this LTS release of course will be MIT licensed freely available like the rest of Dino but is largely aimed at at companies that need to kind of vet individual binaries or have processes for for introducing new versions We have additional Enterprise support commercial support available you can learn more about that at dino.com Enterprise I want to touch on Dino's performance Dino's performance is great for instance Doo's HP server has almost twice the throughput as nodes JavaScript runtimes are multifaceted and have lots of different functionality and so so

it's hard to sum it up in a single number or a single graph but here are a number of benchmarks that give you some broad idea of how Dino performs overall Dino performs fantastic and there's much more we're just scratching the surface here we haven't talked about web GPU we haven't talked about dos documentation generation we haven't talked about our uh ffi or fresh or D deploy I do want to leave you with one more demo here on our Jupiter notebook support so I'm going to just open up Jupiter notebooks and I'm going to create

a new notebook all you need to do is switch the kernel from python the default of course to Dino and you can now execute some dino code uh what I'm going to do is pull in observable plot and uh plot some stuff uh with with JavaScript so let's let's do that so import Star as plot from uh npm colon observable HQ plot is uh let's make sure that works uh yes uh observable plot is uh just a fantastic uh uh Graphics library for for analyzing data I need a little bit of data to analyze so

let me pull in a data set called Penguins so import penguins penguins from uh and this is just a little uh library that I have called Jupiter DH helper on jsr Penguins is an async function that returns some data so I'll just await penguins and let's see if we can actually load some data here yeah so here's here's a table this this data set is a bunch of measurements of penguins just just kind of a sample data set we need one more uh object here which is a document object in order to interact with observable

plot so let me let me assign this penguin's uh uh data set to P here and let me print it out again just so I can see and yeah let's do a scatter plot with kind of two two rows of of this data here so observable works like this you do plot plot and you give it some marks which is in Array and you give it this document inside of marks if you want to do a scatter plot do plot Dot and we'll just do a P2 records to get uh our Penguins data set in

the right format and then we just need to give it X and Y coordinates here yeah let's just say const x equals Coleman length I think this is some measurement of a penguin's uh beak size maybe and I don't know let's let's measure it against flipper flipper length const Y is flipper length and yeah there we go we we have a scatter plot it's black and white you know maybe not so interesting maybe we can add some color here and and kind of color it based on species and yeah suddenly you can kind of see

three different species of penguins kind of broken out by their flipper length and Beak lengths um so yeah just to take everything full circle here let's uh pull in that tree function that we just published to jsr and plot a directory tree with that so first of all import tree from jsr rdo2 DDO and yeah let's just make sure this works so await tree users Ry SRC Dino runtime my favorite directory and yeah we've got we've got an array of data here let's ass this to a variable uh files let's say and yeah let's let's

do some observable observing so plot plot marks is in Array and we'll just do plot tree and we'll give files here and again document and yeah suddenly you have a visual representation of a file tree can maybe even clean it up a little bit more more by turning off the axis and giving it a a margin but uh yeah same thing observable is super cool check it out and it interacts very nicely with Dino and Jupiter notebooks like I said before there's so much more to dino we're just scratching the surface Dino is ready for

production now I can't wait for you to explore it and by the way we we've we are also introducing a new logo so check that out thank everyone hello everybody this is the dino team streaming to you live from a hotel conference room in Dublin I'm Joe I'm the devel here at Dino and I'll be our host for this live stream uh I hope you're super excited about Dino to I know we all are the whole team we're actually here together for an offsite that was happening uh we're in Ireland it's about 5:30 p.m. for

us at the moment but we thought we'd take the opportunity to open the floor up to the entire team to your questions we're looking forward to hearing what you're excited about what you'd like to know and you can get the chance to actually ask questions of the engineers who have built the runtime that you love but before we get to the questions let's actually introduce the team they'd really love to meet you all as well and hear a little bit about what everyone has worked on so first up let's have LCA hi folks uh I'm

luuka I've been working at Dino for actually ever since the 1.0 release um and I've been working on Doo 2 for a while mostly on node crypto um upgrades and jsr yeah um I want to introduce Dy next uh hello uh I'm Dy uh I worked on framework compa like nextjs Astro for Dino to and doo compile and yeah I'm really excited about R 2 uh yeah David hi everyone uh I'm David I work on the C team uh I've worked mostly on workspaces and mpm resolution uh most recently and uh Nathan hi uh I'm

Nathan uh I've been working on node compatibility like angular and playright um also the dino install sub command and uh the dino ser parallel option uh Gus hello I'm Gus or snack um been Doo for a few months uh I work on CLI on node compatibility like the node API um and asent Cooks um I also work on maintaining and upgrading our uh JavaScript V8 bindings uh keep those nice and fresh um next we got Josh hey Josh uh fr developer at Dino uh I have been working mainly on the website and the new dino

brand and uh docs here and there lots of other fun stuff uh especially in tandem with our designer John hey I'm John a product designer here I work on docs and jsr and uh Doo deploy and some other new stuff that we haven't seen yet so um yeah I guess Leo over here couple more hey I'm Leo um I work on jsr web apis and a bunch of dogs and dog Generation stuff and here are BK Ry and bdone in I see a lot of folks on the live stream asking about how they can get

stickers uh if you would like to get some stickers uh if you contribute an example to our doc site we will happily send you out some stickers so get contributing but team introduce yourselves uh hi I'm BK I'm the team lead for the dino CLI um I've been working on Dino for over five years and uh I wrote stuff like Dino bench or Dino test do land but I pretty much touched everything there is at some point Ryan I'm Ryan you just listen to me stutter through a prolonged introduction to dino uh hopefully it wasn't

too painful uh somehow I've become a marketing mascot for for this company uh uh but uh yeah also also co-founded it here with with Bert yeah I'm Bert Ryan and I go uh back more than a decade to the early days of node.js actually where you know Ryan of course invented that and I was involved in the development of libuv and porting it to Windows and actually made it possible I yeah did did the all together with e by the way who is in the back of the room and did introduce himself should point that

out yes I I forgot to say we have of course also got the deploy team with us here today say hi deoy team awesome so let's jump straight in uh with the most important question which has come from the chat which is Ryan how did you manage to code all of that without Co without co- pilot uh I think I did have co-pilot on in there uh but maybe I disabled it um yeah really I practice life demos like many many times uh and still still stutter through them excellent so uh first of all a

question from me like what are the changes that you're most excited about that have come in from dino2 uh like do you do you have a personal favorite you oh I love all of them honestly that's cheating uh sure it is uh well I believe I'm most excited about giving folks ability to run their existing projects uh that were probably offered for nodejs with Dino uh with little to no changes that's a huge thing uh I really like jsr uh it's it's fantastic um all the note compet stuff is is good and necessary but uh

it's more fun when we can kind of push the envelope of what's possible in JavaScript yeah for me it would also be exactly that uh the compatibility with you know the ecosystem in in a broad sense is really important for me uh I also really like workspaces to be honest uh I think it's a it's easy for to forget that but I think it's very very useful nice awesome uh some some cool things for people to look out for particularly for adino 2 so um there's a been a couple of people asking in the chat

what's happening with bundling in dino2 is that something that's going to be supported what what's the plan uh well the plan is still in the works uh as you folks probably know we deprecated and remove Dino bundle but we're not giving up on it we're just regrouping here and figuring out the best Solutions so we can actually uh cater to your needs and and satisfy what you uh want to do when bundling with Dino so stay tuned for some news bundling is like a very hard problem in general uh and we've had a simple solution

that uh just compiles all of your code into into a single file and that's nice for some use cases but in general for websites bundling is is a very very difficult problem and Dino is more focused on executing JavaScript than uh solving this other very difficult problem that of bundling and we are not satisfied with uh how Doo bundle operated uh and didn't feel that we could contribute something that was state-of-the-art for website bundling and so removed it so uh we'll we we acknowledge that this is an important part of the JavaScript tool chain but

uh yeah we are going to be looking at uh how to improve that situation in the future you know I I I think this this might mean uh uh shelling out to to some other bundler like like es build uh it might mean uh kind of working with uh yeah there's many projects out there that are that are attempting this and we'll we'll integrate that somehow into the the overall Doo tool chain but that's uh not here in doo2 cool um and there's a few people asking about um compile uh so are we going to

be able to take the node tools like things that require node installed compile them and then remove the node requirement for end users oh that's a tough one uh all depends on the particular tool it's hard to say and mass that all of them will work um but that's certainly possible for some of them um I think es L might be a good example that could be compiled down and not require node anymore um but yeah pretty much you need to evaluate on the tool about by Tool basis because these tools are really complex and

they do uh a lot of intricate operations uh so can't really promise that all of them will be able to be compiled down with yeah and there was a lot of people asking about uh electron and like desktop apps are we going to be able to build those uh so Doo does have uh some some pretty interesting support for uh windowing and I'm blinking on the the actual uh uh sui no um uh for for binding a a window um there's window surface unsafe window surface dy's got some demos out there of of kind of

drawing uh Native Native applications um and I think the the very interesting ones are taking web GPU uh without a browser and kind of drawing a window directly on there he's he's got like a Flappy Birds demo that you know is is GPU accelerated and drying on a desktop and can use Doo compile and compile down into a binary but actually doesn't use you know is not bundling a browser at all um electron likee capability is uh you know likely you want to have a a web browser uh bundle along with that and I think

would require kind of more more infrastructure um but uh you know I think this can be built with doo compile with some work awesome and and uh this is maybe a difficult question off the top of your head maybe you know do you know how big the compiled one time is it's uh I think 60 megabytes or so on Macintosh I think it depends on on the the platform which you know you you might bulk at if you're a go user and and seeing a hello world demo that is a couple of kilobytes large but

uh it it is the full JavaScript runtime so the way that Dino compile works is it kind of takes your JavaScript and attaches it to the end of a slimmed Down Dino binary uh it's it's not compiling your JavaScript into into assembly that that's not possible JavaScript is is a very Dynamic language but frankly does it really matter like 60 megabytes uh I think I think it's a kind of academic argument it might matter in in certain situations but in those certain situations JavaScript is probably not the right tool for the job in the first

place uh and somebody asked uh I don't actually know can we install Dina with Homebrew at the moment are we planning to be able to install Dino with home bre uh oh yeah certainly uh not right now uh We've released Dino to like literally a couple hours ago and Nathan back here is uh working really hard to uh provide the home bre build so expect it to be available uh maybe in matter of hours or maybe in a couple days but yeah it's it's getting done awesome that's really cool to hear um and there was

a lot of love for uh fresh happening in the chat while the video was streaming so what's happening with fresh and is there going to be a fresh two fresh 2 is coming uh we've been working on this Dino 2 for for a while now but uh it's it's uh you know we're we're dotting our eyes and crossing our tees so uh yeah stay tuned awesome and how about deploy uh does deploy support D2 not yet but we are not this hour but maybe in the next hour uh very soon now yeah very cool very

cool okay and uh there's somebody asking uh does Dino work with playright do we support play uh yeah it does work with playright uh certainly Linux ma um so just try it out and you should be good to go excellent um and what else have we got in here does Dino cash completely replace the timeout warmup in containers now oh that's a tough one I don't think Dino cash produces the V8 code cache uh no it does not um however you can still use Doo run to uh warm up the V8 caches and have pretty

much the as much data as possible cached to improve your startup time so um the answer would be no Dino cach does not replace it by the way switch your Dino cache usage to dino install that's the preferred way of of naming it Dino cache is still there um but it's it's a to-do for Dino install to produce the V8 code cache which is what's necessary to really optimize the cold start time uh and we we have a blog post on uh AWS Lambda cold start optimization and and show how to do that in a

Docker file um yeah you can Google it um and if you are if obviously if you have a adino 1x uh project where can we go to learn about how to SW over to Doo 2 uh well first of all if you do upgrade Dino from Dino 1X to doo2 you will be presented with this nice Banner linking to the blog post uh but also to the migration guide which should work you through uh most of the changes required and uh well there should not be too many changes required we were really diligent and and

how you migrate from Doo 1 to doo2 so hopefully just do doo upgrade and everything still works but if you need help go to uh dodo.com and search for the migration guide page awesome um so the website talks a lot about Dino being secure but like what does that actually mean in comparison to node for example that means that when you do any sort of IO operation when you access the operating system if you touch the disk if you open a network connection if you do some operating system you know you try to to list

the the network interfaces uh you doo by default will not allow that to happen uh they're they're in a similar way that if you go to a website that tries to open your uh uh camera uh you it's you just don't don't have that permission by default like you have to kind of opt into that permission and so similarly in in Dino you need to opt into being able to read from the file system for example or open a network connection awesome um okay what other questions have we gotten from chat um are we going

to get jsr private packages and self-hosting maybe not yet well if you're brave enough you can certainly host your own uh jsr instance and use it with Dino uh yeah yeah J jsr is open source unlike the npm registry uh and you you can can go find that code uh github.com dinoland jsr I believe and yeah host it yourself you know it's it's uh it's going to be more than like running a single command of course and we we haven't made that particularly easy uh I you know I I think if if you do need

private uh private packages I think the right way to go about that right now is to have a uh npm private registry uh as you normally would and Dino supports that and and you can kind of pull in packages via npm colon um having private jsr registry is um something we've discussed but uh and certainly possible if if you if you kind of uh twiddle the knobs enough but uh probably probably not a happy path for most people enough um okay and uh but you mentioned that workspaces sort of most excited feature that you've added

like could um could you expand a little bit on like what workspaces are and what the plan for extending workspace functionality is in the future I don't think I'm the right person to ask how to Extended but workspaces really helps you if you have a mo if you have a mono repo where you develop um an multiple applications or multiple Doo programs and you need to share something between them um but I think btech what what what are we planning to do there next uh well right now you can use um Dino workspaces like let's

say Dino first but you can also use npm workspaces with Dino and you can even mix uh the two of them in in a single monor repo so uh let's say you have an existing app that consists of multiple supporting libraries uh you don't have to buy write in for all of it like Ryan mentioned in the presentation you can start small uh at a new d directory that is Doo first and essentially mix and match feel if you if you like the flow and then migrate gradually so that's like one of the coolest features

of Works spaces we have right now um but obviously people have um a lot of experience with um Works spaces in ER and pnpm npm and we definitely want to uh keep improving dins uh implementation to make it more ergonomic and Powerful as um as people need it nice um so a few folks have mentioned having the ability to create plugins or extensions is that something that's in the works like a yarn Plugin or like an install hook or custom CLI command I'm not sure I know yarn plugins to be honest um well you can

certainly create CLI tools with d know like that's pretty much one of the best use cases um as Ryan present presented Doo compile you essenti she get the single executable uh so that's that's perfect solution as for yarn plugins I'm really not sure what to to answer here I'm not familiar with them yeah what do what do yarn plugins do does anyone know what your plugins do we don't have Marvin here resolution oh custom resolution yeah I mean if if the question is like how do you kind of do your own custom resolution scheme uh

we're fairly adamantly against that right we we we want kind of a defined resolution uh mechanism so you know we have these npm colon we have you can pull in uh HPS spec uh uh you you can pull in source code from URLs uh there's a couple of defined paths for pulling in packages but uh we don't want the language to just go off in every different direction like we we kind of want a a structured language that has a defined resolution scheme uh to this is you know essentially what what makes uh a lot

of node uh tooling so complicated is is that people like augment the language and pass it through transpilers and do all sorts of uh funky stuff with it that uh ultimately results in in a pretty complicated system but that said I don't actually know what yarn plugins do so that's all assumption okay uh then moving on uh someone has asked whether um security tools like sneak are going to be able to analyze the Dino source so that Enterprise security groups are going to be more willing to adopt Dino LTS we should use sucket dodev instead

of sneak first of all um but uh uh uh eventually yes uh we we're we're very open to working with sneak or and uh I I'm sure socket will will add support before that at the end of the day like you know it's very you know vanilla JavaScript that you write at Doo so tooling that they already have that what should work for node probably it's very easy to adapt to you know awesome and uh when is dino2 going to be a certified image for Lambda say unknown yeah unknown we're trying does doo2 work nicely

with Puppeteer yes it does excellent um and are we getting native uh SQL light API SQ light it's implemented uh the uh Dy just just implemented it yesterday the node colon uh SQL light built-in library that that node has I think we probably wait until node UNF Flags it before we release it um but uh given that we Implement all of the no built-in apis if they stabilize it we will we will follow close all right well we're reaching the top of the hour so maybe we could uh consider wrapping it up but uh i'

just like to ask each of you and indeed anyone in the room it's lovely to have you all here um you know this is like a significant milestone for Dino so what future enhan enhancements are you personally excited about like what's coming what can people out there get excited about the list is endless uh no my personal favorite something that we've been pondering for a long time is maybe plings for for linting so that you can uh use use your favorite presets or write your own uh presets to to enforce certain uh conventions across your

team and Company I'm looking for DM Imports uh we've been doing Luca has been doing work in in tc39 to to kind of make sure that this is uh sound with the language uh and I think this is all kind of worked out so I think very soon now we'll we'll be adding the ability to to just uh import a a wasm binary I think mine would be uh so this is really something that comes out of our experience with doo deploy um we're we're looking in at building uh Telemetry and observability deep into Dino

uh so that would be very easy for you to get tra traces and logs and especially like associate them with requests that come in through an HTP server um and that's really to make like operating you know a dino website much easier and also just during development that seems very useful so I think that's you know around the corner but not yet in 2 I might add interactive graphs and notebooks so imagine Brian's demo of uh penguin beaks and flap flippers uh but then you got some sliders there so we can zoom in or maybe

filter out some some of the uh data set there and I think that's also really close I love that that would be very cool amazing well thank you everybody so much for joining us uh we hope that you're super excited about doo2 and we would love to hear your thoughts so try it out let us know and uh we'll see you on