2026

Sept 2026

Week 4 (09/21 - 09/27)

• ✅ Low Level Design: Cancellation in .NET
• Low Level Design: OOP Concepts and Design Patterns (transcribe annotations)
• Low Level Design: Concurrency (Introduction, Correctness)
• Low Level Design: Problem Breakdown - Parking Lot
• Think Bayes: Ch. 1-2 (transcribe annotations), Ch. 3 Estimation
• [MAS S67] The Great Problems: Introduction and Mental Health module
• Calling Bullshit: Introduction, Spotting Bullshit

Week 3 (09/14 - 09/20)

• ⌛ Low Level Design: OOP Concepts and Design Patterns (transcribe annotations)
• ❌ Low Level Design: Concurrency: Introduction, Correctness
• ❌ Low Level Design: Problem Breakdown - Parking Lot
• ❌ Low Level Design: Problem Breakdown - Rate Limiter
• ❌ [MAS S67] The Great Problems: Introduction and Mental Health module
• ⌛ Think Bayes: Ch. 1-2 (annotated but not fully transcribed to repo)
• ❌ The Rape of Nanking : Ch. 3-5 (library book expired; on hold for next slot)

Week 2 (09/07 - 09/13)

• ✅ Transfer remaining notes into “Kaburi Bila Msalaba”
• ⌛ Low Level Design: Fundamentals : Still need to transcribe annotations on “OOP Concepts” and “Design Patterns”
• ✅ Basketball: reading plays - DIVE, SWING, HAWK, HORNS, FLIP
• ❌ Low Level Design: Concurrency
• ❌ Low Level Design: Problem Breakdowns: Parking Lot, Rate Limiter
• ❌ Think Bayes: Ch. 1-2
• ❌ Calling Bullshit: Intro, Spotting, Causality
• ❌ The Rape of Nanking : Ch. 3-4

Cancellation

Sourced from . Notes

1. ✅ Overview: cooperative cancellation; the 90% case; the cancellation contract; exceptions to the “90% case”
2. ✅ Requesting Cancellation: CancellationTokenSource; timeouts; manual cancellation; cancelling and disposing
3. ✅ Detecting Cancellation: responding to cancellation; TaskCanceledException; OperationCanceledException.CancellationToken
4. ✅ Polling: how to poll; how not to poll; when to poll
5. ✅ Registration: how to register; a race condition; cleanup is important; synchronous cancellation callbacks
6. ✅ Linking: linked cancellation tokens; use cases; don’t use OperationCanceledException.CancellationToken

References

1. Cancellation, Part 1: Overview. Stephen Cleary. blog.stephencleary.com . Accessed Sep 22, 2026.

Overview

Cancellation is cooperative. One part of the code politely notifies the other code that it’d like it to please stop. The responding code may immediately stop, or continue until it reaches a valid stopping point, or ignore the cancellation request entirely.

Most code has the form:

async Task DoSomethingAsync(int data, CancellationToken cancellationToken)
{
  var intermediateValue = await DoFirstStepAsync(data, cancellationToken);
  await DoSecondStepAsync(intermediateValue, cancellationToken);
}

… where the CancellationToken is passed down to whatever APIs you call.

By convention, the CancellationToken is the last in the method signature:

Singleton

Singleton ensures only one instance of a class exists. Useful when you need exactly one shared resource like a connection pool, logger, etc. Most times, passing shared objects through constructors is clearer, works, and easily testable.

Sample

public class DatabaseConnection
{
  public static DatabaseConnection Instance
  {
    get
    {
      _instance ??= new DatabaseConnection();
      return _instance;
    }
  }

  private static DatabaseConnection? _instance;
  private DatabaseConnection() {}
}

… with usage:

var db = DatabaseConnection.Instance;
var users = db.Query("SELECT * FROM users");

