Skip to main content
Log in
R

RichMorin

@RichMorin·14 public vizzes

Loading thumbnail…

irb (etc) nastygrams

The visualization maps the scattered locations of SQLite3 Ruby gem files across a macOS file system, using data collected from the `mdfind` command’s output in a gist. It shows how numerous gem versions (1.2.1 through 1.3.11) are duplicated across system, backup, and external volumes, revealing version conflicts. The example parses the file paths to extract gem versions and directory hierarchies, then renders them as a node-link diagram using D3’s `d3.forceSimulation` and `d3.hierarchy`. Each path becomes a linked node, with color encoding gem versions and volume names as top-level clusters.

May 24, 2017
Loading thumbnail…

demonstrate newline-handling nit

This example demonstrates a newline-handling discrepancy between Sinatra’s Embedded Ruby (ERB) implementation and the standard Ruby ERB library. The code runs four template strings, each placing an interpolated value next to newlines in different configurations, then prints both sets of results to STDOUT and an HTML page. It shows that Sinatra’s `erb` method strips newlines when an interpolation sits alone on a line, while Ruby’s `ERB.new(...).result(binding)` preserves them. The source is a Ruby script using `erb`, `sinatra`, and a fixed array of test inputs.

Jan 2, 2017
Loading thumbnail…

failing run of "mix compile" for Nerves

This example shows the terminal output from two failed attempts to compile a Nerves project with `mix compile`. The first attempt fails because the `rebar3` tool cannot find the `bare` command, while a second attempt reveals dependency resolution warnings and a lock file version mismatch. The visualization uses raw text from a gist, capturing a shell transcript where the user tries to fix the issue by copying `rebar3` but encounters permission errors. It highlights the interplay between Mix, Rebar3, and Hex package manager during Elixir/Nerves builds.

Jul 13, 2016
Loading thumbnail…

redo_nodes - redo node sets into TSV data rows

This example demonstrates a Julia script that parses node sets from a text-based data file and outputs them as tab-separated value (TSV) rows. It reads a file containing node names and their associated properties, extracts the node name, splits it into a namespace and a name, and merges property values into each output row. The script uses Julia’s `split` and `match` functions for string parsing, the `YAML` library to load predicate metadata, and writes results using `@printf` and file I/O operations. The data comes from a `nodes.t2` file containing entries like Wikipedia article titles or database records.

Jun 13, 2014
Loading thumbnail…

Gist 27dfb7404ee69c1a87e2

This example demonstrates a YAML library in the Go programming language, showing how to unmarshal YAML text into a nested map-of-maps, print the resulting data structure, marshal it back into YAML, and then display that dumped output. The code uses the `yaml.Unmarshal` and `yaml.Marshal` functions from the `gopkg.in/yaml.v1` package, along with `fmt.Printf` and `log.Fatalf` for output and error handling. The embedded YAML source describes predicates like `owl_disjointWith` and `owl_equivalentClass` with metadata fields.

Jun 13, 2014
Loading thumbnail…

Treemap of MBTI statistics

A treemap displays Myers-Briggs Type Indicator (MBTI) distribution statistics, with each leaf node labeled by its four-letter personality type and sized by frequency. Radio buttons let viewers switch between male, female, and total population values, triggering a 1.5-second animated transition that re-sizes and re-positions the rectangles. The code uses d3.layout.treemap with a sticky layout, d3.scale.category20c for coloring, and transition() callbacks to animate changes. Data comes from a local MBTI_3.json file, sourced from mfstats.com statistics.

Mar 9, 2013
Loading thumbnail…

D3 data formats

D3 data formats is a gallery of examples that demonstrates how D3 handles diverse dataset formats. It shows both tabular formats like CSV, with examples including stock prices, population demographics, and car specifications, and hierarchical or relational JSON structures like nested node trees and network graphs. The examples showcase D3's parsing methods for these formats, with various charts such as bar , parallel coordinate, and geographic visualizations.

Jun 13, 2012
Loading thumbnail…

Gist 2784668

This example visualizes the structure of the YARD Ruby documentation library as a navigable tree, starting from its root module and expanding through child namespaces, methods, and constants. It renders this hierarchy using JSON-LD formatted data, which is generated from YARD’s Registry API to capture relationships like children and namespaces. The visualization relies on the `json` and `cgi` libraries to process and encode the data, while the tree layout itself is implemented with D3’s `d3.forceSimulation` and related tree-layout functions.

May 26, 2012
Loading thumbnail…

YARD Registry Dumper

This example converts a YARD documentation registry into an interactive JSON-LD tree, visualizing Ruby code structure as nested namespaces and methods. The Ruby script generates a context header mapping YARD metadata fields to JSON-LD properties, then formats node data including children, files, and superclass relationships for each registered object. The output uses CGI escaping for URI references and produces a structured hierarchy that can be rendered with any JSON-LD-compatible visualization tool.

May 18, 2012
Loading thumbnail…

Hive Plot Demo Rework

An interactive network visualization of software module dependencies, presented as a hive plot with four radial axes for import relationships. The demo uses D3.js to render SVG paths and ellipses, with mouseover interactions that highlight a selected link and connected nodes in blue, green, and red. The visualization is built from the flare-imports dataset, with a smaller test dataset for comparison.

Mar 30, 2012
Loading thumbnail…

Hive Plot Demo

A Hive Plot Demo renders six edges among three labeled axes (foo, bar, baz) in a 350×350 SVG canvas. Three colored axes radiate from a central point, with edges drawn as basis-interpolated splines between axis endpoints, using the D3 v2 API (d3.select, append, attr, d3.svg.line). The demo defines axes via CoffeeScript objects and computes edge directions and control-point offsets for curved paths. Data is entirely mocked in code, with static, predefined node positions and edge lists.

Mar 16, 2012
Loading thumbnail…

Selectable Projection Demo

The demo displays a global grid of points every 10 degrees of latitude and longitude, simultaneously projected through two map projections and connected by curved lines. A static Albers projection is paired with an interactive orthographic projection, whose origin shifts as the mouse moves over the SVG. A dropdown menu changes the static projection to Mercator or stereographic, triggering a smooth transition of point positions and connection paths. The visualization uses D3 v2 methods such as `d3.geo.albers`, `d3.geo.azimuthal`, `transition().duration`, and jQuery event binding for the select control.

Mar 15, 2012
Loading thumbnail…

Selectable Projection Demo

This demo shows how map projections transform a sphere onto a 2D surface by displaying a grid of points—one every 10 degrees of latitude and longitude—mapped between an Albers equal-area projection and an orthographic azimuthal projection. Moving the mouse changes the orthographic projection’s origin, redrawing the corresponding circles and the connecting lines that link each point from the Albers to the orthographic view. Built with D3 v2, it uses `d3.geo.albers`, `d3.geo.azimuthal`, and `d3.geo.path` to render the projections, updating SVG circle and path elements on `mousemove`.

Mar 9, 2012
Loading thumbnail…

Gist 473142

This example shows the output of a UNIX `du` command listing all dynamic libraries (`dylib` files) found within the Google SketchUp 7 application bundle on macOS, sorted by file size. It uses the shell pipeline `du -a . | sort -k 2 | grep dylib` to collect and filter the data, displaying the paths and sizes in a terminal. The visualization highlights the distribution and duplication of shared libraries across the `LayOut`, `SketchUp`, and `Style_Builder` sub-applications, alongside the core frameworks.

Jul 15, 2010