Skip to main content
Log in
P

P7h

@P7h·66 public vizzes

Loading thumbnail…

JDK8 command line download script; For JDK10, please check: https://gist.github.com/P7h/9741922

This shell script automates the download of Oracle JDK8 binaries for multiple platforms, including Windows, Linux, macOS, Solaris, and ARM architectures, from a single base URL. It defines an array of platform-specific file suffixes and iterates through them, invoking `curl` with the `-C -` resume flag, `-L` for redirects, `-R` to preserve remote timestamps, and the `Cookie: oraclelicense=accept-securebackup-cookie` header to accept Oracle’s license terms. The script also includes a commented list of earlier JDK8 versions for reference.

Jul 25, 2018
Loading thumbnail…

Script to download JDK / JRE / Java binaries from Oracle website from terminal / shell / command line / command prompt

This example shows a collection of Bash scripts for downloading Oracle JDK/JRE binaries from the Oracle website via the terminal. It demonstrates how to automate fetching multiple platform-specific packages (Linux, Windows, macOS) and documentation in a single invocation using `curl` or `wget`. The scripts use `wget` with options like `-c` for resuming interrupted downloads and `--header` to pass the required Oracle license cookie, while `curl` variants employ `-C -` for continuation, `-L` for redirects, and `-O` for remote filenames. The code includes version-specific base URLs for JDK 8, 9, and 10, along with commented notes on command-line flags.

Jul 25, 2018
Loading thumbnail…

JDK9 command line download script; For JDK10, please check: https://gist.github.com/P7h/9741922

This example provides a shell script that automates the download of Oracle JDK 9 binaries from the Oracle website using command-line tools. The script defines a base URL for JDK 9.0.4 and a list of platform-specific files, including Linux tar archives, Windows executables, and API documentation. It uses `curl` with options like `-C -` for resuming interrupted downloads, `-L` for redirects, `-R` for timestamping, and `-O` (implied) with a cookie header to accept the Oracle license. The script also includes commented-out alternatives using `wget`, and documents its purpose for environments like Amazon EC2.

Jul 25, 2018
Loading thumbnail…

7zip install on Linux -- Ubuntu and Fedora or CentOS / RHEL

This example visualizes the manual installation steps for 7zip on Linux, contrasting the Ubuntu and Fedora/CentOS/RHEL workflows. A static tree or flowchart layout renders the command sequences, with distinct branches for each distribution and sub-branches for CentOS 6.7 versus 7.x. The visualization uses plain SVG elements with D3.js for positioning and hierarchy, while the embedded code blocks are styled directly from the Markdown source. No interactive behavior or dynamic data binding is shown; the focus is on comparing package manager commands (`apt-get`, `yum`, `rpm`) and manual download URLs.

Jul 22, 2018
Loading thumbnail…

Apache Toree intallation steps

This example shows a terminal-style walkthrough of the Apache Toree installation process, presenting a sequence of shell and Conda commands in a monospaced layout. The code includes installation steps for system utilities via `sudo apt`, JupyterLab and PySpark through `conda install`, and additional Jupyter extensions from conda-forge. It then demonstrates Toree’s pip installation from an Apache distribution URL, followed by `jupyter toree install` commands that register Scala, PySpark, and SQL kernels against a Spark home directory. The final `jupyter kernelspec list` command displays the available kernels, highlighting the command-line interaction as the primary visual element.

May 21, 2018
Loading thumbnail…

tmux 2.0 and tmux 2.3 installation steps for Ubuntu. Or build from tmux source v2.5 for Ubuntu and CentOS.

This example shows shell-script procedures for installing tmux on Ubuntu and CentOS, comparing package-manager workflows with direct source builds. The code uses `wget`, `tar`, `apt-get`, and `yum` commands to fetch and configure tmux v2.7 from GitHub releases, with `./configure` and `make` for compilation. It also demonstrates PPA-based installation via `add-apt-repository` for older tmux versions like v2.3 and v2.0, pinning specific package versions. The scripts include cleanup steps and verification checks using `tmux -V`, with timings noted for EC2 environments.

May 18, 2018
Loading thumbnail…