In multi-threaded scenarios, C# offers Lazy<T> w/ options for ensuring thread safety, e.g., LazyThreadSafetyMode.ExecutionAndPublication ensures that only a single thread can initialize a Lazy<T> instance, and set (publish) the value of the Lazy<T> instance. T is initialized the first time Lazy<T>.Value is accessed.

Builder Pattern

Shows up when designing things like HTTP requests, configuration objects, etc. Instead of a ctor with 10 parameters where half are null, you build the object incrementally, e.g.,

public class HttpRequest
{
  public string? Url { get; private set; }
  public string? Method { get; private set; }
  public Dictionary<string, string> Headers { get; private set; }
  public string? Body { get; private set; }

  private HttpRequest() {}

  public class Builder
  {
    private readonly HttpRequest _request = new();

    public Builder Url(string url) { ... }
    public Builder Method(string method) { ... }
    public Builder Body(string body) { ... }

    public Builder Header(string key, string value)
    {
      _request.Headers ??= new Dictionary<string, string>();
      _request.Headers[key] = value;
      return this;
    }

    public HttpRequest Build()
    {
      if (string.IsNullOrWhiteSpace(_request.Url))
        throw new InvalidOperationException("URL is required");

      return request;
    }
  }
}

… with usage like:

var request new HttpRequest.Builder()
  .Url("https://foo.com")
  .Method("GET")
  .Build();

System Design

See for bite-sized groups that are digestible in a week’s period.

In a Hurry

• Introduction
• How to Prepare
• Delivery Framework
• Core Concepts
• Key Technologies
• Common Patterns
• Question Breakdowns

Core Concepts

• Networking Essentials
• API Design
• Data Modeling
• Database Indexing
• Caching
• Sharding
• Consistent Hashing
• CAP Theorem
• Numbers to know

Question Breakdowns

• Bitly
• Dropbox
• Yelp
• Local Delivery Service
• Ticketmaster
• Instagram
• FB News Feed
• Tinder
• LeetCode
• WhatsApp
• Strava
• Distributed Cache
• Rate Limiter
• Online Auction
• YouTube
• Job Scheduler
• FB Live Comments
• News Aggregator
• Price Tracking Service
• Notification System
• YouTube Top K
• Uber
• Robinhood
• Google Docs
• Web Crawler
• Ad Click Aggregator
• FB Post Search
• Payment System
• Metrics Monitoring
• Online Chess
• ChatGPT
• Flash Sale

Patterns

• Real-time Updates
• Dealing with Contention
• Multi-step Processes
• Scaling Reads
• Scaling Writes
• Handling Large Blobs
• Managing Long Running Tasks

Key Technologies

• Redis
• Elasticsearch
• Kafka
• API Gateway
• Cassandra
• DynamoDB
• PostgreSQL
• Flink
• Zookeeper

Advanced Topics

• Proximity Search
• Data Structures for Big Data
• Vector Databases
• Time Series Databases
• Change Data Capture

In the Wild

• How Shopify Moved Inventory Reservations from Redis to MySQL
• How Discord Moved Trillions of Messages to ScyllaDB
• How Slack Put Kafka in Front of Its Redis Job Queue
• How Figma Built Multiplayer Editing on Simplified CRDTs
• How Spotify Serves Point Queries from an Exabyte Data Lake

Code

Two Pointers

• Overview
• Container With Most Water
• Two Sum (Sorted Array)
• 3-Sum
• Triangle Numbers
• Move Zeroes
• Sort Colors
• Trapping Rain Water

Sliding Window

• Overview
• Maximum Sum of Subarrays of Size \(k\)
• Max Points You Can Obtain from Cards
• Max Sum of Distinct Subarrays of Length \(k\)
• Overview
• Longest Substring Without Repeating Characters
• Longest Repeating Character Replacement

Intervals

• Overview
• Can Attend Meetings
• Insert Interval
• Non-Overlapping Intervals
• Merge Intervals
• Employee Free Time

Stack

