Advanced code explainers

ruby

module Instrumentation
  module Timing
    def self.[](*method_names)
      Module.new do

Timing methods with a prepended module in Ruby in Rails

metaprogramming prepend instrumentation

Advanced 7 steps

typescript

type Curried<A extends any[], R> = A extends [infer First, ...infer Rest]
  ? (arg: First) => Rest extends [] ? R : Curried<Rest, R>
  : R;

Type-safe currying in TypeScript

currying conditional-types recursion

Advanced 8 steps

rust

use axum::{extract::{Query, State}, http::StatusCode, Json};
use base64::{engine::general_purpose::URL_SAFE_NO_PAD, Engine};
use serde::{Deserialize, Serialize};
use sqlx::PgPool;

Cursor pagination in an Axum handler

cursor-pagination keyset-pagination base64

Advanced 10 steps

php

<?php
 
namespace App\Http;

Building an onion middleware pipeline in PHP

middleware closures array-reduce

Advanced 9 steps

typescript

import { Injectable } from '@angular/core';
import {
  HttpInterceptor,
  HttpHandler,

Refreshing tokens with an Angular HttpInterceptor

http-interceptor token-refresh rxjs

Advanced 8 steps

go

package cache
 
import (
	"context"

Cache-aside reads with singleflight in Go

caching singleflight concurrency

Advanced 8 steps

ruby

module Multitenant
  extend ActiveSupport::Concern
 
  included do

How a multitenant concern scopes Rails models

multitenancy default-scope concern

Advanced 8 steps

rust

use std::sync::{Arc, Mutex, MutexGuard};
use std::time::Instant;
 
pub struct TimedGuard<'a, T> {

A self-timing mutex guard in Rust

raii mutex deref

Advanced 7 steps

typescript

type EventMap = Record<string, unknown>;
 
type Handler<T> = (payload: T) => void;

A type-safe event bus in TypeScript

generics event-emitter type-safety

Advanced 7 steps

go

package pipeline
 
import "sync"

The fan-in pattern in Go channels

concurrency channels fan-in

Advanced 8 steps

ruby

class SearchIndexReconciler
  DEBOUNCE_WINDOW = 5.seconds
 
  def self.schedule(record)

Debouncing search reindex jobs in Rails

debouncing background-jobs caching

Advanced 7 steps

typescript

type AsyncFn<A extends unknown[], R> = (...args: A) => Promise<R>;
 
interface MemoizeOptions<A extends unknown[]> {
  keyFn?: (...args: A) => string;

Memoizing async functions with TTL in TypeScript

memoization generics promises

Advanced 8 steps

java

@Component
public class RateLimitingFilter extends OncePerRequestFilter {
 
    private static final int MAX_REQUESTS = 100;

How a rate-limiting filter works in Spring

rate limiting concurrency servlet filter

Advanced 8 steps

go

package pipeline
 
import (
	"context"

A cancelable worker pool in Go

concurrency channels worker-pool

Advanced 8 steps

javascript

const RETRIABLE_STATUS = new Set([408, 429, 500, 502, 503, 504]);
 
function sleep(ms, signal) {
  return new Promise((resolve, reject) => {

Retrying fetch with exponential backoff

retry exponential-backoff abort-signal

Advanced 8 steps

typescript

type EventMap = Record<string, unknown[]>;
 
type Listener<Args extends unknown[]> = (...args: Args) => void;

A type-safe event emitter in TypeScript

generics mapped-types event-emitter

Advanced 8 steps

ruby

class FundsTransfer
  class InsufficientFundsError < StandardError; end
 
  def initialize(source:, destination:, amount:)

Atomic money transfers with Rails transactions

service object database transactions row locking

Advanced 9 steps

python

import time
from dataclasses import dataclass, field
 
from fastapi import Depends, FastAPI, HTTPException, Request, status

Token-bucket rate limiting in FastAPI

rate-limiting token-bucket dependency-injection

Advanced 10 steps