The Future of JavaScript Runtimes

Rate this content
Bookmark

JavaScript was born in the browser, Node brought it to the server embracing unix primitives and async I/O and lately Cloudflare Workers & Deno Deploy have brought it to the edge. Let’s take a look at where JavaScript runtimes are heading and how it will shape the software we write.

This talk has been presented at Node Congress 2022, check out the latest edition of this JavaScript Conference.

FAQ

Aron's talk at Node-Congress focuses on the future of JavaScript runtimes, examining how they have evolved and how they might continue to evolve over the next decade, specifically in CLI and cloud contexts.

JavaScript runtimes have evolved from being primarily used in browsers to being utilized in servers, with significant advancements in performance and capabilities, exemplified by the development of Node.js and the introduction of V8 by Google.

Future JavaScript runtimes are expected to have new capabilities and use cases such as enhanced cloud integration, better ergonomics and primitives, and a shift towards more web-standard APIs, which will impact how software is built, deployed, and used.

Deno is a JavaScript and TypeScript runtime built on Rust, which Aron is involved with. He discusses its approach to using web-standard APIs and how it represents a shift in designing JavaScript runtimes.

Aron notes that TypeScript has become a dominant dialect for new JavaScript applications, highlighting its widespread adoption and potential future integration directly into JavaScript engines, which might allow them to execute TypeScript untransformed.

Aron predicts a shift towards using more modern languages like Rust to build JavaScript runtime technology, enhancing safety and development speed. He also discusses the alignment of Node.js with web-standard APIs like Fetch and ECMAScript modules.

Aron envisions JavaScript playing a significant role in the future of cloud computing, particularly through 'isolates' which could offer highly efficient, lightweight execution environments ideal for JavaScript applications in the cloud.

Aron suggests that JavaScript runtimes like Deno and Node might converge or one may eventually replace the other, emphasizing the need for standardization in APIs and possibly a shared standard library to reduce fragmentation.

Aaron O'Mullan
Aaron O'Mullan
34 min
17 Feb, 2022

Comments

Sign in or register to post your comment.
Video Summary and Transcription
Today's Talk explores the future of JavaScript runtimes, their evolution, and impact on software development. It discusses the historical trends of JavaScript, the adoption of new tools and libraries, and the convergence of Node and Deno. The emergence of isolate clouds and their potential to replace traditional VMs and containers is also highlighted. Additionally, the talk touches on the possibilities of JavaScript in exotic use cases, its impact on machine learning, and the potential for TypeScript to become the de facto language for JavaScript development.

1. Introduction to JavaScript Runtimes

Short description:

Today, I'm going to talk about the future of JavaScript runtimes, how they have evolved, and how they will shape the runtimes of tomorrow. It's an interesting exercise to explore the possibilities and open up a conversation about innovation and progress in JavaScript.

Hi everyone, my name is Aron and I'd like to thank you for joining me at Node-Congress. Today I'm going to talk about the future of JavaScript runtimes. We're going to look at how JavaScript runtimes have evolved from browsers to servers and how Node and other technologies have evolved over the past decade and how that will shape the runtimes of tomorrow, the ones we'll use in 10 years. I think it's an interesting exercise. Obviously neither me nor others can truly predict the future, but the interesting thing is, since some of us work on runtimes, we have the ability to impact it. And so I think with this talk, I want to open up that conversation, get the conversation started, and basically hear other thoughts because I think there is a lot of room to innovate and there's still a lot of room for JavaScript to progress.

2. JavaScript Runtimes: Trends and Evolution

Short description:

Today, we'll explore what JavaScript runtimes will look like in the future, their new capabilities, use cases, primitives, and ergonomics, and how they will impact software development and deployment. I'll provide my personal views as someone new to working on JavaScript runtimes, with a focus on the CLI and cloud. We'll also discuss the historical trends of JavaScript, including the creation of JavaScript in 1995, the introduction of V8 and Chrome in 2008, and the impact of Node in 2009. Another significant event was the release of TypeScript in 2012, which is now widely used. These trends give us insights into the evolution of JavaScript in the coming decade.

So let's jump in. So I think, as I mentioned there, we'll look at what will runtimes look like in 2025, 2030, what new capabilities will these runtimes have, what new use cases will they enable, what kind of primitives will they have, what kind of ergonomics will they have, how will that impact the software we build and write or how we deploy software, how we use it. I think there's a lot of different angles that we'll look at as we step through this.

