Skip to main content
100%

Reactor-based framework versus Node.js streaming

✓ Published0🌍 Public
Aackuser
Last edited Dec 7, 2011
Created on Mar 19, 2019

The benchmark compares a JVM-based Reactor framework using Java NIO FileChannel.transferTo (sendfile) with a Node.js streaming application using fs.createReadStream and pipe, both serving a 1MB file. Under Apache Bench with 100 concurrent users, the JVM framework shows roughly double the throughput and lower latency, with mean total time of 121ms versus 254ms. A single-user test confirms the JVM framework sustains higher requests per second. The example highlights how the Reactor framework’s multi-threaded event handling outperforms Node.js’s single-threaded streaming for file transfers.

AI-generated description

Similar vizzes

Loading thumbnail…

Hello Reactor

This example demonstrates a minimal event-driven communication system built with JavaScript. It shows how two listeners attached to the same `'big bang'` event respond to a dispatched payload, with one listener logging a fixed message and the other printing the passed arguments. The code defines a custom `Reactor` class and an `Event` class, showcasing manual event registration, callback storage, and dispatch logic. The implementation relies on JavaScript's array `forEach` method to invoke all registered callbacks with the spread `...eventArgs` syntax. The data originates from a hardcoded dispatch call passing the values `135`, `'test'`, and `[1, 2, 3]`.

MMAKIO135
58% match
Loading thumbnail…

Gist d51a566a307b428d98eaf3aa8d2a59a3

This example benchmarks JavaScript event emitter libraries across multiple test scenarios, including initialization, emitting with context, and emitting single or multiple values to one or more listeners. The code runs benchmark suites using `benchmark.js`, comparing libraries such as `EventEmitter3`, `MiniSignals`, `push-stream`, and `signal-lite`, and reports throughput in operations per second. It highlights the fastest performers per scenario, such as `push-stream` leading in the "emit with context" test. The visualization shows raw performance data from Node.js 6.2.1, rendered as plain-text tables with pass/fail assertions and timing summaries.

HHypercubed
57% match
Loading thumbnail…

FoundationDB Flow

This example compares the performance of Flow, a C++11 actor-based concurrency language, against other programming languages using the ring benchmark. A table lists execution times for Ruby, Java, Erlang, Go, and Flow, showing Flow completing 1,000,000 message sends in 0.075 seconds. The code samples demonstrate Flow’s `ACTOR` and `wait` keywords for asynchronous futures and promises. The benchmark data comes from external sources circa 2010, with Flow’s result derived from its native-code compilation and callback-based actor rewriting.

Aallyraza
56% match
Loading thumbnail…

AB Benchmark Node.js (via Restify) - 10,000 requests (10 concurrent)

This example displays the results of an ApacheBench load test against a Node.js Restify server, showing 10,000 requests completed with 10 concurrent connections. The visualization plots the percentage of requests served within specific time thresholds, from the 50th percentile at 3 milliseconds up to the longest request at 18 milliseconds. The chart uses D3.js to render the distribution of response times, with data parsed from the ApacheBench text output. The visualization highlights the server’s consistent performance, as most requests complete within 4 milliseconds, and reveals the small variance in request handling times.

HHugoberry
56% match
Loading thumbnail…

Using sendfile(2) with NodeJS

This example demonstrates using the `sendfile(2)` system call in NodeJS to stream file contents over a TCP connection, bypassing userspace buffering for efficiency. It creates a net server that opens a file with `process.binding('fs').open` and sends data in chunks via `sendfile`, tracking the file offset across invocations. The code handles `EAGAIN` errors by listening for the `'drain'` event and manually starting the socket’s `_writeWatcher` to resume transmission, ultimately ending the connection when the file is fully sent. The file path and port are supplied as command-line arguments.

Aalessioalex
54% match
Loading thumbnail…

The introduction to Reactive Programming you've been missing

This example illustrates the core concepts of reactive programming using asynchronous data streams, drawing from the original tutorial by André Staltz. The visualization, built with React, shows how streams can be created from user inputs and combined using functional operators like map and filter. The code references RxJS observables to demonstrate the flow of data events over time, with an interactive diagram that maps click events and other stream transformations. The rendering uses React components to display the stream diagrams, highlighting how multiple streams can be merged and filtered to produce new data sequences.

YYonet
52% match
Loading thumbnail…

The introduction to Reactive Programming you've been missing

This example demonstrates the core concepts of reactive programming through asynchronous data streams, using a click-event stream on a button as the central illustration. The visualization walks through how streams emit values, errors, and completion signals over time, with diagrams showing event sequences and filtering operations. The code is written in JavaScript with the RxJS library, including APIs like `Rx.Observable.fromEvent` for capturing button clicks and methods such as `map`, `filter`, and `merge` to combine and transform stream data. The accompanying markdown references the original tutorial by André Staltz and includes inline images that depict stream behavior.

Aallyraza
51% match
Loading thumbnail…

readStreams leaking in Node

This animation shows memory leaking in a Node.js process as it repeatedly creates read streams for a 2 MB file. Over 180 streams are spawned in a loop, each printing characters to indicate lifecycle events ('o' on open, '*' on data, '$' on end). Every 5 seconds, the script forces garbage collection via `--expose-gc` and logs the process’s resident set size (RSS) in megabytes, producing a stepwise upward trend that reveals how unclosed stream handlers accumulate and prevent memory from being reclaimed. The visualization renders this growth as an animated time series, highlighting the leak’s progression over time.

Aalessioalex
51% match