A channel is a data structure that’s used to store produced data for a consumer to retrieve, and an appropriate synchronization to enable that to happen safely, while also enabling appropriate notifications in both directions.

A Toy Channel

public sealed class Channel<T> {
  // Use a thread-safe data store to free us from locking semantics for any
  // number of producers and consumers.
  private readonly ConcurrentQueue<T> _items = new ConcurrentQueue<T>();

  // A mechanism for coordinating between producers and consumers.
  private readonly SemaphoreSlim _semaphore = new Semaphore(0);

  public void Write(T item)
  {
    _items.Enqueue(item); // Store the data.
    _semaphore.Release(); // Notify any consumers that more data is available.
  }

  public ValueTask<T> ReadAsync(CancellationToken ct = default)
  {
    await _semaphore.WaitAsync(ct).ConfigureAwait(false); // Wait for data to be available.
    bool gotOne = _items.TryDequeue(out T item);
    Debug.Assert(gotOne);
    return item;
  }
}

Notes

For read-heavy applications, storing frequently accessed data in fast memory (e.g., Redis) allows you to skip the DB entirely for some reads. A cache hit on Redis takes ~1ms compared to 20-50ms for a typical DB query, and this speedup is impactful in the order of millions of requests. In a web application, user sessions are typically stored in a distributed cache, allowing the system to quickly retrieve the data when a user makes a request.

Streams and Event Sourcing

Unlike message queues , streams can retain data for a configurable period of time, allowing consumers to read and re-read messages from a specified time. You can use a stream to ingest high volumes of events in real-time, e.g., real-time analytics of user engagements in social media.

Event sourcing involves storing changes in application state as a sequence of events. These events can be replayed to reconstruct the system’s state at any point in time. The technique is useful for systems that require a detailed audit trail, e.g., a banking system, where every transaction (deposits, withdrawals, transfers) need to be recorded and may affect multiple accounts.

Sharding

Sharding comes up when a single database won’t work (e.g., hit storage limits, write throughput limits, or read throughput limits) and you need to split your data across multiple independent servers.

For a user-centric social media app, sharding by user_id means all of a user’s posts, likes, and comments live on one shard. User-scoped queries are fast, but “trending posts across all users” become expensive because of hitting every shard and aggregating results. Mutating transations need to account for the distributed nature of the shards, making them complex and slow.

Blob Storage

Unstructured blobs of data include images, videos, and other files. Typically, these are stored in blob storage, and the core database stores metadata, e.g., blob URL.

Blob storage solutions like S3 can be considered infinitely scalable within your account limits. They are also cost effective, e.g., AWS S3 charges $0.023 per GB per month for the first 50TB, compared to AWS DynamoDB that charges $1.25 per GB per month for the first 10TB of storage.

Data Modeling

Choosing what data to store and how to structure it directly affects performance, scalability, and maintenance.

Relational databases are useful when you have structured data with clear relationships and need strong consistency (transaction-based actions, enforcing foreign key constraints). NoSQL databases shine for flexible schemas or when you need to scale horizontally across many servers without complex joins.

That said, the overlap between relational DBs and NoSQL ones is substantial, so focus on the DB that your using and how it helps solve the problem at hand, e.g., NoSQL DBs can express relationships too, SQL DBs can have JSON columns with flexible schemas, etc.

Functional Requirements

• FR1: Platform can ingest metrics (CPU, memory, latency, custom counters) from services.
• FR2: Users can query and visualize metrics on dashboards with filters, aggregations, and time ranges.
• FR3: Users can define alert rules with thresholds over time windows, e.g., “alert if P99 latency > 500ms for 5min”.
• FR4: Users can receive notifications when alerts fire, e.g., email, Slack.

Scale: 500K servers, 5M metrics per second, ~1GB/s raw ingestion.

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.

Performance in Context

The execution of a web browser primarily involves three tasks: fetching resources, page layout and rendering, and JavaScript execution. That said, optimizing the last two tasks won’t do much good if the browser is blocked on the network, waiting for resources to arrive.

Of the top 100K, the median page on desktop requests 97 resources weighing 2,954KB in total, and makes 16 TCP connections . While the underlying transport (TCP) is optimized for large, streaming downloads, most network transfers in the browser are short and bursty.

