Skip to main content
100%

QueueWrite - asynchronous queue for stream output

✓ Published0🌍 Public
ZZJONSSON
Last edited Mar 18, 2013
Created on Mar 18, 2013

The QueueWrite example demonstrates asynchronous stream throttling by piping the contents of `test.js` through a custom writable stream that queues chunks and limits concurrent write operations. A `delayPrint` function writes each chunk to stdout after a random delay of up to 200 milliseconds, while periodic console logs show the current open slot count and queue size. The code uses Node.js `stream.Writable`, `fs.createReadStream` with `lowWaterMark` and `highWaterMark` options, and `util.inherits` to implement the custom stream logic. Animation occurs through the timing of queued writes and the live stats output.

AI-generated description

Similar vizzes

Loading thumbnail…

Infinite Queue

A queue processes tasks across six parallel slots, each rendering a horizontal bar that animates its width, then collapses and fades before removal. The demo appends div elements via d3.select and transitions, scheduling new tasks with setTimeout to sustain activity. A sentinel task that never invokes its callback keeps the queue running indefinitely, using d3.queue’s defer method. The code highlights the queue’s unbounded memory growth as results accumulate, a trade-off of this infinite-lifecycle pattern.

Mmbostock
64% match
Loading thumbnail…

Node-mysql Query.stream test

This example demonstrates how the node-mysql Query.stream() method handles automatic backpressure by pausing data emission when a downstream writable stream is slow. A MySQL query streams rental records from the sakila.rental table through a custom stream.Writable that delays each write by 500 milliseconds, while the code logs every incoming result event. The mysql connection and Query.stream() API control the flow, and the writable’s highWaterMark settings trigger the pause behavior when the buffer fills.

ZZJONSSON
58% match
Loading thumbnail…

d3.queue image loader

This example demonstrates how to load multiple asynchronous resources before rendering content to a canvas, using `d3.queue` to coordinate a text file and an image. The code defines a custom `d3.imageload` function that wraps the HTML `Image` object, then defers both it and `d3.text` for `hola.txt` and `thumbnail.png`. After both complete, it displays a status message and draws the loaded image onto the canvas using the Canvas API’s `drawImage` method. The page’s body is fixed to fill the viewport, and rendering targets a `canvas` element.

PPhilippe Rivière
56% match
Loading thumbnail…

Streamgraph

A streamgraph displays 20 layers of synthetic time-series data, each rendered as a filled area with a smooth, wiggle-based baseline. The visualization alternates between two precomputed datasets when the "Update" button is clicked, triggering a six-second animated transition. The code uses the D3 v3 stack layout with the "wiggle" offset, an area generator, and linear scales for x, y, and color. Layers are vertically offset with a translate transform for added padding.

CCurran Kelleher
54% match
Loading thumbnail…

Asynchronous Queue

This example demonstrates asynchronous loading and summation of three remote JSON files using the d3-queue library with a concurrency limit of two. A large headline displays the formula “1 + 2 + 3” and updates the result from “?” to the calculated sum once all files are fetched. The code uses `d3.queue(2)`, `d3.json` deferrals, and an `awaitAll` callback to render the computed total via `document.querySelector`. Data files `1.json`, `2.json`, and `3.json` each contain a single number, which are combined with a `reduce` function.

Mmbostock
53% match
Loading thumbnail…

Hello VizHub

This example demonstrates asynchronous programming patterns using JavaScript Promises, with text updates appearing sequentially in two HTML divs. It shows how a chain of `Promise` objects, created through the `setTimeout` function, executes one after another, updating the visual output after each one-second delay. The visualization uses D3.js v5 through the `select` function to modify text content, while a separate module file exports an unused string constant. The styling relies on the Ubuntu font from Google Fonts with a dark background and light text, though the core interaction is purely timing-based rather than data-driven.

Aasimplesinger
53% match
Loading thumbnail…

Streamgraph

A streamgraph displays twenty layers of synthetic time-series data, using a wiggle offset to minimize visual overlap. The graphic animates between two independently generated datasets, smoothly interpolating the stacked area paths over 2.5 seconds. Built with D3 v4, the example uses `d3.stack`, `d3.area`, `d3.scaleLinear`, and `d3.interpolateCool` for color. A button triggers the transition, re-binding the data and applying a transition on the `d` attribute of SVG path elements.

Mmbostock
53% match
Loading thumbnail…

Streamgraph

A streamgraph displays twenty stacked layers, each with two hundred samples, generated from synthetic data using a wiggle-offset stack. The visualization animates between two different datasets, smoothly transitioning the area paths over 2.5 seconds when the Update button is clicked. Built with d3.v4, it uses d3.stack, d3.area, and d3.scaleLinear, with a custom zoom that pans horizontally and a color scale from d3.interpolateCool. The random data is created via a bump function, and the rendering is pure SVG.

GGerardoFurtado
53% match