Skip to main content
SimilarExport ZIP
100%

Things to install on a fresh installation of ElementaryOS

✓ Published0🌍 Public
EEkthelion
Last edited Nov 30, 2014
Created on Aug 1, 2017

This visualization maps the step-by-step commands from a shell script, perfectelementary.bash, that automates the installation of software on a fresh ElementaryOS system. It shows the sequence of actions, from system updates to installing specific applications like Chrome, Skype, and Java, highlighting the dependencies between them. The rendering uses a custom layout to arrange the commands as nodes, likely with a force-directed graph or similar network visualization library. The underlying data is parsed directly from the Bash script's comments and command structure, revealing the logical flow of the setup process.

AI-generated description

Similar vizzes

Loading thumbnail…

HowTo Install the perfect Elementary-OS

This example shows a Bash script that automates the post-installation setup of Elementary OS, using `apt-get`, `wget`, and `sudo` commands to install software, remove bloatware, and configure system settings. The visualization highlights the script's sequential steps and dependencies, with the code as the primary data source. It maps the command order and conditional branches, such as kernel installation for 32-bit versus 64-bit architectures, using a linear flow diagram. The rendering relies on text-based annotations to clarify each action, without any graphical libraries.

EEkthelion
80% match
Loading thumbnail…

Gist 46edd1c0f072399710e0

This example shows a Bash script automating the post-installation setup of an Elementary OS system, covering package installation, system cleanup, and hardware driver configuration. The code relies on standard command-line tools like `sudo apt-get`, `wget`, `add-apt-repository`, and `dpkg`, along with direct manipulation of system directories. It installs software such as Google Chrome, Gimp, and Steam while removing bloatware like Midori and Noise. The script also configures kernel updates, firmware, and proprietary graphics drivers from PPAs, emphasizing a streamlined, terminal-driven workflow.

MMrMattSim
71% 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
60% match
Loading thumbnail…

Gist f01d812faefd538a9228175105471468

This example demonstrates the installation of Yarn through the command line, showing the sequence of steps required to add the Yarn repository, update system packages, and verify the installation. The visualization uses a terminal-style interface that displays each shell command as text output, including `curl`, `sudo apt-key add`, `echo`, `tee`, and `sudo apt install`. The code relies on standard terminal rendering in a web page, with no external charting or data libraries, and the source is a plain-text script captured from a Gist.

MMistyBlunch
57% 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
56% match
Loading thumbnail…

Gist b6841d55375225f550b287b3e0632119

This example demonstrates how to install Node.js and npm on Ubuntu 18.04 using shell commands, providing a step-by-step reference. It shows the process of adding the NodeSource repository and running the apt package manager to set up the runtime environment. The code uses command-line instructions with curl and sudo to download the setup script and install the nodejs package, with a link to the official Linuxize tutorial for additional guidance. The visualization is not graphical; it is a plain-text procedural guide.

MMistyBlunch
55% match
Loading thumbnail…

Gist 8cc56701b1ffabad9825c205b2c0a77e

This example visualizes a step-by-step guide to post-installation tasks for Arch Linux, rendered as an interactive flowchart. The diagram uses a force-directed layout powered by `d3.forceSimulation` to position nodes and links, with SVG elements for the boxes and arrows. Each node represents a command or tip from the original Markdown file, and viewers can hover to inspect details. The code parses the source text and constructs the network graph, demonstrating a flexible approach to turning documentation into an explorable visual structure.

MMistyBlunch
55% match
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
54% match