JavaScript Runtimes: Node.js, Deno, Bun

Exploring the World of JavaScript Runtimes

JavaScript runtimes have been a hot topic among developers, with multiple new entrants such as Deno and Bun. Despite the emergence of these new tools, Node.js continues to be a steadfast option. But what makes one runtime different or better than another? A significant factor is how each handles data, particularly when interfacing with the operating system.

Node.js has been around since 2009, offering a robust platform for JavaScript developers. It exposes APIs that allow developers to manage tasks efficiently. The community around Node.js has been strong, encouraging contributions and maintaining its relevance.

Newer runtimes like Deno and Bun are built with modern technologies, such as TypeScript and Rust, aiming to offer enhanced performance and developer experience. While these may use different programming languages or data handling techniques, they often share similar underlying principles.

The Magic Behind Node.js

The inner workings of Node.js reveal its reliance on tools like V8, libuv, and C++. V8 is the JavaScript engine responsible for interpreting code, while libuv handles asynchronous I/O operations. C++ acts as a bridge between JavaScript and the operating system.

Node.js cleverly injects functionality into V8, allowing it to extend JavaScript capabilities. Functions like setTimeout and setInterval, common in JavaScript development, are not native to the language but are implemented via Node.js's C++ bindings. Understanding this architecture helps demystify the power and flexibility of Node.js.

Recreating Node.js from Scratch

Rebuilding Node.js from scratch provides valuable insights into its components and architecture. This process involves compiling V8, linking libraries like libuv, and configuring C++ to handle JavaScript commands. It highlights the complexity and innovation behind Node.js's design.

By experimenting with Node.js's core, developers can appreciate the seamless experience it offers. It also sheds light on how Node.js has evolved from a proof of concept to a staple in web development. The journey involves numerous challenges, but the outcome is a deeper understanding of how JavaScript runtimes operate.

The Role of Community and Collaboration

The strength of Node.js lies not just in its technology but in its community. Collaborative efforts have driven improvements in performance and functionality. The community's willingness to share knowledge and resources ensures Node.js remains a viable option for developers.

Developers behind newer runtimes like Bun and Deno often have roots in Node.js, showcasing a spirit of collaboration rather than competition. This interconnectedness fosters innovation, allowing each runtime to learn from the others' successes and challenges.

Performance and Developer Experience

Performance is a key differentiator among JavaScript runtimes. While Bun claims to be faster due to its use of Zig, Node.js has made strides in optimizing its performance over its various iterations. The focus is not just on speed but also on providing a seamless developer experience.

Tools like TypeScript integration and built-in testing frameworks contribute to Deno's appeal. These features simplify the development process, allowing developers to focus on building applications rather than managing configurations.

The Future of JavaScript Runtimes

The landscape of JavaScript runtimes is dynamic, with each offering unique advantages. Node.js, with its rich history and community support, continues to be a reliable choice. Meanwhile, Deno and Bun bring fresh perspectives and innovations to the table.

Ultimately, the choice of runtime depends on factors like project requirements, performance needs, and developer preferences. Understanding the strengths and intricacies of each runtime empowers developers to make informed decisions and leverage the best tools for their projects.

Watch full talk with demos and examples:

Rate this content
Bookmark

From Author:

Bun, Deno, and many other JavaScript runtimes have been hype, but do you know why? Is it that easy to make a runtime from scratch?


I've been researching the secret behind Node.js' power and why there are so many new JavaScript runtimes coming up. Breaking down each key component used on Node.js I've come to interesting conclusions that many people used to say whereas in practice it works a bit differently.


In this talk, attendees will learn the concepts used to create a new JavaScript runtime. They're going to go through an example of how to make a JavaScript runtime by following what's behind the scenes on the Node.js project using C++. They'll learn the relationship between Chrome's V8 and Libuv and what makes one JavaScript runtime better than others.

This talk has been presented at JSNation 2023, check out the latest edition of this JavaScript Conference.

Watch video on a separate page

FAQ

The speaker suggests extending the V8 engine by implementing custom functions in C++ and linking them to JavaScript calls, effectively adding new functionalities like 'print' and 'setTimeout' to the V8 global context.

The speaker faced significant challenges, including the complexity of understanding and implementing the various components of Node.js, coordinating with experts, and the time-intensive nature of compiling and managing the required environments and libraries.

The speaker encourages taking pictures and mentioning the event on social media to help promote their work and extend the reach of the event, aiding in community building and recognition.

The key takeaway was the realization that Node.js extends functionalities by linking JavaScript with C++ operations, demonstrating that much of what seems complex is manageable with the right understanding and tools.

The speaker mentions an upcoming project to recreate React Native, indicating plans to explore and understand another complex framework by breaking it down into its fundamental components.

