deno

Deno

Return to JSR, Deno Glossary, Node.js Glossary, NPM Glossary, Deno Glossary, JavaScript Glossary, TypeScript Glossary, Docker Glossary, Podman Glossary, Containerization Glossary, Kubernetes Glossary, OpenShift Glossary, Rancher Glossary, DevOps Glossary, DevSecOps Glossary, Git Glossary, GitHub Glossary, GitOps Glossary, IaC Glossary, Terraform Glossary, Ansible Glossary, Virtualization Glossary, Cloud Native Glossary, Microservices Glossary, Cloud Computing Glossary, AWS Glossary, Azure Glossary, GCP Glossary, IBM Cloud Glossary, Oracle Cloud Glossary

https://www.youtube.com/watch?v=H8VLifMOBHU

Ryan Dahl introduces Deno 2

https://www.youtube.com/watch?v=2x2eIhn2BJM

Creator of Node talks Deno 2.0 and the Future of JS

Announcing Deno 2

https://deno.com/blog/v2.0

The web is humanity’s largest software platform — building for it means potentially reaching over 5 billion people. But as web development has accelerated in recent years, it has also become increasingly and unmanageably complex. Before writing a single line of code, developers must deal with tedious configuration and wading through unnecessary boilerplate, when they would rather focus on shipping product and delivering value to users.

Yet despite these complexities, JavaScript, the language of the web, has remained the most popular language for the past decade, with TypeScript quickly emerging as number three. This is a testament to JavaScript’s ubiquity and usefulness for web development — and a sign that JavaScript is not going anywhere.

In an effort to simplify web programming, we created Deno: a modern, all-in-one, zero-config toolchain for JavaScript and TypeScript development.

Native TypeScript support Built on web standards: Promises, fetch, and ES Modules Batteries included: builtin formatter, linter, type checker, test framework, compile to executable, and more Secure by default, just like browsers Today, hundreds of thousands of developers love using Deno, with repository becoming one of the highest starred Rust project on GitHub second only to the Rust language itself.

While we’ve accomplished a ton in Deno 1, the next major version is focused on using Deno at scale. This means seamless interoperability with legacy JavaScript infrastructure and support for a wider range of projects and development teams. All without sacrificing the simplicity, security, and “batteries included” nature that Deno users love.

Today, we’re thrilled to announce Deno 2, which includes:

Backwards compatibility with Node.js and npm, allowing you to run existing Node applications seamlessly Native support for package.json and node_modules Package management with new deno install, deno add, and deno remove commands A stabilized standard library Support for private npm registries Workspaces and monorepo support Long Term Support (LTS) releases JSR: a modern registry for sharing JavaScript libraries across runtimes We are also continually improving many existing Deno features:

deno fmt can now format HTML, CSS, and YAML deno lint now has Node specific rules and quick fixes deno test now supports running tests written using node:test deno task can now run package.json scripts deno doc’s HTML output has improved design and better search deno compile now supports code signing and icons on Windows deno serve can run HTTP servers across multiple cores, in parallel deno init can now scaffold libraries or servers deno jupyter now supports outputting images, graphs, and HTML deno bench supports critical sections for more precise measurements deno coverage can now output reports in HTML Backwards-compatible, forward-thinking Deno 2 is backwards compatible with Node and npm. This allows you to not only run Deno in your current Node projects, but also incrementally adopt pieces of Deno’s all-in-one toolchain. For instance, you can use deno install after you clone a Node project to install your dependencies at lightning speed or run deno fmt to format your code without needing Prettier.

Deno 2’s compatibility with Node and npm is robust. Deno 2 understands package.json , the node_modules folder, and even npm workspaces, allowing you to run Deno in any Node project using ESM. And if there are minor syntax adjustments needed, you can fix them with deno lint –fix.

Don’t like the clutter of package.json and the node_modules directory, but still need to use that npm package? You can directly import npm packages using npm: specifiers. Without package.json and the node_modules folder, Deno will install your package in the global cache. This allows you to write programs with npm dependencies in a single file — no dependency manifest, configuration files, or node_modules needed.

import chalk from “npm:chalk@5.3.0”;

console.log(chalk.blue(“Hello, world!”)); // Hello, world! (in blue) For larger projects, a dependency manifest makes it simple to manage your dependencies. Placing an npm: specifier into an import map in a deno.json file allows importing the bare name of the package:

// deno.json {

 "imports": {
   "chalk": "npm:chalk@5.3.0"
 }

} import chalk from “chalk”;

console.log(chalk.blue(“Hello, world!”)); // Hello, world! (in blue) With the ability to import npm packages via the npm: specifier, you can access over 2 million npm modules in Deno. This even includes complex packages such as gRPC, ssh2, Prisma, temporal.io, duckdb, polars. Deno even supports advanced features like Node-API native addons.

Finally, you can use Deno 2 with your favorite JavaScript framework. Deno 2 supports Next.js, Astro, Remix, Angular, SvelteKit, QwikCity and many other frameworks.

Running create-next-app with Deno. Deno is now a package manager with deno install Not only does Deno 2 support package.json and the node_modules folder, it also comes with three important subcommands that allow you to easily install and manage your dependencies.

deno install installs your dependencies at lightning speed. If you have a package.json it will create a node_modules folder in the blink of an eye. If you don’t use package.json, it will cache all of your dependencies to the global cache.

deno install is 15% faster than npm with a cold cache, and 90% faster with a hot cache. We’re already exceptionally fast here, but expect more improvements, especially in cold cache scenarios, in the coming weeks.

