Skip to main content
Log in
F

Franklin Chen

@FranklinChen·18 public vizzes

Loading thumbnail…

SVG stuff

This example shows a single red circle centered on an SVG canvas, demonstrating the basic structure of an SVG rendering within an HTML page. It uses the `circle` element with `cx`, `cy`, and `r` attributes to position and size the shape, and a `fill` attribute to set its color. The code relies on the HTML5 `<svg>` tag directly inside the document body, with no external JavaScript or framework dependencies. This serves as a minimal introduction to vector graphics creation via inline markup.

Mar 15, 2021
Loading thumbnail…

Keybase proof

This example shows a Keybase proof as a signed JSON object, demonstrating how a GitHub user can cryptographically authenticate their identity across services. The visualization renders the proof’s structure, highlighting the embedded public key, signature, and metadata fields. The code parses the JSON payload and uses the Keybase API to verify the signature, while a custom SVG layout maps the hierarchical relationships between the user, service, and cryptographic elements. The data source is the gist’s raw content, and the rendering approach relies on d3.js for hierarchical node placement and Canvas for signature visualization, making the authentication flow transparent.

Nov 28, 2016
Loading thumbnail…

shibboleth-sp on macOS 10.12 - Homebrew build logs

This visualization presents the Homebrew build logs for shibboleth-sp on macOS 10.12 as a raw, terminal-style text document. The data, sourced from a gist by FranklinChen, displays the complete build output including environment configuration, system checks, and compilation errors. The visualization uses monospaced typography and preserves the original log structure, with timestamps marking each build stage. The key visual element is the contrast between the clean, timestamped log entries and the highlighted error messages that signal build failure, making it easy to scan for the critical information amidst the verbose output.

Sep 28, 2016
Loading thumbnail…

Shared via Rust Playground

This example demonstrates how multiple threads can safely share and mutate a counter using Rust’s concurrency primitives. It shows the `Arc<Mutex<Toaster>>` pattern, where an atomic mutex lock protects the `count` field from race conditions. The code spawns three threads via `thread::spawn`, each cloning the `Arc` handle and acquiring the lock with `toaster.lock().unwrap()` before incrementing the count. The output prints each thread’s index, which is assigned from the prior value of `count` before incrementing. The example uses the standard library’s `std::sync::{Arc, Mutex}` and `std::thread` APIs, with no external data source or rendering—purely console output.

Nov 15, 2015
Loading thumbnail…

Shared via Rust Playground

This example simulates a concurrent breakfast scenario using Rust's standard library. It shows how multiple attendee threads send bagels through channels to a single toaster thread, which toasts them and returns them via acknowledgment channels. The visualization highlights thread synchronization and message passing with `std::thread::spawn`, `std::sync::mpsc::channel`, and channel send/receive operations. The code prints toasting progress and final consumption messages, illustrating the choreography of concurrent tasks through inter-thread communication. No external libraries or data sources are used; the rendering is purely textual output from the console.

Nov 15, 2015
Loading thumbnail…

Gist 133cb61af931a08bbe20

This example demonstrates recursive directory traversal as a streaming pipeline in Haskell, yielding each file path as a producer. The code uses the `Pipes` library, with `getRecursiveContents` recursively descending into subdirectories via `getDirectoryContents` and filtering out `.` and `..`. Each file path is then piped through `P.map` to prefix `"Found file "` and sent to `P.stdoutLn` for output. The main function takes a starting path from command-line arguments via `getArgs`, illustrating a functional, lazy approach to filesystem enumeration.

Oct 20, 2015
Loading thumbnail…

Merge a list of annotations into selected nodes of a tree, with error recovery and reporting

The example demonstrates a Haskell prototype for merging a list of labels into selected nodes of a tree structure, with explicit error recovery when labels run out. It shows how the `merge` function, built on `Control.Monad.State` and `traverse`, pairs each `Right` leaf with an annotation, returning leftover labels if too many are supplied. When labels are insufficient, missing ones are marked with `Nothing`, and `contentsMissingLabels` collects those unlabeled values for reporting. The code uses the `Content` and `Annotated` data types with `Functor`, `Foldable`, and `Traversable` instances, and verifies behavior via HSpec tests.

Apr 26, 2015
Loading thumbnail…

"" + 0

This example humorously demonstrates Haskell’s typeclass overloading by defining a `Value` type that can behave like both a number and a string. It uses the `Num` and `IsString` instances to make the expression `"" + 0` compile and evaluate to the string `"0"`. The code relies on the `OverloadedStrings` language extension and the `Data.String` module, while the `Show` instance outputs the underlying representation. The gist illustrates how Haskell’s ad-hoc polymorphism can mimic loosely-typed language syntax.

Oct 11, 2014
Loading thumbnail…

Example of point-free style

This example demonstrates how to compose functions in a point-free style using Haskell’s `Control.Category` operator `(>>>)`. The code defines a `matches` function that checks whether a given string equals an `Option`’s name prefixed with `"--"`, without explicitly mentioning the arguments. It shows the data flow by chaining `name`, `("--" ++)`, and `(==)` together, making the logic declarative. The example uses a custom `Option` data type and a sample `helpOption` to test the matching with `"--help"`. The source is a gist by FranklinChen, illustrating readable point-free composition in a functional programming context.

Oct 6, 2014
Loading thumbnail…

Spark line