Customized ConEmu [https://github.com/Maximus5/ConEmu] configuration as on 12th Dec, 2017.

This example visualizes the structure of a customized ConEmu configuration file, showing the hierarchy of XML keys and values as of December 12, 2017. It uses D3.js to render a collapsible tree layout, with nodes representing configuration settings like `ColorTable` entries, `CursorTypeActive`, and `ClipboardDetectLineEnd`. The graph is built via `d3.hierarchy` and `d3.tree`, with transitions animated through `transition.attrTween` for smooth expansion and collapse. Data comes from a Gist by P7h containing the raw `ConEmu.xml` configuration.

Dec 12, 2017
Loading thumbnail…

Replaces all levels to ERROR in all the log4j.properties files on the disk

This visualization shows a system-wide search-and-replace operation that converts every log level (TRACE, DEBUG, INFO, WARN) to ERROR across all `log4j.properties` files on the disk. It uses `find` with the `-exec` flag to locate each file and pipes the results through `sed -i` with the `s/.../ERROR/g` substitution pattern, applying the change in place. The rendering approach is a simple command-line process, with no external data-visualization libraries involved. The sequence of four `sudo find` commands highlights the repeated transformation, emphasizing the scope of the disk-wide modification.

Oct 26, 2017
Loading thumbnail…

Zeppelin official Docker image download and configure for O'Reilly Spark 2.1 course

This example shows how to set up the Zeppelin notebook environment for an O'Reilly Spark 2.1 course by downloading course materials and launching the official Apache Zeppelin Docker image. The script creates directories for notebooks, logs, and data, then downloads and extracts a GitHub repository containing the course content. It runs the `docker run` command with volume mounts for `$PWD/logs`, `$PWD/data`, and `$PWD/notebooks`, while setting environment variables like `ZEPPELIN_LOG_DIR`, `ZEPPELIN_DATA_DIR`, and `ZEPPELIN_NOTEBOOK_DIR` to point to those mounted paths. The code also includes cleanup commands using `docker images` and `docker ps -a` with `awk` and `xargs` to remove all Docker images and containers.

Aug 31, 2017
Loading thumbnail…

Share folders between Guest and Host OS with Virtual Box.

This example demonstrates how to share a folder between a Windows host and a Linux guest in VirtualBox. The Gist provides two shell commands: first, a note to create the shared folder via the GUI, then a series of Bash commands run inside the guest OS. These commands add the current user to the `vboxsf` group, create a mount point at `~/share`, and mount the shared folder using the `mount -t vboxsf` command with the `uid` and `gid` options set to the current user’s IDs. The code relies on the VirtualBox Guest Additions and standard Linux utilities, with no external libraries.

Aug 17, 2017
Loading thumbnail…

DateTime difference between 2 timestamps. Granularity from centuries to nanos.

This example shows the elapsed time between September 11, 2001, and the current moment, broken down into units from centuries down to nanoseconds. Two approaches are compared: the first uses Java’s `ChronoUnit` enumeration with a tail-recursive function to compute differences across twelve granularities, while the second uses `TimeUnit` conversion and `ZoneOffset` to produce a day-to-second breakdown. The Scala code builds a human-readable string, adjusting unit labels for singular values, and prints both outputs from the `Stopwatch` object.

May 12, 2017
Loading thumbnail…

Download and setup [from the command line] Java, Scala, SBT and Spark on a Ubuntu machine.

Two Bash scripts automate the end-to-end setup of a big-data toolchain on Ubuntu, downloading and installing JDK 8, Scala, SBT, and Spark via `wget`, then extracting tarballs with `tar`, moving binaries into `~/apps`, and appending environment variables to `.bashrc`. The second script sources the updated shell configuration, launches a Spark master and slave using `start-master.sh` and `start-slave.sh`, and runs the bundled `SparkPi` example to verify the installation. It also uses `sed` to reduce log verbosity across all `log4j.properties` files.

Mar 11, 2017
Loading thumbnail…

My tmux conf

This example turns a tmux configuration file into an interactive plugin-management guide, rendering the config’s plugin list via git clone commands in `install_tmux_plugins.sh`. It visualizes the tmux interface’s color-coded status bar, pane borders, and prefix remapping using tmux’s `set-option` and `setw` directives, while the shell script sources the config with `tmux source-file`. The display maps each config line to its corresponding tmux API call, such as `run-shell` for plugin loading and `bind` for key remapping.

Mar 7, 2017
Loading thumbnail…

FizzBuzz in Haskell

This example demonstrates the classic FizzBuzz algorithm implemented in Haskell, printing results for numbers 1 through 100 to the console. The code defines three pure functions—`fizzbuzz`, `fizz`, and `buzz`—which use Haskell’s `mod` operator for divisibility checks and string concatenation to build each output line. The `main` function leverages the `mapM_` function with `putStrLn` to sequentially output each line, using a list comprehension to generate the input range. No external libraries are used; the example relies solely on Haskell’s standard Prelude, and it is compiled with GHC as shown in the comments.

Feb 4, 2017
Loading thumbnail…

FizzBuzz in Scala

This example demonstrates a functional implementation of FizzBuzz for numbers 1 through 30, using Scala’s pattern matching with custom extractors. The code defines a `MultipleOf` case class whose `unapply` method returns `Some(x/n)` when the input is divisible by `n`, enabling concise matching against `multipleOfThree`, `multipleOfFive`, and `multipleOfFifteen`. Each number is mapped through a `fizzbuzz` function that returns the appropriate string or the original integer, then printed sequentially via `map println`. The example highlights Scala’s case classes, partial functions, and the map-collect-print idiom.

Feb 4, 2017
Loading thumbnail…

Current week# using Python

This example displays the current ISO week number and its corresponding year and day of the week based on the system’s local date. It uses Python’s `datetime` module, specifically the `datetime.datetime.now().isocalendar()` method to retrieve a tuple containing the year, week number, and weekday. The script then prints these three values to the console, providing a simple snapshot of the current calendar position. No external libraries or data sources are involved; the output is derived directly from the system clock.

Feb 4, 2017
Loading thumbnail…

tmux vs screen commands

This visualization presents a two-column comparison table of tmux and screen terminal multiplexer commands, organized by common actions like session management, window navigation, and pane splitting. The data, sourced from a gist by P7h, is rendered as an accessible HTML table using standard markdown-to-HTML conversion via GitHub’s rendering pipeline. Each row pairs equivalent commands side-by-side, with keyboard shortcuts displayed as distinct keycap-styled elements (<kbd> tags) for clarity. The layout prioritizes scannability, allowing users to quickly identify the syntactic differences between the two tools for tasks such as detaching, renaming windows, or enabling scrollback, without requiring interactive features or custom JavaScript libraries.

Dec 7, 2016
Loading thumbnail…

My customized User Settings of Sublime Text.

This example visualizes the complete configuration of a Sublime Text user settings file as an interactive network diagram. The visualization maps each setting key and its associated value or nested array structure into nodes and links, using d3.forceSimulation for layout and d3.drag for user interaction. The data comes from a JSON gist authored by P7h, with the graph organized to reveal relationships between preferences like editor behavior, theme, and file patterns. The rendering approach uses SVG elements updated through D3’s data join to reflect the hierarchical nature of the settings.

Dec 4, 2016
Loading thumbnail…

Docker Image for GHC v8.0.1 and Cabal v1.24

This example shows a Dockerfile that defines a containerized Haskell development environment, pinning GHC v8.0.1 and Cabal v1.24. It demonstrates the Dockerfile instructions `apt-get`, `add-apt-repository`, `ENV`, `WORKDIR`, and `USER` to install the compiler toolchain from the `hvr/ghc` PPA and set the `PATH` and home variables. The file uses the base image `ubuntu` and concludes with a `CMD` to launch an interactive Bash shell, showing a reproducible setup for Haskell tooling.

Sep 18, 2016
Loading thumbnail…

Bash command line Shortcuts

This example visualizes Bash command-line shortcuts by grouping them into four functional categories: command editing, recall, control, and Bang commands. The visualization uses a force-directed graph layout via `d3.forceSimulation` to position shortcut nodes, with color coding and labels indicating each shortcut’s key combination and its corresponding action. Hovering over a node highlights its description. The underlying data is sourced from a gist by P7h, originally adapted from a blog post, and the visualization is rendered in JavaScript with D3, focusing on the relational structure of these productivity commands.

Sep 13, 2016
Loading thumbnail…

Gist 0491d89144ebf831d3e485d03c947351

This gist contains a Keybase proof statement, not a data visualization. It is a plain-text and JSON document that cryptographically links a GitHub account, P7h, to a Keybase identity, p7h, via a signed PGP message and a public key fingerprint. The file demonstrates the command-line verification process using the `keybase id` command. No visualization libraries or rendering code are present.

Jul 26, 2016
Loading thumbnail…

Formatting and parsing date and time with Java 8

This example demonstrates how to format and parse date-time strings using the Java 8 `java.time` API, focusing on the distinction between `LocalDateTime` and `ZonedDateTime` when time-zone offsets are present. It defines a custom pattern with `DateTimeFormatter.ofPattern("EE MMM dd HH:mm:ss ZZ yyyy")` to parse a fixed date string and to format the current time. The code shows that parsing a string with a time-zone offset requires `ZonedDateTime`, while formatting without an offset works with `LocalDateTime`. It also illustrates two equivalent syntaxes for formatting: calling `formatter.format(now)` and `now.format(formatter)`.

Apr 3, 2016
Loading thumbnail…

Spark.ml Pipelines QuickRef

This example is a Markdown quick-reference card for Apache Spark’s MLlib Pipelines API, organized as a structured cheat sheet. It lists and categorizes key classes—such as Transformers (Tokenizer, HashingTF, PCA) and Estimators (LogisticRegression, KMeans)—and briefly describes their purpose and configuration methods like `setNumFeatures` or `setMaxIter`. The content is rendered as plain text in a code block, with no interactive or graphical elements; the visual presentation relies solely on the document’s formatting, not on any JavaScript or charting libraries.

Mar 22, 2016
Loading thumbnail…

Sublime Text Packages

This example visualizes the 24 Sublime Text packages listed in the included text file, arranged as a force-directed graph. Each package name appears as a node with its description on hover, and the layout uses `d3.forceSimulation` with `d3.forceLink` to position nodes and edges based on the provided data. The visualization is rendered dynamically on a canvas, with node colors and text drawn in a dark theme to match the packages’ utility. It offers a quick overview of the ecosystem from the GitHub gist by P7h.

Mar 11, 2016
Loading thumbnail…

To connect to EC2 env in a SSH Client, the following Gist has to be updated for a specific machine, source and final folders and also the Pub file.

This example shows a shell-based workflow for connecting to an Amazon EC2 instance from an SSH client, including transferring a public key and syncing local folders. It uses command-line tools like `pscp`, `ssh`, `ssh-keygen`, and `scp` to convert a PuTTY key, append the client’s public key to the server’s `authorized_keys`, and copy files via SCP with strict host checking disabled. The gist exposes the necessary commands and file paths that must be edited per machine.

Jan 22, 2016
Loading thumbnail…

JDK 7 command line download script; For JDK8, please check: https://gist.github.com/P7h/9741922

This example shows a shell script that automates the download of multiple JDK 7 platform-specific packages from Oracle’s website. It defines a base URL for JDK 7u79 and iterates over an array of file suffixes, using `wget` with `--no-check-certificate` and a cookie header to accept the Oracle license. The script also comments alternative versions and a `curl` command for JDK8.

Jul 17, 2015
Loading thumbnail…

Python snippets for quickly finding the platform type, cpu and memory stats of a Linux machine.

This example shows how to quickly retrieve platform type, CPU model names, and memory statistics from a Linux machine. It parses the `/proc/cpuinfo` and `/proc/meminfo` files using Python’s `collections.OrderedDict` to preserve field order, printing each processor’s model name and total/free memory. The third snippet uses the `platform` module’s `uname()` and `linux_distribution()` functions to display system and distribution details. Together, these scripts demonstrate lightweight, file-based system introspection without external dependencies.

Jun 16, 2015
Loading thumbnail…

Module 5 Exercise -- Life Expectancy for all the countries.

Two side-by-side scatterplots show life expectancy at birth for every country in 1960 and 2012, with each orange circle representing a nation and its vertical position indicating the reported years. The paired charts let viewers compare global longevity changes across the five-decade span. Using d3.v3, the code loads the CSV data, sorts countries by life expectancy, and renders the circles with SVG, applying a staggered transition to animate their appearance. The y-axis uses a fixed 20-to-90 year scale, and hover tooltips reveal each country’s exact value. Data originates from the World Bank’s 2014 indicator.

Apr 26, 2015
Loading thumbnail…

Life expectancy multiline chart: 1960 &ndash; 2011

This interactive multiline chart displays life expectancy at birth for countries worldwide from 1960 to 2012, using data from the World Bank. Users can filter the display by selecting a letter button to view only countries starting with that letter. The visualization uses D3.js v3 to render SVG paths, with a highlight effect applying a steelblue stroke to selected countries such as the United States, China, and India. The chart includes x and y axes generated with d3.svg.axis and a line generator built with d3.svg.line.

Apr 25, 2015
Loading thumbnail…

Find the largest of a sub-array for a specific window size

This example demonstrates the sliding window maximum problem, showing how to find the largest value within every contiguous sub-array of a fixed size as the window moves across an integer array. The Groovy script initializes an array of nine integers and a window size of three, then iterates through the array, extracting each window into a temporary array. For each window, it calls the `getMax` function, which concatenates the window’s elements into a string and identifies the largest value by comparing each element against a running maximum. The output prints each window’s contents followed by an arrow and the computed maximum, illustrating the algorithm’s step-by-step progression without using any visualization libraries.

Apr 24, 2015
Loading thumbnail…

Life Expectancy Slope Graph: 1960 &ndash; 2011

A slope graph compares life expectancy at birth in 1960 and 2012 for countries worldwide, using data from the WorldBank. Each country is represented by a line connecting its two values, with labels on both ends, and the SVG is rendered using D3.js version 3. The code parses a CSV file with d3.csv, uses ordinal scales and custom collision-avoidance logic to space labels, and highlights lines and labels in red on hover via CSS classes.

Apr 18, 2015
Loading thumbnail…

Module 4 Exercise -- Life Expectancy for all the countries.

A horizontal bar chart ranks a subset of countries by life expectancy at birth in 2012, drawing on 53 years of World Bank data loaded from a CSV. The chart uses D3 v3 with an ordinal scale for country names, a linear scale for years, and SVG rects for bars. It pulls a random subset of rows to keep the display readable, and interactive tooltips reveal each country’s value. Axes are rendered via `d3.svg.axis`, and text labels show the exact 2012 value at each bar’s end.

Apr 18, 2015
Loading thumbnail…

JDK Download script [earlier version] -- NOT maintaining this anymore. Please check: https://gist.github.com/P7h/9741922

This example presents a shell script that automates downloading various JDK 8 and JDK 7 distributions and documentation from Oracle’s servers. It shows how to use `wget` with the `--no-check-certificate`, `--no-cookies`, and `--header` flags to pass the required `oraclelicense=accept-securebackup-cookie` cookie, bypassing Oracle’s license acceptance. The script targets multiple versions (8u25 through 8.0) and platforms including Windows x64/i586 and Linux x64/i586, and also fetches Java tutorials zips. It is an earlier, unmaintained version, with the code referencing a newer gist.

Apr 17, 2015
Loading thumbnail…

Global Food Index Bar Chart

This bar chart ranks countries by their Global Food Index score, from highest to lowest, with each bar's length representing the score. The chart uses orange bars with black outlines, and hovering over a bar reveals a tooltip with the specific country and score. The visualization is built with D3 version 3, using `d3.scale.linear` and `d3.scale.ordinal` for positioning, and `d3.svg.axis` to render the axes. The data comes from a CSV file named `FoodDataFinal.csv`.

Apr 7, 2015
Loading thumbnail…

Module 3 Exercise -- Life Expectancy for all the countries.

A clustered bar chart displays life expectancy at birth in years for a subset of countries in 2012, drawn from a CSV file. The chart presents country names on the y-axis and horizontal bars proportional to their life expectancy values, with each bar labeled by its data value. The visualization sorts the data in descending order and samples every few rows to manage the dataset size. It is rendered as SVG using D3 v3, where the code loads the CSV via `d3.csv`, sorts with `d3.descending`, and appends rectangles and text elements to the SVG canvas.

Apr 5, 2015
Loading thumbnail…

Module 3 Exercise -- Sacramento Yearly Average Temperature.

This visualization displays Sacramento’s yearly average temperature from 1915 to 2011 as a vertical bar chart using D3 v3 and SVG. Each year is labeled along the left, with bar lengths proportional to the temperature value and the numerical figure overlaid at the bar’s end. The chart reads data from a CSV file via `d3.csv`. Bars change to a dark teal on mouseover and toggle between green and orange on click, using D3’s selection and event-handling methods.

Apr 5, 2015
Loading thumbnail…

Loading CSV Data with D3

This example demonstrates loading tabular CSV data from a file and transforming it into an array of JavaScript objects using the `d3.csv` API from D3 v3. The visualization renders a static decorative composition of SVG shapes—a line, polygon, rectangle, and circle—on a 500 by 500 canvas, while the primary focus is on console output. The code logs a table of the parsed data, showing selected columns like country name and life-expectancy values for 1960 and 2012, verifying the data-loading process.

Mar 27, 2015
Loading thumbnail…

Numpy and Scipy [and also 7zip] on Ubuntu.

This example shows a shell script for setting up a scientific Python environment on Ubuntu, with a focus on installing NumPy, SciPy, and 7zip. The code uses the Bash `sudo apt-get` and `sudo pip` commands to install system packages like `gfortran`, `libopenblas-dev`, and `liblapack-dev`, which are required for building SciPy. It also installs `p7zip` for archive handling and `python-pip` for package management. The script demonstrates a linear, command-by-command installation workflow, with each line invoking a package manager API directly in the terminal.

Feb 12, 2015
Loading thumbnail…

Workaround RubyGems' SSL errors on Ruby for Windows (RubyInstaller).

This example presents a step-by-step guide for resolving SSL certificate verification failures in RubyGems on Windows, specifically for RubyInstaller users. It shows the transition from the obsolete bundled CA certificate to a SHA-2 upgraded replacement, affecting RubyGems versions 1.8, 2.0, and 2.2. The document details manual installation of official update packages (e.g., 1.8.30, 2.0.15, 2.2.3) via the `gem install --local` command, followed by `update_rubygems`. It also links to relevant GitHub commits and issue discussions, rendering the historical context and fix through a Markdown-formatted gist.

Jan 16, 2015
Loading thumbnail…

Commands to download Chromium from the shell. Just in case, if you dont want to go thru this hassle, check Chromium Auto Updater. http://www.firstever.eu/en/chromium-auto-updater.

This example shows shell commands for downloading Chromium browser builds for both 32-bit and 64-bit Windows from the command line. The script uses `curl` to retrieve the latest build version number from the Chromium continuous build server’s `LAST_CHANGE` file, then `wget` to download the corresponding `chrome-win32.zip` archive, and finally `mv` to rename the file with its version stamp. It relies on the Google Cloud Storage API endpoints for the `Win` and `Win_x64` directories, and includes a note about an alternative auto-updater tool.

Jan 1, 2015
Loading thumbnail…

Adds GitHub Atom Editor to the Windows Explorer context menu. Not required anymore as Atom Installation is adding the context menu entry.

This example provides a Windows Registry script that adds an “Atom” option to the Explorer context menu, allowing files or folders to be opened directly in the GitHub Atom editor. The `.reg` file defines multiple registry keys under `HKEY_CLASSES_ROOT` for file, directory, and background contexts. The code specifies the Atom executable path and uses `%1` or `%V` parameters to pass the selected item. It relies on the `regedit` tool to apply the configuration.

Jan 1, 2015
Loading thumbnail…

Performance tuning parameters for IntelliJ IDEA. Add these params in idea64.exe.vmoptions or idea.exe.vmoptions file in IntelliJ IDEA. If you are using JDK 8.x, please knock off PermSize and MaxPermSize parameters from the tuning configuration.

This example displays a plain-text configuration file for tuning IntelliJ IDEA performance, listing JVM flags such as `-Xms2048m` and `-XX:+UseConcMarkSweepGC`. It shows the exact parameters to add to `idea64.exe.vmoptions` or `idea.exe.vmoptions`, including heap size, garbage collection settings, and perm-size options, with a note to remove PermSize entries when using JDK 8.x. The visualization presents the raw gist content as a text block, using no graphics or charting libraries. The data source is a gist authored by P7h, and the rendering approach is a straightforward text dump of the file’s contents.

Nov 6, 2014
Loading thumbnail…

Kill all tmux sessions and screen sessions.

This example shows how to terminate all active tmux and screen sessions via shell commands. It first lists tmux sessions, extracts session IDs by filtering lines containing colons, trimming with `cut`, and stripping trailing characters using `awk` and `substr`, then pipes them to `xargs kill`. For screen, it filters lines containing "Detached", parses the session identifier with `cut` and `awk`, and kills those processes similarly. The code relies on standard Unix utilities including `tmux`, `screen`, `grep`, `cut`, `awk`, `xargs`, and `kill`.

Oct 25, 2014
Loading thumbnail…

Various aliases set up for my convenience on my Linux machine. Copy these to your .bashrc.

This example presents a collection of shell aliases for Linux, sourced from a gist by P7h and intended for direct inclusion in a user’s `.bashrc` file. It shows a curated set of shortcuts, including commands like `cd..`, `ls`, `grep` with color output, and the `now` alias for formatted date and time. Each alias is defined via the Bash `alias` built-in, demonstrating how to override default behaviors, such as adding `-c 5` to `ping` or using `sudo` with `vi`, while also grouping related functions like `tmuxn`, `tmuxa`, and `tmuxl` for session management. The text is plain code, with no external libraries or APIs beyond the shell environment.

Oct 25, 2014
Loading thumbnail…

tmux shortcuts & cheatsheet

This example renders the tmux shortcuts and cheatsheet as a structured text document, presented in a monospaced format that mirrors a terminal interface. The visualization organizes commands into color-coded sections for sessions, windows, panes, resizing, and copy mode, using Markdown headings and code blocks from the source gist to delineate each category. It displays the full command syntax, including the `tmux` CLI calls and in-session prefix keybindings, while static HTML and CSS styling emphasize the hierarchical layout without any interactive elements. The content derives directly from the author’s cheat sheet, preserving its original typography and annotation style.

Oct 24, 2014
Loading thumbnail…

For showing IP Address before the login prompt on Ubuntu env. Copy the following script to /etc/network/if-up.d/ and /etc/network/if-post-down.d/ folders. And don’t forget to mark them as executables.

This example shows a Linux system displaying the Ubuntu version, hostname, and IP address before the login prompt by writing this information to the `/etc/issue` file. The script uses `cat /etc/issue.net` to copy the OS release banner, `hostname` to append the machine name, and `ip address show eth0` piped through `awk` and `cut` to extract the IPv4 address from the `eth0` interface. It is intended for placement in `/etc/network/if-up.d/` and `/etc/network/if-post-down.d/` directories, which run the script upon network interface state changes. The code relies solely on standard shell utilities and system files, with no external graphics or data-visualization libraries.

Sep 17, 2014
Loading thumbnail…

Turn off the firewall on a Linux machine

This example illustrates the sequence of commands for disabling a firewall on a Linux machine, visually organized as a static flowchart. The visualization maps each shell command (such as `sudo service iptables stop` and `sudo ufw off`) into distinct nodes, with arrows indicating the logical order of execution. The code relies on the D3.js library’s `d3.hierarchy` and `d3.tree` APIs to compute the layout, while `d3.select` and `d3.enter` render the SVG elements. The data source is the author’s own gist, manually parsed into a hierarchical JSON structure for the tree diagram.

Sep 17, 2014
Loading thumbnail…

Guava API toString() method generator for a JavaBean or POJO for IntelliJ IDEA.

This example shows an IntelliJ IDEA live template that generates a Guava-based `toString()` method for a JavaBean or POJO. It uses Apache Velocity syntax to iterate over the bean’s members and emits a call to `Objects.toStringHelper(this)`, chaining `.add()` for each field, and finally `.toString()`. The template auto-imports `com.google.common.base.Objects` from the Guava library, producing a readable string of all attributes without manual boilerplate.

May 14, 2014
Loading thumbnail…

Renaming files in many sub-folders. Requirement: There is a huge directory list which has many sub-directories and one file in each sub-directory, which has to be renamed as sub-directory name with the original extension. Last sub-directory name is always 8 chars. After renaming is done, it has to be moved to a different folder. Wrote a small Python utility for this requirement.

This example demonstrates a Python utility that renames a single file inside each sub-directory to match the sub-directory name while preserving the original extension, then moves it to a destination folder. It shows how `os.walk` traverses the directory tree, identifies the last 8 characters of each sub-directory name via string slicing, and uses `os.rename` to relocate and rename the file to `D:/GBR/`. The code relies on the standard `os` library for file system operations.

May 14, 2014
Loading thumbnail…

Python utility to create missing tsv files [numbered 1 to 78] in a directory.

This example demonstrates a Python utility that scans a designated directory and programmatically verifies the presence of 78 sequentially numbered TSV files, creating any that are missing. The script first defines the target folder path and then iterates through a numeric range from 1 to 78, constructing filenames and checking their existence with `os.path.isfile`. For any absent file, it opens a new file in write mode and populates it with a header row containing `word` and `count` column labels, using the built-in `open` function and the file object's `write` method before closing it with `f.close()`. The process ensures a complete, standardized dataset structure across the directory.

May 12, 2014
Loading thumbnail…

Trivia: Generate primes between 1 and 100 million with Hadoop MapReduce job. Inspired by https://gist.github.com/krishnanraman/6346307.

This example compares Hadoop MapReduce and pure Java for computing prime numbers between 1 and 100 million. It uses the Hadoop `Job`, `Mapper`, `TextInputFormat`, and `TextOutputFormat` APIs to process a file with one number per line, emitting each prime via `context.write`. The MapReduce job runs in about 2 minutes 20 seconds, while a pure Java loop takes 5 minutes 26 seconds. The output file, `part-r-00000`, contains 5,761,455 primes, demonstrating the parallel framework’s speed advantage over a single-threaded approach.

Apr 13, 2014
Loading thumbnail…

Maven Important commands and Lifecycle phases.

This graphic visualizes the sequence of Maven build lifecycle phases alongside the corresponding command-line instructions for each step. It displays a tabular breakdown of each phase, from validate through deploy, with accompanying descriptions. The visualization pairs this lifecycle data with a list of specific Maven commands, such as `mvn compile` and `mvn package`, that trigger each phase. The information is sourced from a plain-text gist by P7h, and the layout uses a simple text-based rendering to present the phases and commands in a clear, structured format.

Mar 24, 2014
Loading thumbnail…

Sample example demonstrating usage of Stopwatch API of Google Guava.

This example shows how to measure elapsed time in a Java program using the Stopwatch API from Google Guava. It creates a started Stopwatch, pauses execution for a random number of milliseconds via `Thread.sleep`, then stops the timer and prints the total duration. The code demonstrates querying elapsed time in nanoseconds, microseconds, and milliseconds using `stopwatch.elapsed(TimeUnit.*)`. The essential API calls are `Stopwatch.createStarted()`, `stopwatch.stop()`, and `stopwatch.elapsed()`, with the output displayed through standard `System.out.println` statements.

Jan 29, 2014
Loading thumbnail…

Load a properties file using Guava.

This example demonstrates how to load a properties file from the classpath and print its key-value pairs to the console using Guava’s I/O utilities. It shows an explicit resource-loading workflow: `Resources.getResource` locates the file, `Resources.asByteSource` wraps it in a `ByteSource`, and `byteSource.openBufferedStream` provides the `InputStream` that `Properties.load` consumes. The code then calls `Properties.list(System.out)` to display all entries, handling `IOException` and closing the stream in a `finally` block.

Jan 26, 2014
Loading thumbnail…

sudo for a command without a password prompt.

This example demonstrates how to configure a Linux system so that a specific user can run sudo commands without being prompted for a password. It shows the contents of a shell script that opens the sudoers file with `visudo` and adds a line granting the user `prash` the `NOPASSWD` privilege for all commands on all hosts. The script relies on the `visudo` command-line tool to edit the file safely, ensuring syntax validation before saving. No external data sources or rendering libraries are used; the visualization is a direct text display of the configuration steps.

Dec 12, 2013
Loading thumbnail…

Install essentials on RHEL machines.

This visualization demonstrates the step-by-step installation of essential software packages on RHEL machines, using a shell script workflow. It shows each command in sequence, including `sudo yum update`, `yum install` for zip, subversion, git, python2.7-dev, and gcc, alongside direct `wget` and `rpm -i` operations for p7zip. The script also runs `sudo easy_install pip`. The rendering relies on a simple code-file viewer that highlights the command lines, with no external data source, presenting the raw Bash instructions as the primary visual element.

Dec 12, 2013
Loading thumbnail…

Script useful to resize or extend a disk on EC2

This example presents a shell script that automates disk resizing operations for Amazon EC2 instances. It shows the sequential process of first checking current disk space with `df -h`, then applying the `resize2fs` command with a user-specified partition name, and finally verifying the resize was successful. The script documents each step through inline comments, making it a practical reference for system administrators. The visualization highlights the clear workflow of examination, action, and validation through command-line tools on a Linux filesystem.

Dec 12, 2013
Loading thumbnail…

Steps to be performed for upgrading Linux Mint 15 "Olivia" to Linux Mint 16 "Petra".

This visualization shows the exact shell commands needed to upgrade Linux Mint 15 “Olivia” to Linux Mint 16 “Petra,” sourced from a gist by P7h. It renders the upgrade steps as a sequential flow, where each command appears as a distinct node or block. The underlying data is a plain-text shell script named `LinuxMint15To16Upgrade.sh`, containing six `sudo` commands that use `sed` to replace codenames in apt source files and then run `apt-get update`, `dist-upgrade`, and `upgrade`. The code likely uses D3.js’s `d3.forceSimulation` to position nodes and standard SVG elements for rendering, with no animated transitions beyond basic layout.

Dec 10, 2013
Loading thumbnail…

Gist 82f1941cefca78989adf

This visualization presents a text-based cheat sheet for tmux, organized into sections for commands, controls, sessions, windows, and panes. The data is plain terminal text formatted with ASCII art tables and separators, rendered likely as an HTML document. The implementation uses standard web technologies, with CSS for styling the preformatted text blocks, tables, and syntax-like highlighting. It does not employ JavaScript visualization libraries, SVG, or canvas rendering; instead, it relies on static markup and typography to convey the hierarchical command structure. The example focuses on clarity of textual information rather than graphical encoding.

Nov 15, 2013
Loading thumbnail…

For jumping around deeply nested folders.

This example presents a command-line tool for navigating deeply nested folders using named shortcuts. It shows how users can create persistent marks for directories, jump to them from anywhere, list all saved marks, and remove unwanted ones. The Bash script relies on symbolic links stored in a hidden `$HOME/.marks` directory, with functions `mark`, `jump`, `unmark`, and `marks` managing these links. Tab completion for `jump` and `unmark` is implemented via the `complete` built-in and a custom `_completemarks` function that queries the filesystem with `find`. The tool depends only on standard shell utilities like `ls`, `sed`, and `cut`.

Aug 18, 2013
Loading thumbnail…

Windows specific registry snippet: This gist is useful for getting Cygwin (http://www.cygwin.com) on right click of a folder, drive or background. This gist assumes that Cygwin is installed and accessible from C:\Cygwin\Cygwin.bat and the icon for the same is C:\Cygwin\Cygwin.ico. This gist assumes that you have run the following in a Cygwin window: svn --force export http://apt-cyg.googlecode.com/svn/trunk/ /bin/ chmod +x /bin/apt-cyg apt-cyg install ncurses chere chere -i -s bash After running all these commands in Cygwin command window, run this registry file to change the overall display of Bash handy access on right click of a folder, drive or background.

This example shows a Windows registry snippet that adds a “Bash” option to the right-click context menu for folders, drives, and the desktop background, enabling quick access to a Cygwin terminal. The registry file writes entries under `HKEY_CLASSES_ROOT` and `HKEY_LOCAL_MACHINE`, using shell command keys like `cygwin_bash` and `Command` to invoke `C:\Cygwin\bin\bash -c "/bin/xhere /bin/bash.exe '%v'"`. It also sets an icon via `Cygwin.ico`, and includes hex-encoded command strings for full path compatibility. The snippet relies on the `chere` utility for Cygwin integration.

Jun 27, 2013
Loading thumbnail…

Windows specific registry snippet: This gist is useful for getting Console2 (http://sourceforge.net/projects/console) on right click of a folder, drive or background. This gist assumes that Console2 is installed and accessible from C:\Apps\Shells\Console2\Console.exe and the icon for the same is C:\Apps\Shells\Console2\Console.ico.

This gist presents a Windows Registry snippet, authored by P7h, that configures the Windows Explorer context menu to launch Console2 from a folder, drive, or background. The code shows the registry structure, using `hex(2)` value types for the icon path and string values for commands. It creates context menu entries under `HKEY_CLASSES_ROOT` and `HKEY_LOCAL_MACHINE`, pointing to `C:\Apps\Shells\Console2\Console.exe` with appropriate arguments to open the selected directory. The snippet demonstrates the raw registry file format (`Windows Registry Editor Version 5.00`) and its hierarchical key/value structure for adding shell extensions.

Jun 27, 2013
Loading thumbnail…

Performance tuning parameters for Eclipse IDE. Add these params in eclipse.ini in Eclipse.

This example visualizes the performance-tuning parameters for Eclipse IDE as a static list, showing each flag and its value from a gist by P7h. It renders the `eclipse.ini` contents in plain text, highlighting JVM arguments like `-Xms1024m`, `-Xmx1024m`, and `-XX:+UseG1GC`. The display uses no interactive libraries or data manipulation; it simply presents the raw configuration lines, sourced from a text file, to make the tuning options readable at a glance.

Dec 29, 2012
Loading thumbnail…

Plugins I use in Eclipse IDE.

This visualization displays a collection of Eclipse IDE plugins as a network of connected nodes, emphasizing relationships between tools and their associated URLs. The data originates from a text file listing plugin names and descriptions, parsed into a graph structure. Using D3.js’s force-directed layout via `d3.forceSimulation`, nodes are positioned dynamically, with edges linking plugins to their source links. Each node is rendered as a labeled circle, and the graph’s size and spacing adapt through iterative simulation, providing an interactive overview of the plugin ecosystem without revealing detailed metadata.

Dec 27, 2012
Loading thumbnail…

Plugins I use in IntelliJ IDEA.

A force-directed network diagram maps the plugins the author uses in IntelliJ IDEA, with each plugin name as a node. The visualization shows the relationships between the seven plugins, clustering them by their functions as described in the accompanying text. Built with D3.js, it uses `d3.forceSimulation` and `d3.forceManyBody` to position nodes, while `d3.drag` enables interaction. Node labels display the plugin names, and the data originates from a plain-text gist file that lists each plugin with a short description.

Dec 27, 2012
Loading thumbnail…

For importing Blogger format posts to Octopress compatible posts.

This Ruby script converts an exported Blogger XML file into Octopress-compatible posts and drafts. It uses Nokogiri to parse the XML, extracting posts, comments, and metadata like titles, dates, and categories. The script organizes entries into published and draft folders, generating YAML front matter and HTML content for each post, while preserving comment threads. It demonstrates a batch migration workflow for static site generators.

Feb 11, 2012