Stability, Testing and the Multi-Process Architecture

In a single-threaded browser, devs use asynchronous APIs - which may sometimes hold the browser up. Instead of multiple threads, Chromium chose multiple processes: isolation, independent crashes, better asymptotic memory management, identifying expensive sites, etc.

The Architecture of Open Source Applications. The Performance of Open Source Applications. Tavish Armstrong. aosabook.org . Sep 26, 2013. Accessed Jan 19, 2026.

✅ High Performance Networking in Chrome. Many of the sites we use today are not just web pages, they are applications. How do we make the fastest browser? Notes .

From SocialCalc to EtherCalc. EtherCalc is an online spreadsheet system optimized towards simultaneous editing, using SocialCalc as its in-browser spreadsheet engine.

Personalizing Your Shell

Put all of your scripts in the ~/bin/ directory, and add ~/bin/ to your path. Beware of conflicting with system commands. One alternative is to prefix your commands with a comma.

Managing launchctl Services

launchctl list lists the running services, e.g.,

$ launchctl list | grep blog
1357    0       com.dchege711.blogserver

launchctl kickstart -k [service-target] restarts the service (-k kills it if it were running before), e.g., launchctl kickstart -k gui/501/com.dchege711.blogserver.

Conflict

MAXWELL LORD. What he failed to understand, my friend, is that it is human nature. To find things that are better than us – godly, wondrous divine things – and drag them down and pull them apart. Until there isn’t very much godly or divine about them at all.

THE CHRONICLER. Having foreseen his imminent capture and inevitable end, Parzurem had already fractured his mind into two arguments, given shape and structure by each other’s existence… moder and paeter. The moder pyxis found itself drawn by the gravitational fallout of the sundering of Urgrund, eventually falling into the orbit of Galactica, which would later come to be known as New Genesis. But the paeter pyxis drifted through an eternity, driven by Parzurem’s search for peace and ponderance, before finding its way to an infant planet in a far corner of the cosmos where it would be undisturbed for a brief age.

BISHOP 1. Your damned letter to the Emperor –
URI TUPKA. How could I not? When he commissioned a giant goat statue – a hundred feet tall and solid gold…?
BISHOP 1. And didn’t we warn you what would happpen? Didn’t we all warn you?
It was only to remind him. Scripture. Theodipus 6:19 – “And all men shall be equal to each other under the eyes of the gods, even as all the gods, like leaves of grass, shall be equal to each other.

Sample Use Cases

Meta

Binary Search on a Non-Decreasing \(f: \mathbb{R} \to \mathbb{R}\)

Given a number \(L\) and a non-decreasing function \(f: \mathbb{R} \to \mathbb{R}\), find the greatest \(x\) such that \(f(x) \le L\). To start, there are two numbers \(lo\) and \(hi\), such that \(f(lo) \le L < f(hi)\).

Algorithm

double binary_search(double lo, double hi, double lim) {
  while (hi - lo > precision) {
    const double mid = (hi + lo) / 2;
    if (lim < f(mid)) hi = mid; // Search in left half
    else lo = mid; // Search in right half
  }
  return lo;
}

Sample Problem

You are given two integer arrays:

• greeds, where greeds[i] represents the minimum size of a cookie that a child needs to to be satisfied.
• cookies, where cookies[j] represents the size of a cookie.

Assign cookies such that as many children as possible are satisfied. Each child can receive at most one cookie, and each cookie can be given to only one child.

A Greedy Algorithm

def num_satisfied_children(greeds: List[int], cookies: List[int]) -> int:
  greeds.sort()
  cookies.sort()

  count = 0
  g_idx, c_idx = 0, 0
  while g_idx < len(greeds) and c_idx < len(cookies):
    if cookies[c_idx] >= greeds[g_idx]:
      count += 1
      g_idx += 1

    c_idx += 1

  return count

The Event Loop

The event loop contains a collection of jobs to be run. Some jobs are added by application code, and others indirectly by asyncio. The event loop takes a job from its backlog and invokes it (“gives it control”). Once that job pauses or completes, it returns control to the event loop which then selects another job from the backlog and invokes it. When there are no jobs to be done, the event loop rests (doesn’t waster CPU cycles) and comes back when more jobs are enqueued.