• Overview
• Valid Parentheses
• Decode String
• Longest Valid Parentheses
• Monotonic Stack
• Daily Temperatures
• Largest Rectangle in Histogram

Linked List

• Overview
• Linked List Cycle
• Palindrome Linked List
• Remove Nth Node from End of List
• Reorder List
• Swap Nodes in Pairs

Binary Search

• Overview
• Apple Harvest (Koko Eating Bananas)
• Search in a Rotated Sorted Array
• Split Array Largest Sum
• Kth Smallest Element in a Sorted Matrix
• Minimum Shipping Capacity

Heap

• Overview
• Kth Largest Element in an Array
• K Closest Points to Origin
• Find K Closest Elements
• Merge K Sorted Lists
• Median from Data Stream

Depth-First Search

• Introduction
• Fundamentals
• Return Values
• Maximum Depth of Binary Tree
• Path Sum
• Passing Values Down and Helper Functions
• Validate Binary Search Tree
• Calculate Tilt
• Diameter of a Binary Tree
• Path Sum II
• Longest Univalue Path
• Graphs Overview
• Adjacency List
• Copy Graph
• Graph Valid Tree
• Matrices
• Flood Fill
• Number of Islands
• Surrounded Regions
• Pacific Atlantic Water Flow

Breadth-First Search

• Introduction
• Overview
• Level Order Sum
• Rightmost Node
• Zigzag Level Order
• Maximum Width of Binary Tree
• Graphs Overview
• Minimum Knight Moves
• Rotting Oranges
• 01-Matrix
• Bus Routes

Backtracking

• Overview
• Word Search
• Solution Space Trees
• Subsets
• Generate Parentheses
• Combination Sum
• Palindrome Partitioning
• N-Queens

Graphs

• Overview
• Course Schedule
• Course Schedule II
• Shortest Path Algorithms
• Network Delay Time
• Cheapest Flights Within K Stops
• Path with Minimum Effort
• Find City with Fewest Reachable

Dynamic Programming

• Fundamentals
• Solving a Question with Dynamic Programming
• Counting Bits
• Decode Ways
• Unique Paths
• Maximal Square
• Longest Increasing Subsequence
• Word Break
• Maximum Profit in Job Scheduling
• Paint House
• Paint House II
• Minimum Window Subsequence

Greedy Algorithms

• Overview
• Best Time to Buy and Sell Stock
• Gas Station
• Jump Game
• Jump Game II
• Partition Labels

Trie

• Overview
• Implement Trie Methods
• Prefix Matching

Prefix Sum

• Overview
• Count Vowels in Substrings
• Subarray Sum Equals \(K\)

Matrices

• Spiral Matrix
• Rotate Image
• Set Matrix Zeroes

Low Level Design

Low Level Design in a Hurry

• ✅ Introduction
• ✅ Delivery Framework
• ✅ Design Principles
• ✅ OOP Concepts
• Design Patterns

Concurrency

• Introduction
• Correctness
• Coordination
• Scarcity

Problem Breakdowns

• Connect Four
• Amazon Locker
• Elevator
• Parking Lot
• File System
• Movie Ticket Booking
• Logging Service
• Rate Limiter
• Inventory Management

Behavioral

• Why the Behavioral Matters
• Decode: How Interviews Work
• Select: Choosing Responses
• Deliver: Telling a Good Story
• The Big Three Questions
• Adapting to Big Tech
• Practicing
• Common Pitfalls
• Special Interview Types
• Answering AI Questions

AI Coding

Overview

• Introduction
• Interview Formats
• Patterns
• How to Prepare

Fundamentals

• Codebase Orientation
• Planning Your Approach
• Driving the AI
• Verification & Testing
• Communication

Common Patterns

• Graph Search & Pathfinding
• Topological Sort
• Backtracking
• Greedy & Bin Packing
• Dynamic Programming
• String Matching and Parsing
• Data Structure Design

AI Coding Problem Breakdowns

