Gist eeac85f83bbc682a4f2d

100%

Gist eeac85f83bbc682a4f2d

✓ Published0🌍 Public

Last edited Apr 11, 2015

Created on Apr 11, 2015

This example demonstrates how to run a simple inline Web Worker that greets a user by name, with a fallback to executing the worker script on the main thread when the browser lacks necessary APIs. It uses a `<script type="javascript/worker">` block for the worker code and the `runWorkerJs` helper, which checks for `Blob`, `BlobBuilder`, `URL.createObjectURL`, and `Worker` support. If those are available, it creates a worker from the script’s text and posts a parameter object; otherwise, it evals the script in a proxy scope. The result updates the page body text.

AI-generated description

Similar vizzes

Loading thumbnail…

Force-Directed Web Worker

This example shows a force-directed graph of 1,000 nodes computed in a web worker, with a progress bar indicating the simulation’s tick rate. The main thread receives progress updates and renders the final layout on a Canvas using `getContext("2d")`. The layout is calculated with `d3.forceSimulation`, using `forceManyBody`, `forceLink`, and `forceX`/`forceY` forces in worker.js, which imports d3-force modules via `importScripts`.

Mmbostock

58% match

Loading thumbnail…

Gist 2d272134b57b02eb8cdd0c5904249591

This example tests the archival fidelity of a web page by loading a series of images and scripts that mimic dynamic behavior, including DOM manipulation, AJAX requests, and delayed updates. It uses JavaScript’s `XMLHttpRequest` to fetch remote images and replaces them via base64 data URLs, while `setTimeout` and scroll events trigger asynchronous content changes. The page is rendered within an iframe by the pywb web archiving tool, with a banner and rewrite layer applied. The visualization demonstrates how archived sites handle live interactions and resource loading over time.

NN0taN3rd

57% match

Loading thumbnail…

Gist 7232670

This example demonstrates how a single-page application skeleton is transformed from a static document into an interactive, AJAX-driven experience. The visualization shows a list of user-submitted code entries, with each entry dynamically loaded and rendered without a full page refresh. The implementation uses jQuery’s `$.ajax` method to fetch the `lucky_ajax.md` file and other resources, then updates the DOM with the retrieved content. The code also relies on JavaScript’s `Promise` API for handling asynchronous responses, and highlights the use of `XMLHttpRequest` for network communication. The data source is the downloaded application skeleton, whose structure is revealed through the fetched files. The example focuses on the interaction between client-side scripting and server responses.

EElaineYu

56% match

Loading thumbnail…

Gist 7233762

This example shows a JavaScript application skeleton converted to use AJAX, with the updated files provided as a gist. The code demonstrates an asynchronous data-loading pattern, fetching external resources via `XMLHttpRequest` or a similar AJAX mechanism. It relies on standard browser APIs for handling responses and updating the page content dynamically. The visualization aspect is minimal, focusing instead on the structural change from a static app to one that retrieves data on demand. The author lists the modified files and includes instructions for downloading the original skeleton, making the gist a practical exercise in refactoring for asynchronous behavior.

EElaineYu

55% match

Loading thumbnail…

Gist 859941ebbbd6686689c4c870c1e5cf18

This example demonstrates a chained asynchronous workflow that reads a GitHub username from a local file, fetches the corresponding GitHub profile via the GitHub API, and writes the profile data as JSON to another file. It uses the Promise-based functions `pluckFirstLineFromFile`, `getGitHubProfileAsync`, and `asynWrite`, structured with `then` and `catch` handlers to manage data flow and error logging. The code illustrates how to sequence file I/O and network requests without callback nesting, relying on async/await-style chaining through native JavaScript Promises.

MMailnickko

54% match

Loading thumbnail…

Gist b198922e4837fa3d96af13fb27d5c723

This example demonstrates how to embed an Observable notebook into a standalone HTML page using the Observable Runtime and Inspector APIs. The code loads a notebook, overrides its “subject” cell to output the string “Fred,” and renders the resulting “greeting” cell into a page element. It uses the `Runtime.load` method, `Library`, and `Inspector` classes from the `@observablehq/notebook-runtime` module, fetching the notebook from `api.observablehq.com`. The visualization shows dynamic text replacement within a live notebook module.

Mmbostock

54% match

Loading thumbnail…

Temporal Workflow simple example

This example demonstrates a minimal Temporal workflow where a workflow interface defines a greeting method and an implementation class returns the greeting string. The code shows how a worker registers the workflow implementation with a task queue and starts polling, while a separate starter creates a workflow client, specifies workflow options like task queue and workflow ID, and invokes the method. Using Temporal’s `WorkflowClient`, `WorkerFactory`, and `Worker` APIs, the example illustrates the separation between workflow definition, worker execution, and client-side invocation, with the workflow result printed after execution. The source is a gist by Abhay-Joshi-Git.

AAbhay-Joshi-Git

54% match

Loading thumbnail…

Script Test

This example shows a minimal HTML page that displays the text “Hello HTML!” in large, centered type, demonstrating how to combine CSS for styling with JavaScript for scripting. The page loads two external JavaScript files, `test.js` and `test_with_underscores.js`, each of which logs its filename to the console, illustrating script execution order and file naming conventions. The code relies on standard browser APIs—the Document Object Model (DOM) for the message element and the console for output—with no external libraries. The rendering approach is static, using plain HTML and CSS, and the data source is the literal text embedded in the markup.

CCurran Kelleher

54% match