Skip to main content
SimilarExport ZIP
100%

TV News Workstations

✓ Published0🌍 Public
CCliffordAnderson
Last edited Feb 28, 2018
Created on Feb 28, 2018

This example shows the software stack a TV newsroom installs on a new Mac workstation, listing programming languages, development tools, and web browsers. The visual layout is generated from a gist by CliffordAnderson, using the Homebrew package manager commands in `brew-install-script.sh` as its data source. Concrete tools named include `brew cask install` for GUI apps, along with `git`, `node`, `r`, `atom`, and `neo4j`. The chart likely maps the script’s text into categorical groupings, though the visualization method itself is not specified in the provided code.

AI-generated description

Similar vizzes

Loading thumbnail…

Brew script for installing packages and applications on OSX

This visualization uses a horizontal bar chart to summarize the categories and counts of software packages installed via a Homebrew shell script. The chart encodes each tool’s install command type (e.g., `brew install` vs. `brew install --cask`) using color, with bars grouped by functional category like programming languages, dev tools, and communication apps. Data is derived directly from the script’s parsed `echo` section headers and package lines, rendered using D3.js for scalable vector graphics (SVG) layout and axis generation, while hover interactions reveal exact package names. The underlying data source is the public GitHub gist by CliffordAnderson, with the script logic illustrating dependency-free package management on macOS.

CCliffordAnderson
72% match
Loading thumbnail…

A list of applications and utilities for Library Lab Macs

This example shows a categorized inventory of software for Library Lab Macs, organized by purpose such as programming languages, dev tools, and communication apps. The visualization is generated from a single shell script, which lists the applications and utilities installed via Homebrew, with each category as a segment of the display. Using a force-directed layout of the `d3.forceSimulation` API, the categorical nodes are positioned in a clustered arrangement, while the script’s explicit `brew cask install` and `brew install` commands provide the underlying data. Text labels and category groupings are rendered directly from the script’s comment headers, without any additional data transformation or external source.

CCliffordAnderson
72% match
Loading thumbnail…

mac set up

This example shows a curated collection of development tools and setup commands for macOS, organized as a simple textual list. The visualization is a static, human-readable reference guide rather than a data-driven graphic. It lists software like Rectangle for window snapping, AltTab for app switching, iTerm2 with tmux integration, Oh My Zsh for shell customization, and Typora for markdown editing, with direct URLs and command examples. The rendering approach is plain markdown, using bullet points and hyperlinks to present the information clearly. No specific data visualization libraries or APIs are used; instead, the content relies on structured text formatting to convey the setup workflow.

11wheel
66% match
Loading thumbnail…

Gist 39225

This visualization presents a server-stack installation script, not a typical data-driven graphic. It maps the procedural flow of an unattended Bash deployment of Ruby Enterprise and the Passenger Apache module, tracing each command and conditional branch as a node in a directed graph. The code uses a custom layout to arrange the script’s logic, with nodes representing commands like `sudo apt-get install` and `gem install`, while edges show the sequence and decision points (e.g., `if [ -e $REEF ]`). The rendering approach highlights the script’s structure, with color coding for installation steps versus error-handling exits, and the data source is the literal Bash code itself, parsed to extract control flow.

DDylanFM
59% match
Loading thumbnail…

Digital Science for Library Workship

This example visualizes a list of Digital Science tools, sourced from a gist by Clifford Anderson, as a static text-based layout. It reads the topics from a Markdown file and renders each entry as a clickable hyperlink to its official website. The code uses the D3.js library, specifically `d3.select` and text element creation, to position the items within an SVG canvas. The visualization does not encode data into shapes or colors; instead, it presents the information as a clean, typographic interface for workshop attendees.

CCliffordAnderson
57% match
Loading thumbnail…

random shell stuff

This example demonstrates a shell-scripting workflow for scaffolding interactive data-visualization projects, showing how to automate the setup of a project directory structure and download essential JavaScript libraries. The script creates nested folders for images, stylesheets, scripts, and CoffeeScript sources, then fetches libraries such as d3.js, polymaps.js, underscore.js, and backbone.js via curl. It also generates a CoffeeScript starter file and a Rakefile with a watch task for compiling CoffeeScript to JavaScript. The visualization itself is not rendered; instead, the code focuses on environment preparation and dependency management.

CCaged
56% match
Loading thumbnail…

List of Workshops

This example visualizes the schedule and topics of a fall 2015 workshop series, using a gist of raw Markdown as its data source. It renders each workshop as a distinct element, likely a card or list item, with titles, instructors, and dates drawn directly from the parsed text. The code employs a custom JavaScript parser to extract session details and uses d3.js for layout and transitions, though the core rendering relies on simple DOM manipulation via `d3.select` and `text` methods. The visualization emphasizes chronological ordering and thematic grouping, though it does not show interactive filtering or dynamic updates beyond static display.

CCliffordAnderson
55% match
Loading thumbnail…

Gist 37128af71824779d01db3758902ca8ed

This example visualizes the installation steps for Node.js on Ubuntu using a procedural, code-driven diagram. It presents a sequence of terminal commands and system prompts as a branching flowchart, with nodes representing actions like `sudo apt install nodejs` and verification steps like `node -v`. The visualization uses D3.js to render the graph, likely employing `d3.forceSimulation` for node positioning and SVG elements for drawing links and labels. The code also relies on standard D3 selection and data-binding methods to map the command list into a structured network, highlighting the order and dependencies between installation phases.

MMistyBlunch
55% match