Skip to main content
100%

Gist 908456

✓ Published0🌍 Public
Aandrewxhill
Last edited Apr 7, 2011
Created on Apr 7, 2011

This example uses the MOL (Molecular) library to set up an interactive visualization application. It creates an event bus and an AJAX API through `mol.events.Bus` and `mol.ajax.Api`, then instantiates a `mol.app.Instance` with logging enabled and runs it. The code configures the application but does not specify a particular dataset or rendering method, so the visible behavior is limited to the initialization and launch of the MOL framework.

AI-generated description

Similar vizzes

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
61% 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
59% match
Loading thumbnail…

Gist 894879

This example builds an interactive map visualization using the D3.js library, displaying geographic data over a rendered world map. It applies a force-directed simulation with `d3.forceSimulation` to position nodes, while `d3.geoPath` generates the map outlines and `d3.geoProjection` handles coordinate transformations. The interface includes customizable control panels styled via CSS, allowing users to adjust map layers and layout dynamically. The visualization renders data from a gist source, combining geographic boundaries with overlaid points that respond to simulated forces for a dynamic, data-driven presentation.

Aandrewxhill
59% match
Loading thumbnail…

Gist 890902

This example defines a reusable canvas-based map marker component for the mol.ui framework. It creates a 120x120 pixel canvas element and layers three separate images—background, foreground, and error state—using the Canvas 2D API’s `drawImage` method. The code supports dynamic icon loading via `setIconSrc` and exposes a `getDataURL` method to export the composite marker as a PNG. The rendering approach relies on explicit canvas drawing operations rather than DOM elements, making it suitable for custom map overlays.

Aandrewxhill
59% match
Loading thumbnail…

Gist 4354110

This visualization displays a map rendered with CartoDB, showing geographic data from a hosted visualization. The page loads a full-screen map using the CartoDB.js library, which initializes the map via `cartodb.createVis` and connects to a remote visualization URL. The map itself is embedded in a fixed-size `<div>` element and relies on CartoDB’s built-in rendering and tile services to draw the geographic layers. The code does not include custom data processing or interaction logic; it simply leverages the CartoDB API to present the pre-configured map.

Aandrewxhill
58% match
Loading thumbnail…

Gist 24e4e0ec42cdeff6633c

This example presents a promotional slideshow for CartoDB, a cloud-based mapping and data visualization platform. The presentation uses D3.js to animate text bullet points and an interactive map visualization, showcasing features like drag-and-drop data importing, real-time dashboards, and GIS analysis through PostGIS. The map rendering employs d3.geoPath to draw geographic boundaries, while the slideshow transitions through sections covering web development integration, team collaboration, and high-performance data processing on scalable infrastructure.

Aandrewxhill
58% match
Loading thumbnail…

Gist a3b2b71ef1d5540adc57

This example presents an interactive visualization built with the D3.js library. It uses the `d3.forceSimulation` API to compute physics-based layouts for nodes, while `d3.geoPath` renders geographic map projections. The code loads external JavaScript libraries and stylesheets via the `index.html` file, and the data is processed through custom scripts. The visualization integrates force-directed graphs with map projections to display relational data across a spatial context.

SSciutoAlex
57% match
Loading thumbnail…

Gist 6105510

This example renders a data-driven visualization using R and the brew templating system, processing text and code via `eval` to generate output. It demonstrates programmatic document composition, where the `brew.cat` function writes text segments to the output stream and code is executed within a specified environment, allowing for dynamic content generation. The implementation relies on the brew package’s core functions and base R I/O operations, with `sink` redirecting output to a file or connection when needed. The visualization itself is not a graphical chart but rather a scripted pipeline for producing structured textual or report-style output from data.

RRCura
57% match