The speaker was motivated by a fear of being asked detailed questions about Node.js's inner workings at conferences and realized a gap in his knowledge. This led him to deeply explore and recreate Node.js to understand it better.

In the reconstruction of Node.js, the main components used were JavaScript for scripting, the V8 engine for JavaScript interpretation, C++ as a bridge for connecting JavaScript with the operating system, and libuv for managing event loops and asynchronous operations.

The tutorial and all related resources, including slides and links, are provided in the last slides of the presentation discussed in the talk.

Erick Wendel
Erick Wendel
28 min
01 Jun, 2023

Comments

Sign in or register to post your comment.
Video Summary and Transcription
This Talk explores the journey of learning and recreating Node.js from scratch, highlighting the main components and experimentation involved. It delves into implementing functions in V8 and setTimeout in Node.js, as well as the execution pipeline and the event loop. The collaboration between different JavaScript runtimes and the continuing evolution of Node.js are also discussed. The speaker shares their experience of exploring Node.js and writing a book, and hints at future projects involving React Native.

1. Introduction to Node.js and My Journey of Learning

Hello, everyone. We're gonna make some crazy experiments today. I tried recreating Node.js from scratch and I'm going to tell you all the step-by-step. First of all, all the slides, all the links, references and even a tutorial for you to follow after this conference I put on the last slides. Mention me, mention the event because this is how you can push our job further. Well, all this talk is about, do I really know Node.js? So I start researching a lot of things and start making questions. I've been creating a bunch of videos doing the same ideas. But this talk, I already have a tutorial there and here today I'm going to show you some highlights, and I even wrote a blog post for you later to extend.

2. Introduction to Node.js and My Journey

I'm not a C++ developer, but I'm curious and eager to learn. This research is my own, and I had to reach out to Google for help. Shout-out to Ben, Dino, Node.js, and the creators for their amazing job. They abstract the complexity, allowing us to create powerful applications. Let's do some magic!

QnA

Check out more articles and videos

We constantly think of articles and videos that might spark Git people interest / skill us up or help building a stellar career

Debugging JS
React Summit 2023React Summit 2023
24 min
Debugging JS
Top Content
Watch video: Debugging JS
Debugging JavaScript is a crucial skill that is often overlooked in the industry. It is important to understand the problem, reproduce the issue, and identify the root cause. Having a variety of debugging tools and techniques, such as console methods and graphical debuggers, is beneficial. Replay is a time-traveling debugger for JavaScript that allows users to record and inspect bugs. It works with Redux, plain React, and even minified code with the help of source maps.
A Framework for Managing Technical Debt
TechLead Conference 2023TechLead Conference 2023
35 min
A Framework for Managing Technical Debt
Top Content
Today's Talk discusses the importance of managing technical debt through refactoring practices, prioritization, and planning. Successful refactoring requires establishing guidelines, maintaining an inventory, and implementing a process. Celebrating success and ensuring resilience are key to building a strong refactoring culture. Visibility, support, and transparent communication are crucial for addressing technical debt effectively. The team's responsibilities, operating style, and availability should be transparent to product managers.
It's a Jungle Out There: What's Really Going on Inside Your Node_Modules Folder
Node Congress 2022Node Congress 2022
26 min
It's a Jungle Out There: What's Really Going on Inside Your Node_Modules Folder
Top Content
The talk discusses the importance of supply chain security in the open source ecosystem, highlighting the risks of relying on open source code without proper code review. It explores the trend of supply chain attacks and the need for a new approach to detect and block malicious dependencies. The talk also introduces Socket, a tool that assesses the security of packages and provides automation and analysis to protect against malware and supply chain attacks. It emphasizes the need to prioritize security in software development and offers insights into potential solutions such as realms and Deno's command line flags.
Building a Voice-Enabled AI Assistant With Javascript
JSNation 2023JSNation 2023
21 min
Building a Voice-Enabled AI Assistant With Javascript
Top Content
This Talk discusses building a voice-activated AI assistant using web APIs and JavaScript. It covers using the Web Speech API for speech recognition and the speech synthesis API for text to speech. The speaker demonstrates how to communicate with the Open AI API and handle the response. The Talk also explores enabling speech recognition and addressing the user. The speaker concludes by mentioning the possibility of creating a product out of the project and using Tauri for native desktop-like experiences.
A Practical Guide for Migrating to Server Components
React Advanced 2023React Advanced 2023
28 min
A Practical Guide for Migrating to Server Components
Top Content
Watch video: A Practical Guide for Migrating to Server Components
React query version five is live and we'll be discussing the migration process to server components using Next.js and React Query. The process involves planning, preparing, and setting up server components, migrating pages, adding layouts, and moving components to the server. We'll also explore the benefits of server components such as reducing JavaScript shipping, enabling powerful caching, and leveraging the features of the app router. Additionally, we'll cover topics like handling authentication, rendering in server components, and the impact on server load and costs.
Power Fixing React Performance Woes
React Advanced 2023React Advanced 2023
22 min
Power Fixing React Performance Woes
Top Content
Watch video: Power Fixing React Performance Woes
This Talk discusses various strategies to improve React performance, including lazy loading iframes, analyzing and optimizing bundles, fixing barrel exports and tree shaking, removing dead code, and caching expensive computations. The speaker shares their experience in identifying and addressing performance issues in a real-world application. They also highlight the importance of regularly auditing webpack and bundle analyzers, using tools like Knip to find unused code, and contributing improvements to open source libraries.

