Code Explainers

Browse the library

ruby 
# Binary search using Ruby's built-in Array#bsearch.
#
# There are two modes:
#   1. find-minimum mode  -> block returns true/false (monotonic)

Binary search patterns with Ruby's bsearch

binary-search algorithms ranges
Intermediate 7 steps
typescript 
type NestedArray<T> = Array<T | NestedArray<T>>;
 
function flatten<T>(input: NestedArray<T>): T[] {
  const result: T[] = [];

Recursively flattening nested arrays in TypeScript

recursion recursive-types generics
Intermediate 7 steps
java 
import java.util.ArrayDeque;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.HashSet;

Breadth-first search on an adjacency-list graph

graph-traversal bfs adjacency-list
Intermediate 7 steps
javascript 
function flatten(arr) {
  const result = [];
  for (const item of arr) {
    if (Array.isArray(item)) {

Flattening nested arrays with recursion

recursion arrays reduce
Intermediate 7 steps
ruby 
class LinkedList
  include Enumerable
 
  Node = Struct.new(:value, :next_node)

Building an enumerable linked list in Ruby

linked-list enumerable data-structures
Intermediate 7 steps
javascript 
function getCityName(user) {
  return user?.address?.city ?? "Unknown city";
}
 

Optional chaining and nullish coalescing in JS

optional-chaining nullish-coalescing defensive-coding
Intermediate 5 steps
typescript 
class LRUCache<K, V> {
  private readonly capacity: number;
  private readonly map: Map<K, V>;
 

Building an LRU cache on a JS Map

caching data-structures generics
Intermediate 8 steps
ruby 
module FileResource
  # Opens a file, yields it to the caller, and guarantees the
  # handle is closed even if the block raises an exception.
  def self.open(path, mode = "r")

Guaranteeing cleanup with begin/ensure in Ruby

resource-management exception-safety blocks
Intermediate 8 steps
rust 
use std::sync::mpsc;
use std::thread;
use std::time::Duration;
 

A worker thread driven by Rust channels

concurrency message-passing channels
Intermediate 8 steps
java 
public final class Quicksort {
 
    private Quicksort() {
    }

Quicksort with Lomuto partitioning in Java

recursion divide-and-conquer in-place
Intermediate 7 steps
go 
package geometry
 
import "fmt"
 

Implementing fmt.Stringer in Go

interfaces stringer composition
Beginner 5 steps
javascript 
function throttle(fn, wait) {
  let lastCall = 0;
  let timeoutId = null;
  let lastArgs = null;

Building a leading-and-trailing throttle

closures rate-limiting timers
Advanced 6 steps
typescript 
type Split<S extends string, D extends string> =
  S extends `${infer Head}${D}${infer Tail}`
    ? [Head, ...Split<Tail, D>]
    : [S];

Type-level string parsing in TypeScript

template literal types conditional types recursive types
Advanced 8 steps
javascript 
async function* fetchPages(baseUrl, maxPages) {
  let page = 1;
  while (page <= maxPages) {
    const data = await mockFetch(`${baseUrl}?page=${page}`);

Paginated APIs with async generators

async-iterators generators pagination
Advanced 7 steps
javascript 
const PENDING = 'pending';
const FULFILLED = 'fulfilled';
const REJECTED = 'rejected';
 

Building a Promise from scratch

promises state-machine microtasks
Advanced 10 steps
javascript 
function delegate(root, eventType, selector, handler) {
  const listener = (event) => {
    let node = event.target;
    while (node && node !== root) {

Event delegation with a clean teardown

event-delegation dom closures
Intermediate 8 steps