Gist 6547269

100%

✓ Published0🌍 Public

Last edited Jul 23, 2013

Created on Sep 13, 2013

This example shows a caching layer for the npm registry, which retrieves package metadata documents and keeps them in a local LRU cache. It demonstrates how to use the `lru-cache` module for in-memory storage, `couchwatch` to subscribe to real-time changes from the CouchDB-based registry database at `http://isaacs.iriscouch.com/registry`, and `request` to fetch individual package documents on cache misses. When a change row arrives, the corresponding cache entry is deleted, ensuring the cache stays fresh. The code defines a `RegistryCache` constructor with a `get` method that returns cached data or fetches it via HTTP, handling errors and non-200 responses.

AI-generated description

Similar vizzes

Loading thumbnail…

Gist 89193bd17e57c1339fdc4888b072d7ed

This example visualizes the caching behavior of a JavaScript `memoize` function. It shows how repeated calls with the same argument return a cached result, while new arguments trigger a fresh computation and expand the internal cache object. The code implements the memoization pattern manually, using a plain object as a cache and the spread operator to merge new entries. It does not rely on external libraries or rendering APIs; the visualization likely depicts the function’s execution flow and cache state changes, though the specific display mechanism is not defined in the provided source. The data originates from the `memoize.js` file, demonstrating the logic in isolation.

RRestuta

63% match

Loading thumbnail…

0-cache-args.js

A JavaScript code example demonstrates a caching wrapper for asynchronous database calls. It shows a `cachify` function that intercepts a Node.js-style callback, first consulting an in-memory cache via `getResultFromCache`, and falling back to the original `getUserFromDb` on cache misses. The data source is a hardcoded `users` object, and timing via `console.time` illustrates the performance difference between direct database access (1–2 seconds) and cached retrieval (near-instant).

Aalessioalex

63% match

Loading thumbnail…

Memcached in JavaScript based on Node.JS

This example visualizes the behavior of a Memcached server implemented in Node.js, showing how it manages key-value storage with an LRU (Least Recently Used) eviction strategy under memory pressure. The animation displays the element count in the cache, updating every two seconds via a `setInterval` callback. The code uses Node.js `net` module for TCP networking, a custom LRU class based on chriso/lru, and leverages `process.memoryUsage()` to monitor RSS memory. It also exposes a custom `gc` command to trigger garbage collection via `gc()`.

Aalessioalex

62% match

Loading thumbnail…

async-cache-0.js

This example demonstrates a caching mechanism for asynchronous functions, showing how repeated calls can bypass a slow database lookup. It defines `cachify`, a wrapper that takes an original async function and a cache-fetching function, returning a new function to use instead. The code uses `setTimeout` to simulate random 1–2 second database delays and a near-instant cache response, with data stored in a plain in-memory `users` object. The example compares timing via `console.time` and `console.timeEnd`, illustrating the performance difference between direct database access and cached retrieval.

Aalessioalex

61% match

Loading thumbnail…

Demo of my strange caching strategy

This example demonstrates a caching strategy that stores promises instead of resolved data, ensuring that repeated requests for the same resource return the same in-flight promise. The code uses jQuery’s `ajax` method wrapped in a native `Promise` to fetch Star Wars character data from the SWAPI, with a `Cache` class exposing getters for Luke Skywalker and his homeworld, Tatooine. The getter for Tatooine chains off the Luke promise, and the demo logs responses from both cached entries, showing how dependent promises are reused without duplicate network calls.

Aalex-r-bigelow

60% match

Loading thumbnail…

Gist 121968fa62b818079652160c129eaf3a

This example demonstrates how the R package `packrat` uses a global cache to speed up project initialization by symlinking installed packages instead of re-installing them. It shows the `packrat::init()` and `packrat::restore()` workflows, where previously cached packages are linked from a shared directory (`/home/willbowditch/R/packratcache`) into the project’s `packrat/lib` folder, as seen in the terminal output. The code also configures caching via `packrat::set_opts(use.cache=TRUE)` and reveals that direct `install.packages()` calls bypass the cache, overwriting symlinks. The visualization is a text-based log of file system operations, R commands, and package installation results, illustrating the cache’s behavior with concrete path and symlink details.

RRobinL

60% match

Loading thumbnail…

Gist f43964c87050d00ea185f80513e0d34f

This example demonstrates a minimalist web page that pairs a red HTML block with a JavaScript-based memory system. The visualization shows how a custom `memory` object stores and retrieves key-value pairs, simulating a limited cache that forgets the oldest entries after 250 saves. The code uses plain JavaScript with no external libraries, relying on standard object properties and array methods like `shift()` and `push()` to manage memory. The page renders via a simple `index.html` file that loads `test.js`, which logs the stored data to the console. No charting or data-rendering APIs appear in the code.

Aagnott

58% match

Loading thumbnail…

0-cache-second-try.js

This example demonstrates a caching pattern that wraps an asynchronous database lookup with a cache check, showing how repeated requests can bypass the original slow operation. The code defines an in-memory `users` object and a `getUserFromDb` function that simulates a 1–2 second delay using `setTimeout`. The `cachify` helper composes the original function with `getResultFromCache`, which returns the same user data synchronously via a zero-millisecond timeout. Two `console.time` calls compare the direct database hit against the cached call, visually timing the difference in the console.

Aalessioalex

57% match