And so a quick disclaimer is obviously I work at Deno, so I'm slightly biased. I like Deno, obviously. But I would say these are mostly my personal views. I've been working full-time on JavaScript runtimes for less than six months. There's people on my team at Deno or even at NodeCongress today who have years or decades of experience building runtimes. So I'm quite new to this. And then also, of course, my talk won't be and can be exhaustive. I'm mainly going to be focusing on the CLI and cloud side of things, obviously browsers and desktop and mobile are huge trends and huge facets of JavaScript. But that won't be the focus of today's talk.

So anyway, let's jump right in. So, you know, first let's take a look at the historical trends and how JavaScript has evolved. And that will inform a little bit how it might evolve in the coming decade. So let's take a quick look at the timeline. So JavaScript was first created by Brennan Eich in 1995 in 10 days, which is pretty extraordinary. Obviously, there came some trade-offs. And, you know, JavaScript continued to exist in browsers. And it was only up until kind of 2008 when Google shipped V8 and Chrome, that web applications really became a thing, because V8 radically changed the performance of JavaScript runtimes and really enabled kind of modern JavaScript heavy applications that weren't really possible before.

And then, you know, only less than, you know, less than nine months later, Brian then built and shipped the first version of Node in 2009. And that's, I think that's, you know, Node's impact is not to be understated. We're obviously all here because of Node. You know, Node has enabled us to build server-side applications in JavaScript, and it's also enabled a ton of tooling on the front end side, et cetera. So I think that's quite impactful. Obviously this timeline is not exhaustive. There's other key events, but once again, I'm trying to stick to the points that I think are relevant.

And then I think, you know, another key event in the timeline is Microsoft shipping TypeScript in October 2012. And so it takes some time for TypeScript adoption to grow, but you know, I think today we're starting to see the TypeScript is maybe one of the dominant forms or dialects of JavaScript that teams are using to build new applications. So, you know, looking back at 2010, you know, we can see a few key trends, such as front end.

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

Scaling Up with Remix and Micro Frontends
Remix Conf Europe 2022Remix Conf Europe 2022
23 min
Scaling Up with Remix and Micro Frontends
Top Content
This talk discusses the usage of Microfrontends in Remix and introduces the Tiny Frontend library. Kazoo, a used car buying platform, follows a domain-driven design approach and encountered issues with granular slicing. Tiny Frontend aims to solve the slicing problem and promotes type safety and compatibility of shared dependencies. The speaker demonstrates how Tiny Frontend works with server-side rendering and how Remix can consume and update components without redeploying the app. The talk also explores the usage of micro frontends and the future support for Webpack Module Federation in Remix.
Full Stack Components
Remix Conf Europe 2022Remix Conf Europe 2022
37 min
Full Stack Components
Top Content
RemixConf EU discussed full stack components and their benefits, such as marrying the backend and UI in the same file. The talk demonstrated the implementation of a combo box with search functionality using Remix and the Downshift library. It also highlighted the ease of creating resource routes in Remix and the importance of code organization and maintainability in full stack components. The speaker expressed gratitude towards the audience and discussed the future of Remix, including its acquisition by Shopify and the potential for collaboration with Hydrogen.
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.
Making JavaScript on WebAssembly Fast
JSNation Live 2021JSNation Live 2021
29 min
Making JavaScript on WebAssembly Fast
Top Content
WebAssembly enables optimizing JavaScript performance for different environments by deploying the JavaScript engine as a portable WebAssembly module. By making JavaScript on WebAssembly fast, instances can be created for each request, reducing latency and security risks. Initialization and runtime phases can be improved with tools like Wiser and snapshotting, resulting in faster startup times. Optimizing JavaScript performance in WebAssembly can be achieved through techniques like ahead-of-time compilation and inline caching. WebAssembly usage is growing outside the web, offering benefits like isolation and portability. Build sizes and snapshotting in WebAssembly depend on the application, and more information can be found on the Mozilla Hacks website and Bike Reliance site.
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.
Webpack in 5 Years?
JSNation 2022JSNation 2022
26 min
Webpack in 5 Years?
Top Content
In the last 10 years, Webpack has shaped the way we develop web applications by introducing code splitting, co-locating style sheets and assets with JavaScript modules, and enabling bundling for server-side processing. Webpack's flexibility and large plugin system have also contributed to innovation in the ecosystem. The initial configuration for Webpack can be overwhelming, but it is necessary due to the complexity of modern web applications. In larger scale applications, there are performance problems in Webpack due to issues with garbage collection, leveraging multiple CPUs, and architectural limitations. Fixing problems in Webpack has trade-offs, but a rewrite could optimize architecture and fix performance issues.

