Why Node.js is Written in C and C++

Node.js has become a dominant platform for networked services and web applications due to its unique architecture that facilitates high throughput and scalability. This architecture is enabled by Node.js being written in the lower level languages C and C++ rather than the JavaScript it exposes to developers.

In this comprehensive technical deep dive, we will analyze the specific benefits of using C and C++ and how they unlocked Node.js to achieve levels of performance not possible in languages like JavaScript alone.

Brief Background on Node.js

Node.js provides a JavaScript execution context outside of the browser powered by the Google V8 engine. This engine compiles JavaScript to optimized machine code before execution by leveraging just-in-time (JIT) compilation techniques.

The key innovation of Node.js was taking this V8 engine and embedding it into an event loop managed by a C++ program. This event loop leverages non-blocking I/O provided by the libuv C library to enable handling thousands of concurrent connections with a single thread.

Here is a quick overview of the key components of Node.js and why C or C++ was chosen for each:

V8 JavaScript Engine

• Compiles and optimizes JS to machine code
• Written in C++ for maximum performance
• Provides access to low level memory management

libuv Library

• Asynchronous event loop and thread pool
• Abstracts non-blocking I/O operations
• Written in C for cross platform support

Node.js Core

• Initializes V8 and connects it to libuv
• Manages addon loading and more
• C++ ties everything together

Next we will do a deep dive on the specific advantages this architecture provides by leveraging C and C++.

Benefits of Using C and C++

There are several areas where using lower level system programming languages unlocked major benefits for Node.js:

1. Near-Native JavaScript Performance

The V8 JavaScript engine was designed from the ground up to provide near-native execution speeds for JS code. It does this by:

• Dynamic machine code generation using just-in-time (JIT) compilation to avoid interpretation
• Advanced optimization techniques like inline caching and assumption tracking
• Efficient garbage collection mechanisms and memory management

These techniques were facilitated by leveraging C++ rather than trying to build this solely in JavaScript. C++ gave V8 engineers fine grained control over memory layouts, direct access to CPU instruction pipelining, and ability to integrate with profiling tools.

The results speak for themselves, with Node.js only 2x slower than compiled languages versus >10x in classic JS engines:

So by using C++ for the V8 engine core, JS execution in Node.js can rival speeds of lower level languages.

2. Asynchronous I/O and Events

Node‘s architecture revolves around its asynchronous, single-threaded event loop. Here is where the libuv C library comes into play by providing abstractions for non-blocking I/O operations.

Libuv handles details like:

• Thread pool management
• Asynchronous TCP/DNS requests
• File system events
• Child process handling
• Asynchronous completion callbacks

Embedding this C library allows Node.js‘ JavaScript layer to issue non-blocking requests without worrying about low level details. It also prevents locking up due to synchronous I/O.

This event based I/O model maps very well to JavaScript callbacks. But relying on JavaScript alone for I/O handling would be inefficient. Libuv offers highly optimized event notification by leveraging the underlying operating system rather than reimplementing system calls from scratch.

3. Cross Platform Abstraction

Consistent behavior across operating systems is critical for a server side runtime like Node.js seeing widespread adoption. Dealing with platform differences could result in a lot of extra development overhead.

The libuv library provides an abstraction layer in C that hides systems level differences between Windows, Linux, and macOS. This prevents platform specific code from leaking into Node.js core while enabling it to run on any modern OS.

4. Interfacing with Peripherals

With C and C++, Node.js can directly access devices and hardware peripherals at a low level. This facilitates using Node.js for Internet of Things (IoT) applications by hooking into external sensors or devices.

Doing this from JavaScript alone requires intermediate native binaries. Leveraging C/C++ allows tighter control for industrial automation, robotics, health monitors, and other connected devices using Node.js.

5. Leveraging Existing C/C++ Libraries

Node.js offers native bindings to 1000s of existing battle hardened C/C++ libraries like OpenSSL, cURL, and BerkeleyDB. This allows Node.js to focus on its own advancements rather than rebuilding existing technology stacks.

Access to these robust and highly optimized C libraries is a huge advantage. Node.js gets improved security due to leveraging OpenSSL rather than creating their own crypto for example.

When is JavaScript Used in Node.js

While C/C++ may dominate the lower layers, the user still interacts solely with JavaScript in Node.js:

const http = require(‘http‘);

http.createServer((req, res) => {
  // app logic here  
})

The fact Node.js relies on C++ is an implementation detail abstracted away from developers. When building an application, JavaScript is used for:

• All Node.js API methods like the http module above
• Custom application code inside .js files
• Non-blocking callbacks for event handlers
• Business logic and data access layers
• Configuring middleware, routers, and templates