Workshops on related topic

Build Modern Applications Using GraphQL and Javascript
Node Congress 2024Node Congress 2024
152 min
Build Modern Applications Using GraphQL and Javascript
Featured Workshop
Emanuel Scirlet
Miguel Henriques
2 authors
Come and learn how you can supercharge your modern and secure applications using GraphQL and Javascript. In this workshop we will build a GraphQL API and we will demonstrate the benefits of the query language for APIs and what use cases that are fit for it. Basic Javascript knowledge required.
Building a Shopify App with React & Node
React Summit Remote Edition 2021React Summit Remote Edition 2021
87 min
Building a Shopify App with React & Node
Top Content
WorkshopFree
Jennifer Gray
Hanna Chen
2 authors
Shopify merchants have a diverse set of needs, and developers have a unique opportunity to meet those needs building apps. Building an app can be tough work but Shopify has created a set of tools and resources to help you build out a seamless app experience as quickly as possible. Get hands on experience building an embedded Shopify app using the Shopify App CLI, Polaris and Shopify App Bridge.We’ll show you how to create an app that accesses information from a development store and can run in your local environment.
Node.js Masterclass
Node Congress 2023Node Congress 2023
109 min
Node.js Masterclass
Top Content
Workshop
Matteo Collina
Matteo Collina
Have you ever struggled with designing and structuring your Node.js applications? Building applications that are well organised, testable and extendable is not always easy. It can often turn out to be a lot more complicated than you expect it to be. In this live event Matteo will show you how he builds Node.js applications from scratch. You’ll learn how he approaches application design, and the philosophies that he applies to create modular, maintainable and effective applications.

Level: intermediate
Build and Deploy a Backend With Fastify & Platformatic
JSNation 2023JSNation 2023
104 min
Build and Deploy a Backend With Fastify & Platformatic
WorkshopFree
Matteo Collina
Matteo Collina
Platformatic allows you to rapidly develop GraphQL and REST APIs with minimal effort. The best part is that it also allows you to unleash the full potential of Node.js and Fastify whenever you need to. You can fully customise a Platformatic application by writing your own additional features and plugins. In the workshop, we’ll cover both our Open Source modules and our Cloud offering:- Platformatic OSS (open-source software) — Tools and libraries for rapidly building robust applications with Node.js (https://oss.platformatic.dev/).- Platformatic Cloud (currently in beta) — Our hosting platform that includes features such as preview apps, built-in metrics and integration with your Git flow (https://platformatic.dev/). 
In this workshop you'll learn how to develop APIs with Fastify and deploy them to the Platformatic Cloud.
Building a Hyper Fast Web Server with Deno
JSNation Live 2021JSNation Live 2021
156 min
Building a Hyper Fast Web Server with Deno
WorkshopFree
Matt Landers
Will Johnston
2 authors
Deno 1.9 introduced a new web server API that takes advantage of Hyper, a fast and correct HTTP implementation for Rust. Using this API instead of the std/http implementation increases performance and provides support for HTTP2. In this workshop, learn how to create a web server utilizing Hyper under the hood and boost the performance for your web apps.
0 to Auth in an Hour Using NodeJS SDK
Node Congress 2023Node Congress 2023
63 min
0 to Auth in an Hour Using NodeJS SDK
WorkshopFree
Asaf Shen
Asaf Shen
Passwordless authentication may seem complex, but it is simple to add it to any app using the right tool.
We will enhance a full-stack JS application (Node.JS backend + React frontend) to authenticate users with OAuth (social login) and One Time Passwords (email), including:- User authentication - Managing user interactions, returning session / refresh JWTs- Session management and validation - Storing the session for subsequent client requests, validating / refreshing sessions
At the end of the workshop, we will also touch on another approach to code authentication using frontend Descope Flows (drag-and-drop workflows), while keeping only session validation in the backend. With this, we will also show how easy it is to enable biometrics and other passwordless authentication methods.
Table of contents- A quick intro to core authentication concepts- Coding- Why passwordless matters
Prerequisites- IDE for your choice- Node 18 or higher