Workshops on related topic

Master JavaScript Patterns
JSNation 2024JSNation 2024
145 min
Master JavaScript Patterns
Top Content
Featured Workshop
Adrian Hajdin
Adrian Hajdin
During this workshop, participants will review the essential JavaScript patterns that every developer should know. Through hands-on exercises, real-world examples, and interactive discussions, attendees will deepen their understanding of best practices for organizing code, solving common challenges, and designing scalable architectures. By the end of the workshop, participants will gain newfound confidence in their ability to write high-quality JavaScript code that stands the test of time.
Points Covered:
1. Introduction to JavaScript Patterns2. Foundational Patterns3. Object Creation Patterns4. Behavioral Patterns5. Architectural Patterns6. Hands-On Exercises and Case Studies
How It Will Help Developers:
- Gain a deep understanding of JavaScript patterns and their applications in real-world scenarios- Learn best practices for organizing code, solving common challenges, and designing scalable architectures- Enhance problem-solving skills and code readability- Improve collaboration and communication within development teams- Accelerate career growth and opportunities for advancement in the software industry
Integrating LangChain with JavaScript for Web Developers
React Summit 2024React Summit 2024
92 min
Integrating LangChain with JavaScript for Web Developers
Featured Workshop
Vivek Nayyar
Vivek Nayyar
Dive into the world of AI with our interactive workshop designed specifically for web developers. "Hands-On AI: Integrating LangChain with JavaScript for Web Developers" offers a unique opportunity to bridge the gap between AI and web development. Despite the prominence of Python in AI development, the vast potential of JavaScript remains largely untapped. This workshop aims to change that.Throughout this hands-on session, participants will learn how to leverage LangChain—a tool designed to make large language models more accessible and useful—to build dynamic AI agents directly within JavaScript environments. This approach opens up new possibilities for enhancing web applications with intelligent features, from automated customer support to content generation and beyond.We'll start with the basics of LangChain and AI models, ensuring a solid foundation even for those new to AI. From there, we'll dive into practical exercises that demonstrate how to integrate these technologies into real-world JavaScript projects. Participants will work through examples, facing and overcoming the challenges of making AI work seamlessly on the web.This workshop is more than just a learning experience; it's a chance to be at the forefront of an emerging field. By the end, attendees will not only have gained valuable skills but also created AI-enhanced features they can take back to their projects or workplaces.Whether you're a seasoned web developer curious about AI or looking to expand your skillset into new and exciting areas, "Hands-On AI: Integrating LangChain with JavaScript for Web Developers" is your gateway to the future of web development. Join us to unlock the potential of AI in your web projects, making them smarter, more interactive, and more engaging for users.
Using CodeMirror to Build a JavaScript Editor with Linting and AutoComplete
React Day Berlin 2022React Day Berlin 2022
86 min
Using CodeMirror to Build a JavaScript Editor with Linting and AutoComplete
Top Content
WorkshopFree
Hussien Khayoon
Kahvi Patel
2 authors
Using a library might seem easy at first glance, but how do you choose the right library? How do you upgrade an existing one? And how do you wade through the documentation to find what you want?
In this workshop, we’ll discuss all these finer points while going through a general example of building a code editor using CodeMirror in React. All while sharing some of the nuances our team learned about using this library and some problems we encountered.
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
Testing Web Applications Using Cypress
TestJS Summit - January, 2021TestJS Summit - January, 2021
173 min
Testing Web Applications Using Cypress
Top Content
WorkshopFree
Gleb Bahmutov
Gleb Bahmutov
This workshop will teach you the basics of writing useful end-to-end tests using Cypress Test Runner.
We will cover writing tests, covering every application feature, structuring tests, intercepting network requests, and setting up the backend data.
Anyone who knows JavaScript programming language and has NPM installed would be able to follow along.
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.