So from an app developer perspective, you mainly need to focus on writing JavaScript while Node handles runtime management behind the scenes.

Leveraging C++ Where Performance Matters

As we‘ve covered, JavaScript is perfect for handling evented application logic and business rules in Node.js. But occasionally performance constraints require dropping to a lower level language.

This is where Node.js C++ addons come into play – modules extending functionality by delegating work to C or C++:

// cpp_addon.cc  

#include <node.h>

namespace demo {

using v8::FunctionCallbackInfo;
using v8::Isolate;
using v8::Local;
using v8::Object;
using v8::Value;

void Add(const FunctionCallbackInfo<Value>& args) {
  Isolate* isolate = args.GetIsolate();
  Local<Object> obj = args[0]->ToObject(isolate);

  double x = obj->Get(String::NewFromUtf8(isolate, "x").ToLocalChecked())
               ->NumberValue(isolate);

  double y = obj->Get(String::NewFromUtf8(isolate, "y").ToLocalChecked())
               ->NumberValue(isolate);

  double sum = x + y;

  args.GetReturnValue().Set(sum);  
}

void Init(Local<Object> exports) {
  NODE_SET_METHOD(exports, "add", Add);
}

NODE_MODULE(NODE_GYP_MODULE_NAME, Init)

}  // namespace demo

This addon can perform operations difficult in pure JavaScript (e.g. matrix math), interface with an existing C library, or improve throughput for a CPU intensive hot path.

So while Node itself relies on C++, it offers a JavaScript friendly method to access lower level languages when required. This gives developers the best of both worlds.

The Impact of Node.js Architecture Choices

The design decisions made in utilizing C++ rather than purely higher level scripts has clearly paid dividends for Node.js:

• Node.js dominates the web landscape powering sites like Netflix, Uber, Reddit
• Major growth in backends, microservices, APIs and web sockets
• Top adoption for cloud native deployments using containers
• JavaScript usage greatly expanding on serverside

Its architecture facilitated this rise to prominence:

• High throughput via non-blocking I/O model
• Efficient use of modern multicore systems
• Package ecosystem seeing expansive growth

All of this success may not have been possible without the performance, modularity, and component leverage that lower level languages like C/C++ unlocked.

How Other JavaScript Runtimes Compare

Given the dominance of Node.js, other attempts have been made at JavaScript runtimes trying to fix perceived flaws or issues. A few examples include:

Deno – Created by Node co-founder Ryan Dahl, leverages Rust instead of C++. Focused on browser compatibility and TypeScript. But has not seen enterprise adoption due to ecosystem issues.

QuickJS – Very lightweight embeddable JS engine aiming for simplicity over speed. Lacks compatibility with NPM.

MuJS – Another minimal JS interpreter optimize for embeddability. But no JIT compilation limits performance.

V8 Isolates – Emerging model for multi-tenancy by isolating V8 contexts. Reduces overhead of multiple processes.

The continued reliance on C++ and growth of Node.js shows that while alternatives exist, they have struggled to match the raw performance and ecosystem breadth already established.

However, incorporating ideas like isolate contexts could allow Node to evolve without fully abandoning its C++ foundations.

The Rise of Modern C++

Node‘s usage of C++ dates back over a decade ago to its inception. But C++ itself has continued rapidly evolving:

• Memory safety mechanisms like strict aliasing and sanitizers
• Async/await support removing callback hell
• Zero cost abstractions and metaprogramming
• Reflection and introspection improvements

These modern C++ advancements have also benefited Node.js. Support for top level await makes callback chains less painful. Smart pointers prevent entire classes of memory issues.

As C++ standardization continues, we may see increased leverage by Node.js through interfaces like V8 or native addons.

Already we see signs of a C++ renaissance for systems programming due to these improvements over its history. The performance advantages overcoming prior complaints around complexity or safety.

Conclusion

Node.js represents a unique bridge between the accessibility of JavaScript and low level control and performance of system languages like C++. This fusion unlocked the ability for JavaScript to expand outside the browser and become ubiquitous across today‘s web infrastructure.

While alternatives exist, none have replicated the scale or adoption that this architecture facilitated. Other languages now even incorporate aspects pioneered by Node.js – like async runtimes and event loops.

Relying solely on a higher level scripting language may have enabled quicker initial development. But performance constraints would have limited these ambitions. Where as the foundation in C++ unlocked Node‘s ability to rival speeds traditionally only seen in compiled languages.

As both JavaScript and C++ advance, their symbiotic relationship in Node.js may drive further innovation powering the next generation of cloud applications and services. Their complementary strengths guide Node.js to pivot the web in new directions not previously possible.