Package install timings

deno add and deno remove can be used to add and remove packages to/from your package.json or deno.json. If you’ve used npm install or npm remove before, these will feel very familiar.

deno add demo 1

deno add demo 2

JavaScript Registry Earlier this year we introduced a modern, open sourced JavaScript registry called JSR.

It supports TypeScript natively (you can publish modules as TypeScript source code), handles the module loading intricacies multiple runtimes and environments, only allows ESM, auto-generates documentation from JSDoc-style comments, and can be used with npm- and npx-like systems (yes, JSR turns TypeScript into .js and .d.ts files, as well).

Because you upload TypeScript to JSR, it has an outstanding understanding of the code that is being published. This allows us to deliver a seamless developer experience for both publishing and consuming modules. If you are interested in the details, you can read our post on how we architected JSR.

Here is a side-by-side video of publishing a package to npm vs. to JSR. The Standard Library is now stable While there are over 2 million modules available on npm, the process of searching, evaluating, and using a new module can be time consuming. That’s why we’ve been building the Deno Standard Library for over 4 years.

The Standard Library consists of dozens of heavily audited utility modules covering everything from data manipulation, web-related logic, JavaScript-specific functionalities, and more. It is available on JSR, and can be used by other runtimes and environments.

To give you a sense of what kinds of modules are available in the Deno Standard Library, here is a partial list of the Standard Library modules and their equivalent in npm:

Deno Standard Library module npm package @std/testing jest @std/expect chai @std/cli minimist @std/collections lodash @std/fmt chalk @std/net get-port @std/encoding rfc4648 For a complete list of available packages visit https://jsr.io/@std.

Introduction to Deno

Deno is a secure runtime for JavaScript and TypeScript, created by Ryan Dahl, the original creator of Node.js. It aims to address some of Node.js's shortcomings, particularly around security, module management, and build system.

Deno's GitHub Repository

The source code for Deno is hosted on GitHub, inviting contributions from developers worldwide: s://github.com/denoland/deno(https://github.com/denoland/deno).

Official Documentation

Deno's official documentation offers comprehensive information on getting started, examples, standard library usage, and API references: s://deno.land/manual(https://deno.land/manual).

Official Website

For more insights into Deno, including installation instructions, tutorials, and the standard library, visit the official website: s://deno.land/(https://deno.land/).

Wikipedia on Deno

Wikipedia provides an overview of Deno, detailing its creation, features, and comparisons with Node.js: [Deno - Wikipedia](https://en.wikipedia.org/wiki/Deno_(software)).

Main Features of Deno

1. **Security**: Deno is secure by default, requiring explicit permissions for file, network, and environment access. 2. **Supports TypeScript**: Deno supports TypeScript out of the box, without the need for additional tooling. 3. **Standard Library**: Deno provides a comprehensive standard library that is audited and curated by the Deno team. 4. **Module System**: Deno uses URLs for importing modules, eliminating the need for a package manager. 5. **Modern JavaScript**: Deno is built on modern JavaScript features, providing a future-proof runtime environment.

Code Example 1: Hello World

```typescript console.log(“Hello Deno!”); ```

Code Example 2: HTTP Server

```typescript import { serve } from “https://deno.land/std/http/server.ts”; const server = serve({ port: 8000 }); console.log(“http://localhost:8000/”); for await (const req of server) {

 req.respond({ body: "Hello Deno\n" });

} ```

Code Example 3: Reading a File

```typescript const decoder = new TextDecoder(“utf-8”); const data = await Deno.readFile(“hello.txt”); console.log(decoder.decode(data)); ```

Code Example 4: Writing to a File

```typescript const encoder = new TextEncoder(); const data = encoder.encode(“Hello Deno”); await Deno.writeFile(“hello.txt”, data); ```

Code Example 5: Fetch API

```typescript const response = await fetch(“https://deno.land/”); const body = await response.text(); console.log(body); ```

Code Example 6: Importing Modules

```typescript import { assertEquals } from “https://deno.land/std/testing/asserts.ts”; assertEquals(“hello”, “hello”); ```

Code Example 7: Environment Variables

```typescript console.log(Deno.env.get(“HOME”)); ```

Code Example 8: Permissions API

```typescript const status = await Deno.permissions.request({ name: “read”, path: “/var” }); console.log(status.state); ```

Popular Third-Party Libraries

As Deno encourages the use of standard modules, it has fewer third-party libraries compared to Node.js. However, the Deno community is growing, and libraries are emerging across various categories, accessible through [Deno's Third-Party Modules](https://deno.land/x).

Competition or Alternatives

Deno primarily competes with Node.js as a JavaScript runtime. However, it also complements other server-side technologies and frameworks by offering a modern, secure, and easy-to-use platform for JavaScript and TypeScript development.

This summary highlights Deno's approach to creating a secure and modern JavaScript runtime environment. Deno's design principles, embracing security, simplicity, and modern JavaScript features, make it an intriguing alternative in the server-side JavaScript landscape.

Snippet from Wikipedia: Deno (software): Deno () is a runtime for JavaScript, TypeScript, and WebAssembly that is based on the V8 JavaScript engine and the Rust programming language. Deno was co-created by Ryan Dahl, the creator of Node.js and Bert Belder.
Deno explicitly takes on the role of both runtime and package manager within a single executable, rather than requiring a separate package-management program.

Creative Commons Attribution-Share Alike 4.0