This example renders a stream of numbers as a row of sparkline glyphs, using Unicode block characters whose vertical position encodes each value relative to the dataset’s minimum and maximum. Written in Haskell, it processes input from standard input or command-line arguments via `System.Environment.getArgs` and `Data.ByteString.Char8`. The `buildInOnePass` function uses a lazy circular fold over the list to compute min/max and generate UTF-8 bytes for the eight possible block levels, requiring only a single pass over the data.

Aug 3, 2014
Loading thumbnail…

Gist ec627b32670dd31f4028

This example demonstrates a modular approach to building and testing effectful programs using the free monad pattern in Scala. It defines a `Free` monad to sequence interactions like console prompts and authentication checks, with interpreters separating execution from logic. The code uses type classes `Monad`, natural transformations (`~>`), and coproducts to compose independent algebras (`Interact` and `Auth`). It shows both a production interpreter (`Console`) and a pure test interpreter (`TestConsole`) that returns output lists from a static input map, highlighting how to decouple I/O from program structure.

Jun 17, 2014
Loading thumbnail…

Gist 10288187

This example demonstrates the importance of bounds checking in C++ vector access. It uses the `std::vector` class and its `.at()` method, which throws an exception when the given index is out of range, in contrast to the unchecked `[]` operator. A loop iterates from zero to four over a vector containing three integers, triggering an out-of-range error that is caught by an `exception` handler. The code also shows a custom destructor message when a `Foo` object, managed via `make_shared`, is cleaned up.

Apr 9, 2014
Loading thumbnail…

For @BillLaboon hey @franklinchen is there an easy way in Haskell to find out which element in a list is most common, e.g. [1,1,1,2,3] -> 1 ?

This example demonstrates a Haskell function that identifies the most frequently occurring element in a list, returning `Just 1` for `[1,1,1,2,3]`. It uses a priority queue from the `Data.PSQueue` library, where each element’s priority is stored as a `Data.Ord.Down` value, allowing the minimum (i.e., highest count) to be retrieved via `PSQueue.findMin`. The `updateQueue` function increments counts using `PSQueue.alter`, and the code includes a unit test with `Test.HUnit`. The data source is an inline list literal passed to `mostCommon`.

Nov 18, 2013
Loading thumbnail…

Tree traversal in Ruby, a response to http://michaelfeathers.typepad.com/michael_feathers_blog/2013/02/sub-tree-selection-with-flattenselect.html

This example demonstrates a preorder tree-traversal algorithm in Ruby, using the `TreeEnumerable` class and the `Enumerable` mixin to flatten a nested abstract syntax tree (AST) into a list of matching subtrees. The `sexp_select` method filters nodes by their symbol type, such as `:@ivar`, returning only those subtrees. The code relies on Ruby’s `find_all` from `Enumerable` and a custom `tree_traverse` that yields each array node recursively. The example includes a MiniTest unit test (`TestTreeSelect`) that asserts the filtered result from a hardcoded parse-tree structure, showing how the selection works on real S-expression data.

Feb 15, 2013
Loading thumbnail…

Gist 0e59d1c2d63aaea35573

This example demonstrates benchmark-driven optimization of recursion schemes in Haskell, using the Criterion library’s `defaultMain`, `bgroup`, and `bench` functions to measure performance. The code defines catamorphisms (`ffold`), anamorphisms (`funfold`), hylomorphisms, and build functions (`fbuild`, `funbuild`), then applies them to natural numbers, lists, and trees. It highlights how `INLINE` pragmas and `RULES` for fusion (e.g., `ffold/fbuild`) improve execution speed, as shown in benchmarks like `lengthL`, `mapL`, and `depthT` over sample data structures.

Jan 6, 2013
Loading thumbnail…

Knuth/McIlroy word count task using Haskell

This example demonstrates a word-frequency analysis task using Haskell, showing how to compute and display the most common words from standard input. It chains data transformations through a pipeline: converting text to lowercase, replacing non-letter characters with newlines, splitting into words, and tallying counts with a hash map. The code relies on `Data.HashMap.Strict` for efficient key-value aggregation via `HashMap.fromListWith`, and uses `Data.List` for sorting and taking the top *n* results. The final output lists each word with its count, sorted in descending order of frequency. The example highlights functional composition and lazy evaluation in a concise, read-backwards data-flow style.

Dec 9, 2011
Loading thumbnail…

Most basic inheritance in C

This example contrasts the most basic inheritance pattern in C and C++ by displaying side-by-side source code. It shows how C++ uses virtual functions and classes to achieve runtime polymorphism, while C relies on manual vtable structs and function pointers to mimic the same behavior. The visualization highlights the structural differences in API design, such as C++’s `virtual` keyword and `class` syntax versus C’s explicit `Animal_vtable` and cast function pointers. The code’s output—identical for both languages—is implied through the `printf` and `cout` calls, but no rendering library is used; the data is the source itself.

Nov 7, 2011
Loading thumbnail…

C++ abuse: simple example

This example demonstrates the dangerous consequences of low-level memory manipulation in C++, where swapping an object’s vtable pointer with another object’s changes its runtime behavior. The code uses raw `void*` casts and pointer arithmetic in the `transmigrate` and `brain_damage` functions to overwrite the virtual function table entries of a `Dog` object with those of a `Cat`, causing the program to call the wrong virtual methods. The output sequence—showing `Dog::food()` initially, then `Cat::food()` after the swap, and finally undefined behavior after the vtable corruption—illustrates how such manual pointer juggling bypasses type safety and virtual dispatch. The example relies solely on standard C++ features like virtual functions, inheritance, and explicit pointer casts, with no external libraries.

Oct 5, 2011