Deno is a hot new runtime that may replace Node.js. Everyone’s talking about it like it’s the next big thing. It likely is. Here’s why.
What Is Deno?
From the manual:
It’s built on V8, Rust, and Tokio.
So Deno aims to take on Node.js, which would be quite the moon shot if Ryan didn’t lead it. So here’s a couple of reasons to pay attention to Deno:
- It’s created by the person who started Node.js
- It directly addresses shortcomings in Node.js
So it’s off to a good start. But let’s look at some of the technologies behind it and see if that matters.
What Powers Deno
So in the manual, it mentions V8, Rust, and Tokio. Not helpful if you don’t know what those are.
Tokio is asynchronous run-time for Rust. It’s an event-driven platform for building fast, reliable, and lightweight network applications. It’s also extremely fast and handles concurrency well.
So do you sense a pattern here? Deno is comprised of technologies that are fast, lightweight, and safe. We’re off to a great start.
So Why Something New?
According to Dahl, here are some design issues he’s found with Node.js.
- The module system and its distribution
- Legacy APIs that must be supported
- Security issues
Deno aims to address all of these issues.
If you’ve worked with Node.js for any amount of time, you know about NPM and its quirks. Personally, I think it’s not too bad. It could certainly be improved. It uses a central repository model (npmjs.com), which has had its share of issues.
Deno modules can be hosted anywhere. Also, they’re cached locally. You don’t need to update them unless you want to. Pretty sweet.
Security in Deno is integrated. It has no access to file or network resources unless explicitly enabled. It dies on uncaught errors.
TypeScript is built-in - This is purely for developers. You can take full advantage of TypeScript for development and use all those fancy explicit types and other goodness from the language.
The Biggest Upside?
Deno promises performance and safety. That’s a great benefit, but the most promise lies in the developer experience. It aims to make your life easier. Here’s how:
You can use:
- Remote repositories
Cool, those are great. But you can also:
- Test with Deno - No scrambling to find random tools or argue about what’s best, there’s a test runner built into the core.
- Format your Code - You can use “deno fmt” to format your files. This is one of the things I love about Go. Working in an opinionated environment has its downsides. It can also be a big time-saver for developers.
- Debug - Deno has built-in Debugging so again, you don’t have to go scouring the internet for the best debugger.
- Compile and Bundle - I’m told this is still not complete, but it has a pretty decent bundler, and you can expect more improvements in the future.
These are all developer-focused improvements. While people will likely be raving about the speed and security, it’s nice to know it won’t be a massive headache for developers to create applications with Deno.
Oh, and it has a single executable to run. This is promising. Anyone who has fought dependencies and breaking changes knows the feeling of having a solid executable to run. You update it when you want, and don’t have to fear what’s going on with the dependencies at the time.
Deno is going to shake things up. It’s going to bring:
- Less developer pain
There’s a lot of potential here. Deno also promises:
- Adherence to web standards
- Protection from deprecated APIs
- TypeScript included
- Built-in tooling
The future is bright for Deno, and I can’t wait to dig in and build things with it. It looks very promising.
Have you built anything with Deno? What do you think? Let me know!