• Battleship
• Inventory Packer
• Spell Checker
• Card Game
• Friend Recommender
• Maze Solver
• Route Planner
• Task Scheduler
• Word Container
• Connect Four
• Kitchen Orders
• Maximize Unique Characters
• Nonogram Solver

ML System Design

ML System Design in a Hurry

• Introduction
• Delivery Framework

ML System Design Core Concepts

• Feature Engineering
• Embeddings
• Generalization
• Evaluation

ML System Design Question Breakdowns

• Harmful Content
• Bot Detection
• Video Recommendations

References

1. System Design Course | Hello Interview. www.hellointerview.com . Accessed Sep 6, 2026.
2. Data Structures and Algorithms Introduction | Hello Interview. www.hellointerview.com . Accessed Sep 6, 2026.

Probability is a Fraction of a Finite Set

A simplified definition: a probability is a fraction of a finite set. For example, in the 2024 GSS survey, of the 3,986 respondents, 42 were bankers. If we choose a person from this population at random, the probability that they are a bank teller is 1.054%.

Eternals Vol. 3 (2006). Neil Gaiman; John Romita Jr.. www.marvel.com . www.hoopladigital.com . 2006.

Eternals Vol. 5 (2021). Kieron Gillen; Esad Ribić. www.marvel.com . www.hoopladigital.com . marvel.fandom.com .

Snapshots

Origin of Life

Mark Evanier: Can you prove that ancient civilizations weren’t visited by space travellers and heralded as gods? Did those aliens alight on this planet eons ago and plant the seeds of our civilization?

A random process is ergodic if all of its statistics can be determined from a sample function of the process. That is, the ensemble averages equal the corresponding time averages with probability one.

Role of Ergodicity in Human Inference

A newspaper has previously printed some inaccurate information, therefore, the newspaper is going to publish inaccurate information in the future. Fair; ensemble of published articles is more or less ergodic.

More crimes are committed by black persons than by white persons, therefore each individual black person is not to be trusted? The ensemble of black people is not at all ergodic!

The Formula

By definition…

$$ \mathbb{P}(A) = \mathbb{P}(A \cap B) + \mathbb{P}(A \cap B^{c}) $$

From conditional probability …

$$ \mathbb{P}(A) = \mathbb{P}(A|B) \ \mathbb{P}(B) + \mathbb{P}(A|B^c) \ \mathbb{P}(B^c) $$

Therefore

$$ \mathbb{P}(B|A) = \frac{ \mathbb{P}(B \cap A) }{ \mathbb{P}(A) } $$ $$ = \frac{ \mathbb{P}(A|B) \mathbb{P}(B) }{ \mathbb{P}(A|B) \ \mathbb{P}(B) + \mathbb{P}(A|B^c) \ \mathbb{P}(B^c) } $$

Definition

Where \( \mathbb{P}(A|B) \) is the probability of event \(A\) given that event \(B\) occurs:

$$ \mathbb{P}(A|B) = \frac{\mathbb{P}(A \cap B)}{\mathbb{P}(B)} $$

Notice that if \(P(B) = 0\) then it’s meaningless to condition \(A\) on \(B\).

Satisfying the Axioms of Probability

Axiom 1: Normalization

$$ \mathbb{P}(B|B) = \frac{\mathbb{P}(B \cap B)}{\mathbb{P}(B)} = 1 $$

Axiom 2: Non-negativity

Because \(A \cap B \subseteq B \), then \( 0 \le \mathbb{P}(A|B) \le 1 \).

\(X\) is a binomial random variable if it takes the values \(0, 1, 2, …, n\) and

$$ \mathbb{P}\{X = k\} = { n \choose k } \cdot p^k \cdot (1 - p)^{n-k} $$

Sanity Check: Do the probabilities sum to 1?

$$ \sum_{k=0}^{n} \mathbb{P}\{X = k\} = \sum_{k=0}^{n} { n \choose k } p^k (1 - p)^{n-k} = \left( p + (1 - p) \right)^n = 1 $$

