Node.js 0.10.x: What's New, Release History & Support Lifecycle

What Is New in Node.js 0.10?

Streams2 -- The Foundation of Modern Node.js Streaming

Node.js 0.10 introduces Streams2 -- a complete rework of the stream API that adds proper backpressure, a read() method for pull-based consumption, and consistent base classes for Readable, Writable, Duplex, and Transform streams.

Prior to Streams2, data events fired immediately and aggressively -- there was no way to slow down a readable stream without losing data. The pause() method was advisory at best. Streams2 fixes this by introducing a buffer and a read(n) API that lets consumers control the rate of data flow.

// Streams2 pipe with automatic backpressure
const readable = fs.createReadStream('./large-file.csv');
const writable = fs.createWriteStream('./output.csv');
readable.pipe(writable); // backpressure handled automatically

The readable-stream npm package was published alongside 0.10, allowing application code using Streams2 to run on older Node.js versions -- an early example of the "develop in core, publish to npm" approach.

process.nextTick() and setImmediate() -- Execution Order Clarity

Node.js 0.10 fixes process.nextTick() to reliably run callbacks before any I/O events -- not just "usually before I/O" as in prior versions. Callbacks scheduled with nextTick run to exhaustion before the event loop processes any I/O.

setImmediate() is added as a companion: it runs after I/O events and before setTimeout(fn, 0). The phase order is: nextTick queue -> I/O callbacks -> setImmediate -> setTimeout(0). Understanding this ordering is fundamental to writing correct async Node.js code.

// Use setImmediate for yielding within a long computation
function processLargeArray(arr, index) {
  if (index >= arr.length) return;
  process(arr[index]);
  setImmediate(() => processLargeArray(arr, index + 1));
  // yields to I/O between each item
}

Domains -- Grouping Async Error Handling

The domain module in Node.js 0.10 lets you group multiple async operations into a single error boundary. An error in any async operation within the domain routes to the domain's error handler instead of bubbling up to process.uncaughtException.

import domain from 'node:domain';
const d = domain.create();
d.on('error', (err) => {
  console.error('Caught by domain:', err.message);
  res.statusCode = 500;
  res.end('Server error');
});
d.run(() => {
  // async operations here are covered by the domain error handler
  db.query('SELECT 1', (err, result) => { /* errors caught by d */ });
});

Domains were later deprecated (Node.js 4+) as async tracking mechanisms like AsyncLocalStorage provided better solutions. But at the time, domains were the only way to catch errors across async boundaries.

TLS Performance Leap

Node.js 0.10 upgrades to a newer OpenSSL and rewrites CryptoStream to use the Streams2 interface. TLS throughput improves dramatically in benchmarks. HTTP throughput also improves for most workloads. The fs.ReadStream and fs.WriteStream improvements mean file serving gets faster as well.