Deno, Just Another JavaScript Runtime for Backend

JavaScript has come a long way since its creation. It started as a very basic language for making web pages interactive. It has become more powerful and it has been the monopoly over web development for decades. However in this blog post we won’t be talking about JavaScript’s web development capabilities.

The idea of Node.js has been an unexpected step for JavaScript, because JavaScript was tightly coupled with frontend development. Yet Node.js was allowing it to run on the server. This was a game-changer for the industry. It enabled developers to use JavaScript for both frontend and backend. However, no software is perfect including Node. Ryan Dahl (the creator of Node.js) saw some problems, and he wanted to fix these issues. Hence, he decided to create Deno. Deno is basically just another runtime for JavaScript along with Node. Its motto can be “being secure, modern, and simple.” In today’s blog post, we will explore Deno in detail. We will look at its features, how it compares to Node.js, and when you might want to use it. We will also guide you on how to get started with Deno. Finally, we will take a look at the growing Deno ecosystem.

By the way, Deno is just switching the syllables of Node.

Key Features of Deno

Security by Default

Deno is designed with “security as a priority” principle. It implements a permission system that controls access to various resources. Deno restricts access to the file system, network, and environment variables by default. When running a Deno script, you need to explicitly grant permissions to use command-line flags. For example, to allow file system access, you use the --allow-read and --allow-write flags. Similarly, network access requires the --allow-net flag, and access to environment variables requires the --allow-env flag. This system helps minimize the risk of unauthorized actions and potential security vulnerabilities in your applications.

Built-in TypeScript Support

As we all know, TypeScript is a superset of JavaScript that adds static type definitions. Deno includes native support for TypeScript, without the need for additional configuration. When you write a TypeScript file, Deno just compiles it to JavaScript before execution. This built-in support streamlines the development process, allowing you to take advantage of TypeScript’s features seamlessly. You don’t need to set up separate build tools or configuration files, making it easier to start and maintain TypeScript projects.

Simplified Module System

Deno simplifies dependency management with its URL-based module imports. Unlike Node.js (which uses a centralized package manager and a node_modules directory), Deno imports modules directly from URLs. This can include both local files and remote sources. For example, you can import a module like this:

import { serve } from "https://deno.land/std@0.95.0/http/server.ts";

This approach eliminates the need for a package manager and a node_modules directory. Dependencies are downloaded and cached locally by Deno. You can also specify exact versions in the URL, ensuring consistent behavior across different environments.

Standard Library

Deno provides a standard library that includes a collection of modules for common tasks. These modules cover various functionalities such as file system operations, HTTP servers, WebSockets, and more. The standard library is maintained by the Deno team and follows the same versioning as the runtime. This ensures compatibility and reliability. You can use these modules without needing third-party packages, reducing dependency management overhead. For example, creating an HTTP server using the standard library is straightforward:

import { serve } from "https://deno.land/std@0.95.0/http/server.ts";

const server = serve({ port: 8000 });
for await (const req of server) {
  req.respond({ body: "Hello, Deno!" });
}

Modern API

Deno embraces modern JavaScript features and best practices. It supports ES modules, which are the official standard for JavaScript module syntax. This is in contrast to Node.js’s CommonJS module system. Deno also fully supports async and await, making asynchronous programming more straightforward and readable. Additionally, Deno includes features like top-level await, which allows you to use await without needing an async function wrapper. This makes writing asynchronous code more natural. Here is an example of using ES modules and async/await in Deno:

import { readJson } from "https://deno.land/std@0.95.0/fs/read_json.ts";

async function readConfig() {
  const config = await readJson("./config.json");
  console.log(config);
}

await readConfig();

Comparison with Node.js

Security Model

Node.js and Deno have different approaches to security. Node.js follows an open-by-default model. This means that Node.js applications have full access to the file system, network, and environment variables without any restrictions. While this provides flexibility, it can also lead to security vulnerabilities if not carefully managed.

Deno adopts a secure-by-default approach. By default, Deno scripts do not have access to the file system, network, or environment variables. Permissions must be explicitly granted using command-line flags. For example, to allow a Deno script to read files, you need to use the --allow-read flag. This model helps to mitigate security risks by restricting access to sensitive resources unless explicitly allowed by the developer.

Module System

The module systems in Node.js and Deno are fundamentally different. Node.js uses npm (Node Package Manager) and a node_modules directory to manage dependencies. Modules are installed locally and managed through the package.json file. This centralized system allows for easy sharing and reuse of packages but can lead to large dependency trees and version conflicts.