Bernoulli Process

A Bernoulli Process is a sequence of independent \({0, 1}\) - valued random variables \(X_1, X_2, X_3, …\), e.g. \(0, 0, 1, 0, 1, 1\)

Suppose you flip a coin repeatedly, and record \(0\) for tails and \(1\) for heads.

Introduction

WWII started on different days for different people. For Africans, 1935 when Mussolini invaded. For Europeans, Sept 1939 when Hitler invaded Poland. For Americans, Dec 1941 when Japan attacked Pearl Harbor. For Asians, 1931 when Japan occupied Manchuria.

A factory is a helper that makes the right kind of object for you so you don’t have to decide. That said, factories are polarizing because some engineers view them as examples of engineering.

Simple Factory

Factory shows up when requirements say something like “support different notification types”, e.g.,

public interface INotification
{
  void Send(string message);
}

public class EmailNotification : INotification
{
  public void Send(string message) { ... }
}

public class SmsNotification : INotification
{
  public void Send(string message) { ... }
}

enum NotificationType { Email, Sms }

public static class NotificationFactory
{
  public static INotification Create(NotificationType notificationType) =>
    notificationType switch {
      NotificationType.Email => new EmailNotification(),
      NotificationType.Sms => new SmsNotification(),
      _ => throw new ArgumentException("Unknown type")
    };
}

… where clients do var notification = NotificationFactory.Create(NotificationType.Sms).

Notes

• Introduction
• A Case Study: Designing a Document Editor

Design Pattern Catalog

• Creational Patterns: Abstract Factory; Builder; Factory Method; Prototype; Singleton.

• Structural Patterns: Adapter; Bridge; Composite; Decorator; Façade; Flyweight; Proxy.

• Behavioral Patterns: Chain of Responsibility; Command; Interpreter; Iterator; Mediator; Memento; Observer; State; Strategy; Template Method; Visitor.

• Conclusion

Design Patterns: Elements of Reusable Object-Oriented Software. Erich Gamma; Richard Helm; Ralph Johnson; John Vlissides. www.uml.org.cn . Aug 1, 1997.

Intent

A one-to-many dependency between object so that when one object (subject) changes, all its dependents (observers) are notified and update automatically.

Redis Basics

Redis is a key-value store that lives in memory, and executes one command at a time. In-memory nature makes it very fast (a single node can handle 100K writes per second), while the sequential model makes it easy to reason about operations.

Redis has two persistence modes. RDB takes periodic snapshots, and AOF logs every write but only fsyncs once per second by default – therefore, Redis is not durable. While you can configure AOF to fsync on every write, you’d lose the speed that you came to Redis for.

Dependency Inversion Principle

Your code should depend on abstractions, not concrete implementations. Instead of:

public class EmailSender
{
  public void Send(string message) { ... }
}

public class NotificationService
{
  private readonly EmailSender _emailSender = new();

  public void Notify(string message) => _emailSender.Send(message);
}

… have:

public interface IMessageSender
{
  void Send(string message);
}

public class EmailMessageSender : IMessageSender
{
  public void Send(string message) { ... }
}

public class NotificationService(IMessageSender messageSender)
{
  public void Notify(string message) => messageSender.Send(message);
}

… so that swapping out an EmailMessageSender for an SmsMessageSender is easy. Even more commonly, unit testing NotificationService with a MockMessageSender that doesn’t send real messages.

Notes from Chromium

Phrased differently, inversion of control allows users of a framework/library (clients) to customize the behavior of the framework. The control flow is inverted because the library (e.g., NotificationService) calls back into the client’s code (e.g., the specific IMessageSender implementation) so that control flows back from a low-level class to a high-level class. .

What Are Design Patterns?

Arriving at designs that are specific to the problem at hand but general enough to address future problems and requirements is hard. New designers tend to be overwhelmed by the options available. Expert designers do not solve every problem from first principles; they reuse design patterns.