Deno, on the other hand, uses URL-based imports for modules. Instead of relying on a package manager, Deno imports modules directly from URLs. These URLs can be either local paths or remote ones. This method eliminates the need for a node_modules directory and a package manager like npm. On the other hand, companies having limited access needs to cache these packages loacally. Dependencies are downloaded and cached locally by Deno, and you can specify exact versions in the URLs to ensure consistency. For example:

import { serve } from "https://deno.land/std@0.95.0/http/server.ts";

This approach simplifies dependency management and ensures that modules are always up-to-date and consistent across different environments.

TypeScript Support

In Node.js, using TypeScript requires additional setup. Developers need to install TypeScript and configure a build process to compile TypeScript code to JavaScript. This typically involves setting up configuration files like tsconfig.json and using tools like tsc (TypeScript compiler) or Babel.

Deno offers built-in support for TypeScript without any extra configuration. You can write TypeScript code directly, and Deno will automatically compile it to JavaScript during execution. This seamless integration makes it easier to start and maintain TypeScript projects, as there is no need for separate build tools or configuration files. This built-in support simplifies the development process and reduces the setup time for TypeScript projects.

Community and Ecosystem

Node.js has been around since 2009 and has built a large and mature ecosystem. It has a vast collection of libraries and frameworks available through npm. The community is extensive, with numerous resources, tutorials, and support available online. This maturity and breadth make it easy to find solutions and tools for almost any development need.

Deno, introduced in 2018, is relatively new compared to Node.js. Its ecosystem is still growing. While the Deno standard library provides many essential modules, it does not yet match the extensive library of packages available in the Node.js ecosystem. However, the Deno community is active and expanding, with more libraries and tools being developed. Deno’s package repository, deno.land/x, hosts third-party modules, and the ecosystem is steadily evolving.

Deno’s Ecosystem

Deno has a growing collection of third-party modules. These modules are available through the Deno third-party module repository https://deno.land/x. This repository hosts a variety of modules that can be used to extend the functionality of your Deno applications. You can find modules for web frameworks, database clients, utilities, and more.

Modules in deno.land/x are versioned and immutable. This means once a module version is published, it cannot be changed. This ensures stability and reliability, as you can be confident that the module code will not change unexpectedly. To use a third-party module, you simply import it using a URL, specifying the version you want to use. For example:

import { Application } from "https://deno.land/x/oak@v6.0.1/mod.ts";

The Deno GitHub repository (https://github.com/denoland/deno) is open to contributions, and there are many other Deno-related projects you can get involved with.

Challenges and Limitations of Deno

Smaller Ecosystem
Compared to Node.js, which has a mature and extensive library of packages available through npm, Deno’s ecosystem is still in its infancy. While the Deno standard library and third-party repository (deno.land/x) are growing, they cannot match the number of tools and libraries in the Node.js ecosystem.

Compatibility Issues
Many popular Node.js packages are not directly compatible with Deno. While some can be adapted using tools like deno2node, this may introduce additional complexity.

Steeper Learning Curve for Node.js Developers
Developers transitioning from Node.js to Deno may find its different module system and security model challenging at first. Adjusting to URL-based imports and explicitly granting permissions can require a shift in mindset.

Limited Adoption and Community Support
As a newer runtime, Deno has a smaller user base and less community support compared to Node.js. This can make it harder to find tutorials, documentation, and solutions to specific problems.

Corporate Backing and Stability
Node.js benefits from strong corporate backing and widespread industry use. Deno, while promising, lacks the same level of enterprise adoption, which may make some businesses hesitant to adopt it for mission-critical projects.

Conclusion

To sum up, I am not expecting much from Deno at the moment. On the other hand, I cannot will be keeping an eye on it since Deno addresses many of the challenges encountered in Node.js. With its secure-by-default design, default TypeScript support, simplified module system, and modern API, Deno offers a fresh approach for developers seeking a streamlined and secure development experience. While its ecosystem is still tiny compared to Node, its innovative features make it a compelling choice for some projects where security, modern tooling, and simplicity are priorities. As the Deno community and ecosystem continue to grow, it has the potential to gain a ground in the world of backend development for JavaScript. Regardless of you liked it or not, Deno is certainly worth exploring.

Suleyman C. Ataman, PhD

Sharing on social media: