Skip to main content

Sitemap

A visual representation of the site structure to help you navigate through the content.

Site Structure

Main landing page with introduction and recent articles

About/about

Learn more about me, my background, and expertise

Speaking/speaking

My talks, presentations, and speaking engagements

GPU Programming 101 in Python/talks/gpu-programming-101-in-python

BangPypers December Meetup 2025

ArrPy: Array You Fast Enough?/talks/arrpy-array-you-fast-enough

PyCon India 2025

Build with AI - Bangpypers

Rolling with Python: A Deep Dive into Python Wheels/talks/rolling-with-python-intro-to-python-wheels

NammaMUG × BangPypers Meetup

PyCon India 2024, Bangalore / PyCon Japan 2024, Tokyo

Devfest 2023

Introduction to Machine Learning/talks/introduction-to-machine-learning

KJ Somaiya Techfest 2019

Articles/articles

Collection of articles I've written on various topics

One multiply, one RTX 5090, eight kernels/articles/rtx-5090-matmul-eight-kernels

Article content

Article content

Article content

CUDA Matrix Multiplication Optimization: From Naive to Near-cuBLAS/articles/cuda-matrix-multiplication-optimization

Article content

Numerical Sensitivity: Why FP16 Breaks NAdam/articles/numerical-sensitivity

Article content

SAM's Multi-Mask Ambiguity: A Visual Deep Dive/articles/sam-multi-mask-ambiguity

Article content

Article content

H.264 Implementation & Applications (Part 3 of 3)/articles/h264-implementation-applications

Article content

H.264 Transform & Quantization (Part 2 of 3)/articles/h264-transform-quantization

Article content

Article content

Fix PyTorch "view size is not compatible" Error/articles/view-size-not-compatible

Article content

Article content

Article content

Quantization Deep Dive: From FP32 to INT4/articles/quantization-deep-dive

Article content

Article content

Python's logging Module Is Already a Singleton/articles/python-production-logging

Article content

Article content

Article content

Article content

Article content

Article content

Article content

Article content

Papers/papers

Research papers and publications

Liger Kernel: Fused RMSNorm/papers/liger-rmsnorm

Paper content

Liger Kernel: Fused SwiGLU/papers/liger-swiglu

Paper content

Paper content

Paper content

Paper content

Paper content

Paper content

Paper content

Hilbert-Guided Sparse Local Attention/papers/hilbert-local-attention

Paper content

Paper content

Paper content

Paper content

Paper content

Visual Instruction Tuning/papers/visual-instruction-tuning

Paper content

Plain ViT Backbones for Object Detection/papers/vit-object-detection

Paper content

Paper content

Paper content

Paper content

ViT: An Image is Worth 16x16 Words/papers/image-worth-16x16

Paper content

A Survey of Techniques for Optimizing Transformer Inference/papers/optimizing-transformer-inference

Paper content

Paper content

Paper content

Paper content

Attention Is All You Need/papers/attention-is-all-you-need

Paper content

Paper content

Deep Residual Learning for Image Recognition/papers/deep-residual-learning

Paper content

Concepts/concepts

Interactive explanations of machine learning concepts

Transformers & LLMs/concepts/category/transformers

Attention mechanisms, large language models, and multimodal architectures: the building blocks of modern AI.

CLS Token in Vision Transformers/concepts/transformers/cls-token

Trace how a learned CLS row joins image patches, gathers evidence through self-attention, and becomes the image-level classification readout.

Hierarchical Attention in Vision Transformers/concepts/transformers/hierarchical-attention

Trace how local windows, shifted cross-window exchange, and patch merging turn one high-resolution token grid into a multi-scale vision hierarchy.

Multi-Head Attention/concepts/transformers/multihead-attention

How multi-head attention runs scaled dot-product attention in parallel across several representation subspaces to build context-aware token embeddings.

Positional Embeddings in Vision Transformers/concepts/transformers/positional-embeddings-vit

Move the same image patches with and without positional addition to see how learned absolute positions change a Vision Transformer’s attention inputs.

Self-Attention in Vision Transformers/concepts/transformers/self-attention-vit

Follow one image patch through Q/K/V projection, scaled scores, row-wise softmax, value mixing, and the residual update inside a Vision Transformer.

ALiBi: Attention with Linear Biases/concepts/transformers/alibi

Follow a query-key distance through ALiBi head slopes, attention logits and normalized weights, then understand the evidence and limits of length extrapolation.

Compare head sharing with explicit projection dimensions and KV-cache bytes. Separate exact memory ratios from measured quality and latency, and see why FlashAttention is an independent choice.

Attention Sinks: Stable Streaming LLMs/concepts/transformers/attention-sinks

See how preserving initial attention sinks stabilizes a rolling KV cache, why it costs recent slots, and why stable streaming does not mean infinite recall.

Cross-Attention: Bridging Different Modalities/concepts/transformers/cross-attention

Trace a target query through source keys, attention weights, and a weighted value mix. Understand cross-attention origins, shapes, masks, and applications.

Grouped-Query Attention: Head Sharing and KV Cache/concepts/transformers/grouped-query-attention

Trace how grouped-query attention keeps independent query heads while sharing fewer key/value heads, projections, and compact KV-cache rows during LLM decoding.

Linear Attention Approximations/concepts/transformers/linear-attention-approximations

Understand normalized kernel attention, low-rank sequence projections and their trade-offs, and compare them with sparse attention and exact tiled softmax.

Masked and Causal Attention/concepts/transformers/masked-attention

Trace causal attention from shifted next-token labels through the lower-triangular mask, pre-softmax blocking, parallel training, and incremental decoding.

Multi-Query Attention (MQA)/concepts/transformers/multi-query-attention

Trace how multi-query attention keeps independent query heads while sharing one key/value head, with exact cache bytes and a shape-correct decoding example.

Rotary Position Embeddings (RoPE)/concepts/transformers/rotary-position-embeddings

Trace RoPE in radians, see how shared shifts preserve relative-position scores, and distinguish its frequency schedule from long-context guarantees.

Scaled Dot-Product Attention/concepts/transformers/scaled-dot-product

Compare scaled and unscaled attention on the same dot products, then derive the square-root scaling factor and its limits.

Sliding Window Attention/concepts/transformers/sliding-window-attention

Explore causal and symmetric local attention with exact window counts, then distinguish direct keys, multi-layer input reach, and inference KV storage.

Sparse Attention Patterns/concepts/transformers/sparse-attention-patterns

Compose sparse attention patterns, follow one query through masking and softmax, and separate fewer allowed pairs from actual sparse-kernel savings.

The Vision-Language Alignment Problem/concepts/transformers/alignment-problem

Trace one image-caption pair through cosine scores, contrastive positives and negatives, a trainable projection, and retrieval evaluation.

Context Windows: Capacity and Attention Limits/concepts/transformers/context-windows

See how context capacity, attention masks, and KV caches differ. Move a planted fact through a token sequence to inspect what one query can access.

Flash Attention: IO-Aware Exact Attention/concepts/transformers/flash-attention

Follow the same Q, K and V through dense and tiled attention. See online softmax preserve the output while avoiding global score and probability matrices.

KV Cache: Reuse Past Keys and Values/concepts/transformers/kv-cache

Trace a cached decode step, separate saved projections from growing attention work, and calculate KV-cache memory with explicit dimensions.

The Modality Gap in Multimodal AI/concepts/transformers/modality-gap

Measure the centroid gap between normalized image and text embeddings, then check why a smaller gap alone does not guarantee correct retrieval.

Multimodal Scaling Laws/concepts/transformers/scaling-laws

Explore a fixed compute budget with Chinchilla’s text-only loss fit, then see why multimodal scaling needs its own data, objectives, and evaluation metrics.

Tokenization: Converting Text to Numbers/concepts/transformers/tokenization

Trace ranked BPE merges from text to pieces and integer IDs. Compare BPE, WordPiece and Unigram, and separate normalization from the SentencePiece framework.

Vision-Language Adapters: Efficient Fine-tuning/concepts/transformers/vision-language-adapters

Trace frozen weights and trainable LoRA matrices, calculate adapter parameter counts, and compare bottleneck adapters, prefix tuning and BitFit for vision-language models.

Mixture of Experts (MoE)/concepts/transformers/mixture-of-experts

Trace top-k expert routing, normalized output weights and capacity overflow, then compare stored parameters and expert work with explicit compute baselines.

Speculative Decoding: Draft, Then Verify/concepts/transformers/speculative-decoding

A small draft model proposes tokens, the target model checks them all in one pass, and a rejection rule keeps the output distribution exactly the target's.

Vision-Language Alignment: CLIP, BLIP-2, LLaVA, Flamingo/concepts/transformers/vision-language-alignment

CLIP, BLIP-2, LLaVA and Flamingo align images with text by different routes. Compare their objectives, bridges, data, and which parts train or stay frozen.

Deep Learning/concepts/category/deep-learning

Neural network fundamentals: normalization, convolutions, losses, graph networks, and training dynamics.

Calinski-Harabasz Index: The Variance Ratio Criterion/concepts/deep-learning/calinski-harabasz

How the Calinski-Harabasz index evaluates clustering quality by measuring the ratio of between-cluster to within-cluster variance — fast, intuitive, and ideal for k-selection with convex clusters.

Silhouette Score: Per-Point Clustering Evaluation/concepts/deep-learning/silhouette-score

How the silhouette score measures clustering quality for every individual point — comparing intra-cluster cohesion to nearest-cluster separation, with per-point diagnostics and explicit distance-metric assumptions.

Davies-Bouldin Index: Worst-Case Cluster Similarity/concepts/deep-learning/davies-bouldin

How the Davies-Bouldin index evaluates clustering quality by finding each cluster's most similar neighbor — a pessimistic, worst-case metric that catches overlapping cluster pairs.

Representation Collapse in Self-Supervised Learning/concepts/deep-learning/collapse-risk

Understanding complete, dimensional, and cluster collapse — the failure modes that every self-supervised method must prevent. Learn why collapse happens and how contrastive, asymmetric, regularization, and masking approaches solve it.

Batch Norm vs Layer Norm: When to Use Which/concepts/deep-learning/batch-vs-layer-norm

BatchNorm normalizes over the batch and spatial axes; LayerNorm normalizes over the channel and spatial axes for each sample. The choice changes whether your model trains stably with batch=1, depends on batch composition at inference, and behaves consistently across train and eval.

Convolution Operation: The Foundation of CNNs/concepts/deep-learning/convolution-operation

Interactive guide to convolution in CNNs: visualize sliding windows, kernels, stride, padding, and feature detection with step-by-step demos.

Cross-Entropy Loss for Classification/concepts/deep-learning/cross-entropy-loss

Understand cross-entropy loss for classification: interactive demos of binary and multi-class CE, the -log(p) curve, softmax gradients, and focal loss.

Dilated Convolutions: Expanding Receptive Fields Efficiently/concepts/deep-learning/dilated-convolutions

Understand dilated (atrous) convolutions: how dilation rates expand receptive fields without extra parameters and how to avoid gridding artifacts.

Receptive Field in CNNs/concepts/deep-learning/receptive-field

Understand receptive fields in CNNs: how convolutional layers expand their field of view and the gap between theoretical and effective receptive fields.

VAE Latent Space: Understanding Variational Autoencoders/concepts/deep-learning/vae-latent-space

Explore VAE latent space in deep learning. Learn variational autoencoder encoding, decoding, interpolation, and the reparameterization trick.

Contrastive Loss for Representation Learning/concepts/deep-learning/contrastive-loss

Understand contrastive loss for representation learning: interactive demos of InfoNCE, triplet loss, and embedding space clustering with temperature tuning.

Dropout Regularization/concepts/deep-learning/dropout

Understand dropout regularization: how randomly silencing neurons prevents overfitting, the inverted dropout trick, and when to use each dropout variant.

Focal Loss: Focusing on Hard Examples/concepts/deep-learning/focal-loss

Learn focal loss for deep learning: down-weight easy examples, focus on hard ones. Interactive demos of gamma, alpha balancing, and RetinaNet.

He/Kaiming Initialization/concepts/deep-learning/he-initialization

Learn He (Kaiming) initialization for ReLU networks: why ReLU needs special weight initialization, variance flow, and dead neurons explained.

KL Divergence in Machine Learning/concepts/deep-learning/kl-divergence

Learn KL divergence for machine learning: measure distribution differences in VAEs, knowledge distillation, and variational inference.

MSE and MAE Loss Functions/concepts/deep-learning/mse-mae

Interactive guide to MSE vs MAE for regression: explore outlier sensitivity, gradient behavior, and Huber loss with visualizations.

Xavier/Glorot Initialization/concepts/deep-learning/xavier-initialization

Learn Xavier (Glorot) initialization: how it balances forward signals and backward gradients to enable stable deep network training with tanh and sigmoid.

Adaptive Tiling: Efficient Visual Token Generation/concepts/deep-learning/adaptive-tiling

Explore an illustrative region-tiling policy: resize tiles, calculate visual tokens, and distinguish analytical savings from measured model quality.

Emergent Abilities in Large Language Models/concepts/deep-learning/emergent-abilities

Explore emergent abilities in large language models: sudden capabilities at scale thresholds, phase transitions, and the mirage debate.

Prompt Engineering for LLMs/concepts/deep-learning/prompt-engineering

Master prompt engineering for large language models: from basic composition to Chain-of-Thought, few-shot, and advanced techniques.

Prompt Information Flow in Causal Transformers/concepts/deep-learning/prompt-influence-flow

Explore how prompt token positions connect through causal self-attention, and why connectivity and attention weights do not establish causal influence.

Neural Scaling Laws Explained/concepts/deep-learning/scaling-laws

Explore neural scaling laws in deep learning: power law relationships between model size, data, and compute that predict AI performance.

Visual Complexity Analysis: Smart Image Processing/concepts/deep-learning/visual-complexity-analysis

Learn visual complexity analysis in deep learning - how neural networks measure entropy, edges, and saliency for adaptive image processing.

Gradient Flow in Deep Networks/concepts/deep-learning/gradient-flow

Learn how gradients propagate through deep neural networks during backpropagation. Understand vanishing and exploding gradient problems.

NAdam: Nesterov-Accelerated Adam/concepts/deep-learning/nadam

Understand the NAdam optimizer that fuses Adam adaptive learning rates with Nesterov look-ahead momentum with a reproducible constant-momentum update and interactive optimization examples.

Layer Normalization for Transformers/concepts/deep-learning/layer-normalization

Learn layer normalization for transformers and sequence models: how normalizing across features enables batch-independent training.

Internal Covariate Shift/concepts/deep-learning/internal-covariate-shift

Understand internal covariate shift: why layer input distributions change during training, how it slows convergence, and how batch norm fixes it.

Batch Normalization in Deep Learning/concepts/deep-learning/batch-normalization

Learn batch normalization in deep learning: how normalizing layer inputs accelerates training, improves gradient flow, and acts as regularization.

Skip Connections in Neural Networks/concepts/deep-learning/skip-connections

Learn how skip connections and residual learning enable training of very deep neural networks. Understand the ResNet revolution with interactive visualizations.

Graph Attention Networks (GAT)/concepts/deep-learning/graph-attention-networks

Adaptive attention-based aggregation for graph neural networks - multi-head attention, learned weights, and interpretable graph learning

Graph Centrality & Metrics/concepts/deep-learning/graph-centrality

Understanding node importance through centrality measures, shortest paths, hop distances, clustering coefficients, and fundamental graph metrics

Graph Convolutional Networks (GCN)/concepts/deep-learning/graph-convolutional-networks

Learn Graph Convolutional Networks (GCN) with spectral theory, message passing, and node classification for geometric deep learning.

Graph Embeddings and Node2Vec/concepts/deep-learning/graph-embeddings

Learning low-dimensional vector representations of graphs through random walks, DeepWalk, Node2Vec, and skip-gram models

Graph Pooling Methods/concepts/deep-learning/graph-pooling

Hierarchical graph coarsening techniques - TopK, SAGPool, DiffPool, and readout operations for graph-level representations

Self-Supervised Learning and Masked Prediction/concepts/deep-learning/self-supervised-learning

Understand where self-supervised targets come from, how masked prediction creates a learning task, and why predicting pixels differs from predicting learned features.

Target Encoders, EMA, and Stop-Gradient/concepts/deep-learning/target-encoders-ema

Follow how a learned target encoder supplies feature targets, how stop-gradient separates backward paths, and how exponential moving averages update its parameters.

Transfer Learning and Fine-Tuning/concepts/deep-learning/transfer-learning-fine-tuning

Move a pretrained encoder to a downstream task: trace frozen features, head training, partial and full fine-tuning, learning rates, and BatchNorm state.

Computer Vision/concepts/category/computer-vision

Images, recognition, detection, segmentation, visual representations, camera geometry, and motion.

Feature Pyramid Networks (FPN) Explained/concepts/computer-vision/feature-pyramid-networks

Learn how Feature Pyramid Networks build multi-scale feature representations through top-down pathways and lateral connections for robust object detection.

ASFF: Adaptive Spatial Feature Fusion/concepts/computer-vision/asff

Learning where to fuse multi-scale features with per-pixel, per-level fusion weights. ASFF challenges FPN's uniform fusion assumption.

RoI Pooling, RoI Align & Deformable RoI Pooling/concepts/computer-vision/roi-pooling

Understanding region-based feature extraction for object detection, from quantized pooling to sub-pixel alignment and adaptive sampling

Anchor-Based vs Anchor-Free Object Detection/concepts/computer-vision/anchor-based-vs-anchor-free

Compare anchor-based vs anchor-free object detection: Faster R-CNN and RetinaNet anchors vs FCOS and CenterNet point-based methods.

Understanding how neural architecture search discovers optimal feature pyramid architectures that outperform hand-designed alternatives

DETR Explained: Object Detection with Transformers/concepts/computer-vision/modern-object-detection

Understanding end-to-end object detection with transformers, from DETR's object queries to bipartite matching and attention-based localization

NMS & Soft-NMS: Removing Duplicate Detections/concepts/computer-vision/nms-soft-nms

Understanding Non-Maximum Suppression algorithms for object detection post-processing, from greedy NMS to soft variants

Visual Complexity Analysis for Token Allocation/concepts/computer-vision/visual-complexity-analysis

Compare edge, frequency and entropy heuristics for selecting a fixed budget of image patches, and distinguish token counts from accuracy and measured speed.

Image Pixels, Channels, and Color Spaces/concepts/computer-vision/image-pixels-color-spaces

Read an image as an array: inspect RGB channels, grayscale and HSV, and understand coordinates, data types and tensor layouts before preprocessing.

Image Resizing and Interpolation/concepts/computer-vision/image-resizing-interpolation

Compare nearest-neighbor and bilinear image resizing, see aliasing when downsampling, and understand aspect ratio, letterboxing and mask interpolation.

Image Filtering and Edge Detection/concepts/computer-vision/image-filtering-edge-detection

Inspect Gaussian smoothing and Sobel filters as local weighted sums, understand signed gradients and Canny edges, and connect fixed filters to CNNs.

Image Classification and CNN Feature Maps/concepts/computer-vision/image-classification-cnn

Follow an image through convolution, ReLU, pooling and class scores. Inspect a transparent toy CNN and learn what classification can and cannot predict.

Bounding Boxes and Coordinate Systems/concepts/computer-vision/bounding-boxes

Convert between xyxy, xywh and center-size boxes, normalize coordinates correctly, and avoid mistakes when resizing, clipping or flipping detection labels.

How Object Detection Works/concepts/computer-vision/object-detection

Understand object detection from image features to boxes, classes and scores. Compare one-stage and two-stage pipelines, training and duplicate handling.

Intersection over Union (IoU)/concepts/computer-vision/intersection-over-union

Calculate box intersection and union, explore how position and size change IoU, and distinguish overlap used for evaluation, NMS and localization losses.

Object Detection Metrics: Precision, Recall, AP, and mAP/concepts/computer-vision/object-detection-metrics

Match detections to objects, inspect precision–recall curves, calculate average precision, and distinguish confidence thresholds from IoU thresholds.

Semantic, Instance, and Panoptic Segmentation/concepts/computer-vision/image-segmentation

Compare semantic, instance and panoptic label maps, inspect individual pixels, and understand dense predictions, mask IoU, Dice and boundary errors.

Image Augmentation and Label Consistency/concepts/computer-vision/image-augmentation

Transform images and annotations together, inspect crop and flip geometry, and choose augmentation assumptions that preserve the meaning of the task.

Visual Representations and Image Encoders/concepts/computer-vision/visual-representations

Follow pixels into image features, compare spatial maps with pooled vectors, and see why image encoders expose different outputs for recognition and localization.

Image Patches and Patch Embeddings/concepts/computer-vision/image-patch-embeddings

Turn an image into a sequence: count patches, flatten pixels, apply a shared learned projection, and separate token count from embedding width.

Object Queries in DETR/concepts/computer-vision/object-queries

Follow spatial image features into DETR decoder slots, separating learned query embeddings, attention queries, changing content and object predictions.

Set Prediction and Bipartite Matching/concepts/computer-vision/bipartite-matching

Learn how DETR assigns unordered object targets to prediction slots, why greedy choices can fail, and how matching differs from training loss and evaluation.

Bounding-Box Regression and Generalized IoU/concepts/computer-vision/bounding-box-regression

Learn how normalized box coordinates, L1 loss, IoU, and Generalized IoU guide object localization, including disjoint boxes and containment limits.

Evaluating Visual Representations/concepts/computer-vision/evaluating-visual-representations

Evaluate frozen image features with nearest neighbors and linear probes, separate training from validation and test data, and understand what each protocol can establish.

Dense Prediction and Upsampling/concepts/computer-vision/dense-prediction-upsampling

Follow coarse feature maps into aligned pixel predictions: nearest and bilinear interpolation, transposed convolution, output shapes, skip fusion, and resizing logits before selecting labels.

Deformable Attention and Reference Points/concepts/computer-vision/deformable-attention

Follow a query from a spatial reference through learned offsets, bilinear feature sampling and weighted aggregation, with exact non-square coordinate arithmetic.

Camera Geometry and Projection/concepts/computer-vision/camera-geometry

Follow a 3D world point through camera extrinsics, depth division and pixel intrinsics, then see why one image point cannot determine its depth.

Optical Flow and Visual Correspondence/concepts/computer-vision/optical-flow

Follow image points between frames, distinguish forward flow from backward sampling, and understand brightness constancy, occlusion and the aperture problem.

Embeddings & Retrieval/concepts/category/embeddings

Dense and sparse embeddings, quantization, and vector search for semantic retrieval.

Dense Embeddings/concepts/embeddings/dense-embeddings

How dense embeddings turn meaning into geometry: word2vec, GloVe, and contextual models, vector arithmetic, cosine similarity, and where the field is heading.

How sparse retrieval (BM25/TF-IDF), dense retrieval (BERT-style embeddings), and hybrid systems that combine both compare on recall, semantic understanding, computational cost, and operational complexity for modern search.

BM25 Algorithm for Text Retrieval/concepts/embeddings/bm25-algorithm

Master the BM25 algorithm, the probabilistic ranking function powering Elasticsearch and Lucene for keyword-based document retrieval and search systems.

Pooling Strategies/concepts/embeddings/pooling-strategies

How a transformer’s per-token outputs become one embedding: CLS, mean, max, last-token, and attention pooling — what each does and when to use it.

Contrastive Learning/concepts/embeddings/contrastive-learning

Master contrastive learning for vector embeddings: how InfoNCE loss and self-supervised techniques train models to create high-quality semantic representations.

Matryoshka Embeddings/concepts/embeddings/matryoshka-embeddings

Matryoshka embeddings: nested representations enabling dimension reduction by simple truncation without model retraining for flexible retrieval.

Domain Adaptation for Embeddings/concepts/embeddings/domain-adaptation

Domain adaptation for embeddings: transfer learning to fine-tune retrieval models across domains while preventing catastrophic forgetting.

Cross-Lingual Alignment/concepts/embeddings/cross-lingual-alignment

Learn cross-lingual embedding alignment techniques like VecMap and MUSE for multilingual vector retrieval and zero-shot language transfer in search systems.

Cross-Encoder vs Bi-Encoder/concepts/embeddings/cross-encoder-vs-bi-encoder

Understand the fundamental differences between independent and joint encoding architectures for neural retrieval systems.

Multi-Vector Late Interaction/concepts/embeddings/multi-vector-late-interaction

Explore ColBERT and other multi-vector retrieval models that use fine-grained token-level matching for superior search quality.

Hybrid Retrieval Systems/concepts/embeddings/hybrid-retrieval-systems

Build hybrid retrieval systems combining BM25 sparse search with dense vector embeddings using reciprocal rank fusion for superior semantic search performance.

Quantization Effects Simulator/concepts/embeddings/quantization-effects

Embedding quantization simulator: explore memory-accuracy trade-offs from float32 to int8 and binary representations for retrieval.

Vector Quantization Techniques/concepts/embeddings/vector-quantization

Master vector compression techniques from scalar to product quantization. Learn how to reduce memory usage by 10-100× while preserving search quality.

Binary Embeddings for Fast Search/concepts/embeddings/binary-embeddings

Learn how binary embeddings use 1-bit quantization for ultra-compact vector representations, enabling billion-scale similarity search with 32x memory reduction.

Vector Index Structures/concepts/embeddings/index-structures

Explore the fundamental data structures powering vector databases: trees, graphs, hash tables, and hybrid approaches for efficient similarity search.

How HNSW, IVF-PQ, and LSH compare for approximate nearest neighbor (ANN) search — recall, latency, memory, build cost, and update characteristics — with Annoy, ScaNN, and DiskANN included for completeness.

LSH: Locality Sensitive Hashing/concepts/embeddings/lsh-search

Explore how LSH uses probabilistic hash functions to find similar vectors in sub-linear time, perfect for streaming and high-dimensional data.

Learn how IVF-PQ combines clustering and compression to enable billion-scale vector search with minimal memory footprint.

HNSW: Hierarchical Navigable Small World/concepts/embeddings/hnsw-search

How HNSW navigates a layered proximity graph to find nearest neighbors in logarithmic time — the default in-memory index of modern vector databases.

GPU & High-Performance Computing/concepts/category/gpu-computing

CUDA, tensor cores, multi-GPU communication, and cluster-scale workload orchestration.

Slurm Fundamentals: Job Scheduling on HPC Clusters/concepts/gpu-computing/slurm-fundamentals

Complete guide to Slurm — architecture, core commands, job lifecycle, job scripts, array jobs, dependencies, monitoring with squeue/sacct, and troubleshooting failed jobs on HPC clusters.

Tensor Cores: Mixed Precision & Matrix Acceleration/concepts/gpu-computing/tensor-cores

How NVIDIA Tensor Cores accelerate GEMM: warp-level MMA, precision dials (TF32/FP16/BF16/INT8/FP8), shape alignment and padding cost, AMP vs model.half(), and when the speedup actually shows up.

High Bandwidth Memory (HBM)/concepts/gpu-computing/hbm-memory

How HBM feeds AI GPUs: the memory wall, width-over-speed packaging, TSVs and interposers, the on-package hierarchy, and the roofline that decides if your kernel is bandwidth-bound.

GPU Memory Hierarchy & Optimization/concepts/gpu-computing/memory-hierarchy

Master GPU memory hierarchy from registers to global memory, understand coalescing patterns, bank conflicts, and optimization strategies for maximum performance

Multi-GPU Communication: NVLink, PCIe, and NCCL/concepts/gpu-computing/multi-gpu-communication

How GPUs talk: the bandwidth cliff from HBM to Ethernet, NVLink 5 and GB200 NVL72 topologies, ring AllReduce step by step, and choosing between NCCL, Gloo, and MPI.

GPU Streaming Multiprocessor (SM)/concepts/gpu-computing/shared-multiprocessor

How a single SM actually runs work: warps of 32, cutaway of cores and memory, divergence tax, latency-hiding occupancy, and coalesced loads — instruments, not a catalog.

Slurm GPU Allocation for Distributed Training/concepts/gpu-computing/slurm-gpu-allocation

Complete guide to GPU allocation on Slurm — --gres flags, CUDA_VISIBLE_DEVICES remapping, GPU topology and NVLink binding, MIG partitioning, production job scripts, and debugging common GPU errors.

CUDA Contexts: Ownership, Current Stack, Isolation/concepts/gpu-computing/cuda-context

Deep dive into the CUDA context object: control vs data plane, inventory (memory, modules, streams, events, graphs), push/pop/setCurrent stacks, primary retain/release, flags and limits, isolation, cost, and traps.

CUDA Streams: Asynchronous Execution and Concurrency/concepts/gpu-computing/cuda-streams

A CUDA stream is an in-order queue of GPU ops. Overlap H→D, kernels, and D→H across streams — and avoid the legacy default-stream fences between blocking streams in one context.

Slurm Resource Management and Job Priority/concepts/gpu-computing/slurm-resource-management

How Slurm decides which jobs run first — priority factors, fair-share scheduling, backfill, and monitoring commands (squeue, sinfo, sacct).

NVIDIA Unified Virtual Memory/concepts/gpu-computing/unified-memory

NVIDIA Unified Virtual Memory (UVM): on-demand page migration, memory oversubscription, and simplified CPU-GPU memory management.

CUDA Context vs Streams vs MPS: Which Layer Fixes What/concepts/gpu-computing/cuda-context-vs-streams

Decision map for CUDA: a context is per-process GPU state, a stream is an in-order queue inside a context, and MPS co-schedules work across client contexts on Volta+. Pick the layer that matches the problem.

Flynn's Classification: Taxonomy of Computer Architectures/concepts/gpu-computing/flynns-classification

Flynn's Classification explained — SISD, SIMD, MISD, MIMD with interactive architecture explorer, SIMD evolution from MMX to AMX, branch divergence visualization, and workload-architecture throughput comparison.

MPI Fundamentals: Message Passing for Distributed Computing/concepts/gpu-computing/mpi-fundamentals

Complete MPI guide — point-to-point and collective communication with real C and mpi4py code, deadlock simulation, analytical performance modeling, communicator splitting, and debugging on HPC clusters.

OpenMP: Shared-Memory Parallel Programming/concepts/gpu-computing/openmp

OpenMP parallel programming: fork-join model, scheduling, data races, false sharing, NUMA thread affinity, and GPU offloading.

Page Migration & Fault Handling/concepts/gpu-computing/page-migration

CUDA page migration and fault handling between CPU and GPU memory. Learn TLB management, DMA transfers, and memory optimization.

Slurm Accounting and Resource Tracking/concepts/gpu-computing/slurm-accounting

How Slurm tracks resource consumption through account hierarchies, TRES billing, and resource limits — sacctmgr, sreport, and the association model explained.

Why ordinary multi-process CUDA time slicing can leave SMs idle, how Volta+ MPS co-schedules separate client contexts, execution-resource caps, and when to choose MPS or MIG.

HPC Performance Optimization: Scaling, Profiling, and Tuning/concepts/gpu-computing/hpc-performance-optimization

Amdahl and Gustafson ceilings, strong vs weak scaling, roofline bounds, and hiding all-reduce behind compute — the levers that decide whether more GPUs actually buy science.

Slurm Backfill Scheduling: How Small Jobs Fill the Gaps/concepts/gpu-computing/slurm-backfill

How sched/backfill works — the algorithm that lets small jobs run in gaps while large jobs wait, why accurate time limits matter, and the key tuning parameters (bf_interval, bf_window, bf_max_job_test).

NVIDIA vs AMD for deep learning compared at both layers: the CUDA vs ROCm software moat, the microarchitecture (warp vs wavefront, SM vs CU, Tensor vs Matrix Cores), and the datacenter accelerators (H100/H200/B200 vs MI300X/MI325X).

NVIDIA Device Files in /dev//concepts/gpu-computing/nvidia-device-files

How /dev/nvidia*, nvidiactl, nvidia-uvm, and DRI nodes map major/minor numbers to the driver, what CUDA opens first, and the minimum mount set for containers.

NVIDIA GPU Operator: Declarative GPU Stacks on Kubernetes/concepts/gpu-computing/kubernetes-operator

How the NVIDIA GPU Operator turns drivers, container toolkit, device plugin, GFD, DCGM, and MIG into DaemonSets reconciling from a ClusterPolicy — boot order, request path, sharing modes, and ops traps.

NVIDIA Persistence Daemon: Killing GPU Cold Starts/concepts/gpu-computing/nvidia-persistence-daemon

Why the first nvidia-smi or CUDA open costs seconds, what that cold path rebuilds, how nvidia-persistenced holds device FDs on the host, and when persistence pays off for pods, CI, and batch jobs.

Distributed Parallelism in Deep Learning/concepts/gpu-computing/distributed-parallelism

GPU distributed parallelism: Data Parallel (DDP), Tensor Parallel, Pipeline Parallel, and ZeRO optimization for training large AI models.

GPU Pipeline Hazards: Scoreboard Stalls and Warp Divergence/concepts/gpu-computing/gpu-pipeline-hazards

A fine kernel can still profile poorly: warp divergence taxes throughput ~1/N; alone on a long scoreboard wait, SM issue util can hit 0%. Interactive demos.

NCCL: How NVIDIA Collective Communication Works/concepts/gpu-computing/nccl-communication

A deep dive into NCCL internals: communicators and channels, how it picks ring/tree/NVLS algorithms and LL/LL128/Simple protocols, reading NCCL_DEBUG logs, and tuning and debugging distributed training.

Data vs Tensor vs Pipeline Parallelism: When to Use Each/concepts/gpu-computing/data-vs-tensor-vs-pipeline-parallelism

Data, tensor and pipeline parallelism split the batch, weight matrices or layers across GPUs. Compare memory, traffic and batch limits, then combine them.

Systems & Architecture/concepts/category/systems

CPU pipelines, memory hierarchies, the Linux kernel, filesystems, and networking.

Deep dive into CPU cache lines — interactive cache simulator with configurable associativity and replacement policies, false sharing MESI protocol visualization, access pattern benchmarks, and optimization techniques.

Explore the inner workings of RAM through beautiful animations and interactive visualizations. Understand memory cells, addressing, and the memory hierarchy.

initramfs: The Initial RAM Filesystem Explained/concepts/systems/initramfs-boot-process

Learn how initramfs enables Linux boot by loading essential drivers before the root filesystem mounts. Explore early userspace initialization.

Linux Kernel Architecture: From User Space to Hardware/concepts/systems/kernel-architecture

Explore Linux kernel architecture: user and kernel space, cooperating subsystems, cached and uncached file reads, and how containers share one kernel.

Filesystems: The Digital DNA of Data Storage/concepts/systems/filesystems-overview

Explore Linux filesystems through interactive visuals. Learn VFS, compare ext4 vs Btrfs vs ZFS, and understand file operations.

Master virtual memory and TLB address translation with interactive demos. Learn page tables, page faults, and memory management optimization.

Filesystem Journaling: Write-Ahead Logging/concepts/systems/filesystem-journaling

Follow a filesystem transaction from journal to checkpoint. Explore crash recovery, ext4 journal modes, and the limits of data durability.

Understand Linux inodes - the metadata structures behind every file. Learn about hard links, soft links, and inode limits.

Memory Access Patterns: Sequential vs Strided/concepts/systems/memory-access-patterns

Master sequential vs strided memory access patterns. Learn how cache efficiency and hardware prefetching affect application performance.

Follow filesystem copy-on-write from a changed block to a committed root. Explore snapshot sharing, space reclamation, and the trade-offs in Btrfs and ZFS.

FUSE: Filesystem in Userspace Explained/concepts/systems/fuse-filesystem

Learn FUSE (Filesystem in Userspace) for building custom filesystems. Understand how NTFS-3G, SSHFS, and cloud storage work.

ext4: The Linux Workhorse Filesystem/concepts/systems/ext4-filesystem

Explore ext4, the default Linux filesystem with journaling, extents, and proven reliability. Learn how ext4 protects your data.

CPU Pipeline Architecture/concepts/systems/cpu-pipeline-detailed

Follow instructions through a five-stage pipeline, distinguish latency from throughput, and connect issue width to out-of-order execution.

Trace data, structural and control hazards, understand forwarding and load-use stalls, and connect register dependencies to scheduling.

Branch Prediction & Speculation/concepts/systems/cpu-pipelines

Replay branch outcomes to compare predictors, then connect local and global history to speculative execution, recovery and profiling.

Master Linux mount options like noatime and async for performance tuning and security hardening. Interactive guide to fstab configuration.

NTFS Filesystem: The Master File Table/concepts/systems/ntfs-filesystem

NTFS internals from the Master File Table outward: 1 KB attribute records, resident vs non-resident $DATA, run lists, alternate data streams, the $LogFile journal, and why dual-boot Linux distros prefer ntfs3 over ntfs-3g.

Btrfs: Modern Copy-on-Write Filesystem/concepts/systems/btrfs-filesystem

Trace how Btrfs shares extents, creates snapshots, distributes copies, compresses writes, and repairs checksum errors when a good replica exists.

Filesystem Data Integrity: Detecting Silent Corruption/concepts/systems/filesystem-integrity

Explore checksum verification, Merkle-tree reads, mirror repair, and scrubbing through interactive examples of silent corruption and recovery.

ZFS: The Ultimate Filesystem/concepts/systems/zfs-filesystem

Master ZFS filesystem with pooled storage, RAID-Z, snapshots, and checksums. Learn enterprise-grade data integrity on Linux.

XFS: High-Performance Parallel Filesystem/concepts/systems/xfs-filesystem

XFS internals end-to-end: allocation groups for lock-free parallel metadata, B+ trees instead of bitmaps, extent-based allocation that scales to terabytes, and delayed allocation that turns scattered writes into contiguous extents.

FAT32 & exFAT: Universal Filesystems/concepts/systems/fat-filesystems

Learn FAT32 and exFAT filesystems for cross-platform USB drives and SD cards. Understand file size limits and compatibility.

Memory Controllers: The Brain Behind RAM Management/concepts/systems/memory-controllers

Learn how memory controllers manage CPU-RAM data flow. Interactive demos of channels, ranks, banks, and command scheduling for optimal bandwidth.

Memory Interleaving: Parallel Memory Access/concepts/systems/memory-interleaving

Discover how memory interleaving distributes addresses across banks for parallel access. Boost memory bandwidth in DDR5 and GPU systems.

NUMA Architecture: Non-Uniform Memory Access/concepts/systems/numa-architecture

Explore NUMA architecture and memory locality in multi-socket systems. Understand local vs remote memory access latency and optimization strategies.

RAID: Redundant Arrays for Speed and Safety/concepts/systems/raid-storage

RAID storage visualized: RAID 0, 1, 5, 6, and 10 levels explained. Learn how they work, when to use them, and disk failure recovery.

SoA vs AoS: Data Layout Optimization/concepts/systems/soa-vs-aos

Structure of Arrays vs Array of Structures as instruments: cache-line fill, SIMD gather vs contiguous load, GPU coalescing, and AoSoA hybrids — when layout is a 10× decision.

Linux Process Management: Fork, Exec, and Beyond/concepts/systems/process-management

Master Linux process management through interactive visualizations. Understand process lifecycle, fork/exec operations, zombies, orphans, and CPU scheduling.

Explore Linux memory management through interactive visualizations. Understand virtual memory, page tables, TLB, swapping, and memory allocation.

Transparent Huge Pages (THP): Reducing TLB Pressure/concepts/systems/transparent-huge-pages

Learn how Transparent Huge Pages (THP) reduces TLB misses by promoting 4KB to 2MB pages. Understand performance benefits and memory bloat tradeoffs.

Linux System Calls: The User-Kernel Interface/concepts/systems/system-calls

Linux system calls visualized: how user programs communicate with the kernel, protection rings, argument registers, error handling, and syscall performance.

Client-Server Communication: Polling vs WebSockets/concepts/systems/client-server-communication

Learn client-server communication patterns including short polling, long polling, and WebSockets. Compare HTTP protocols for real-time web applications.

Long Polling: The Patient Connection/concepts/systems/long-polling

Learn HTTP long polling - a server-side technique that holds connections open until data arrives. Achieve near real-time updates with standard protocols.

Master the Linux networking stack through interactive visualizations. Understand TCP/IP layers, sockets, iptables, routing, and network namespaces.

Short Polling: The Impatient Client Pattern/concepts/systems/short-polling

Learn short polling in networking - a simple HTTP pattern for periodic data fetching. See why 70-90% of requests waste bandwidth and when to use alternatives.

Understanding TCP/IP Protocol Stack/concepts/systems/tcp-ip

Explore the TCP/IP protocol stack, packet encapsulation, and how data travels through network layers from application to physical transmission.

Master WebSocket protocol for real-time bidirectional communication over TCP. Learn handshakes, frames, and building low-latency web applications.

Linux Boot Process: From Power-On to Login/concepts/systems/boot-process

Visualize the complete Linux boot sequence from BIOS/UEFI to login. Learn how GRUB, kernel, and systemd work together with interactive visualizations.

Linux Init Systems: From SysV to systemd/concepts/systems/init-systems

Compare Linux init systems through interactive visualizations. Understand the evolution from SysV Init to systemd, service management, and boot orchestration.

Master Linux kernel modules through interactive visualizations. Learn how to load, unload, develop, and debug kernel modules that extend Linux functionality.

Master Linux namespaces — the kernel mechanism that makes containers possible. Learn how mount, PID, network, and user namespaces create isolated environments, with interactive demos.

Compare Wayland vs X11 display servers on Linux. Learn about architecture, performance, security, and modern graphics stack.

Control groups as instruments: noisy neighbors, v1 vs v2 membership, CFS cpu.max periods, memory.high vs memory.max OOM, and how Docker flags become cgroup files.

Discover how containers work by combining namespaces, cgroups, and OverlayFS. Build a mental model of Docker internals through interactive visualizations.

Understand how containerized processes access GPU hardware through device files, bind mounts, and the NVIDIA container runtime. Learn the kernel driver vs user-space library distinction.

Learn nvidia-modeset for display configuration on Linux. Understand kernel mode-setting, DRM integration, and GPU drivers.

Explore how smaller transistors promised more speed at the same power, why voltage limits broke that bargain, and how chip design adapted.

Step a packet through a home router to see how NAT rewrites addresses and ports, what it breaks, how hole punching and NAT-T work around it, and why it is not security.

Follow a packet inside an encrypted VPN tunnel, separate wrapping from NAT, compare full and split routing, and see what Wi-Fi, ISPs and VPN servers can observe.

Language & Framework Internals/concepts/category/language-internals

How CPython, C++, and PyTorch work under the hood: bytecode, memory, linking, and concurrency.

Python Bytecode Compilation/concepts/language-internals/python-bytecode-compilation

Explore CPython bytecode compilation from source to .pyc files. Learn the dis module, PVM stack operations, and Python 3.11+ adaptive specialization.

PyTorch DataLoader Pipeline/concepts/language-internals/pytorch-dataloader-pipeline

Follow PyTorch batches through worker queues, collation, ordered delivery and GPU transfer, then measure loading throughput and budget process memory.

C++ Stack vs Heap Memory: A Complete Guide/concepts/language-internals/cpp-stack-vs-heap

Deep dive into C++ memory allocation — stack frame internals, heap allocator mechanics, fragmentation, performance benchmarks, custom allocators, RAII, and debugging with AddressSanitizer and Valgrind.

Python Memory Management/concepts/language-internals/python-memory-management

A practical mental model for CPython memory management: names and references, object headers, PyMalloc arenas, reference counting, reuse paths, and memory profiling.

Python Global Interpreter Lock (GIL)/concepts/language-internals/global-interpreter-lock

Follow CPython thread states, execution frames and shared objects through a GIL handoff. Inspect the source behind waiting, release, native work and application locks.

Pinned Memory and DMA Transfers in PyTorch/concepts/language-internals/pytorch-pin-memory

How page-locked memory changes CPU-to-GPU transfers, the extra staging in pageable paths, and the conditions needed to overlap copies with GPU work.

C++ Symbol Resolution: How the Linker Connects Your Code/concepts/language-internals/cpp-symbol-resolution

Complete guide to C++ symbol resolution — how linkers match references to definitions, name mangling, strong vs weak symbols, ODR, template instantiation, linking order, and debugging undefined reference errors.

C++ Program Loading: From ELF to Running Process/concepts/language-internals/cpp-program-loading

How Linux loads C++ programs: captured ELF segments, runtime mappings, startup handoffs, lazy binding and practical loader debugging.

Understanding num_workers/concepts/language-internals/pytorch-dataloader-num-workers

Why DataLoader num_workers matters: processes hide load latency behind GPU work, how to find the sweet spot, and the memory/GIL pitfalls that come with the pool.

Python Object Model Internals/concepts/language-internals/python-object-model

Learn how CPython implements PyObject, type objects, and the unified object model. Explore reference counting, memory layout, and Python internals.

Python Garbage Collection/concepts/language-internals/python-garbage-collection

Understand CPython garbage collection: reference counting, generational GC for circular references, weak references, and gc module tuning strategies.

Python __slots__ Optimization/concepts/language-internals/python-slots

Learn when Python __slots__ reduces memory, how slot storage differs from __dict__, and the caveats for dataclasses and inheritance.

Python Green Threads vs OS Threads/concepts/language-internals/green-threads-vs-os-threads

Complete guide to Python concurrency — OS threads, green threads (asyncio), the GIL, event loop internals, Python 3.13 free-threading, and production patterns.

Python asyncio Event Loop/concepts/language-internals/asyncio-event-loop

Deep dive into Python's asyncio library, understanding event loops, coroutines, tasks, and async/await patterns with interactive visualizations.

Python Shared Memory/concepts/language-internals/python-shared-memory

Master Python multiprocessing.shared_memory for zero-copy IPC. Learn synchronization, NumPy integration, and race condition prevention patterns.

Thread Safety: Concurrent Programming Fundamentals/concepts/language-internals/cpp-thread-safety

Complete C++ thread safety guide — race conditions with step-through simulation, mutexes, atomics, condition variables, deadlock detection, memory ordering, and Thread Sanitizer walkthrough.

C++ AST & Parsing Explained/concepts/language-internals/cpp-ast-parsing

Follow a C++ function from tokens to a simplified AST, then inspect exact source ranges, declaration references and types in a keyboard-accessible explorer.

C++ Compilation Overview/concepts/language-internals/cpp-compilation

Understand the complete C++ compilation pipeline from source code to object files. Learn preprocessing, parsing, code generation, and optimization stages.

C++ Dynamic Linking at Runtime/concepts/language-internals/dynamic-linking

Follow Linux shared libraries from dependency lookup to PLT/GOT binding, then build a versioned library, load a plugin and debug runtime linking failures.

C++ Linking Overview/concepts/language-internals/cpp-linking

How C++ object files are linked into executables. Learn symbol resolution, static vs dynamic linking, and linker optimization.

Memory Management & RAII in C++/concepts/language-internals/cpp-raii

Learn Resource Acquisition Is Initialization (RAII) - the cornerstone of C++ memory management. Understand automatic resource cleanup and exception safety.

Object-Oriented Programming in C++/concepts/language-internals/cpp-inheritance-polymorphism

Master C++ OOP concepts including inheritance, polymorphism, virtual functions, and modern object-oriented design principles with interactive examples.

C++ Compiler Optimization/concepts/language-internals/cpp-optimization

C++ compiler optimization lab notebook — compare optimization levels, inspect compiler rewrites, diagnose auto-vectorization, and build production verification commands.

Pointers & References in C++/concepts/language-internals/cpp-pointers-references

Understand C++ pointers and references with step-by-step memory diagrams: addressing, dereferencing, aliasing, array arithmetic, and object lifetime.

C++ Preprocessor Directives/concepts/language-internals/cpp-preprocessor

C++ preprocessor visualized: macros, header guards, conditional compilation, and #include directives explained interactively.

Smart Pointers in Modern C++/concepts/language-internals/cpp-smart-pointers

Master C++11 smart pointers through interactive examples. Learn unique_ptr, shared_ptr, and weak_ptr with reference counting visualizations.

Templates & STL in C++/concepts/language-internals/cpp-templates-stl

Master C++ templates and the Standard Template Library. Learn generic programming, template metaprogramming, and STL containers and algorithms.

DataParallel vs DistributedDataParallel/concepts/language-internals/pytorch-dataparallel-vs-ddp

Compare PyTorch DataParallel vs DistributedDataParallel for multi-GPU training. Learn GIL limitations, NCCL AllReduce, and DDP best practices.

C++ Virtual Tables & Inheritance/concepts/language-internals/cpp-virtual-tables

C++ virtual tables (vtables) explained. Learn virtual dispatch, single/multiple inheritance, RTTI, and object memory layout visually.

Tail Call Optimization and Python’s Tail-Call Interpreter/concepts/language-internals/tail-call-optimization

See how tail calls reuse stack frames, when compilers can eliminate them, and how CPython 3.14 applies tail calls to C opcode dispatch.

Interpreter Dispatch: Switch, Computed Goto, and Tail Calls/concepts/language-internals/interpreter-dispatch

Trace a small virtual machine through branches and loops, then compare switch, computed goto, and tail-call dispatch without changing its bytecode semantics.

Continuation-Passing Style: Make the Remaining Work Explicit/concepts/language-internals/continuation-passing-style

Follow direct-style and CPS factorial through the same calculation. See how closures carry pending work, why Python still grows call depth, and where trampolines fit.

Trampolines: Recursive Control Flow Through a Loop/concepts/language-internals/trampoline-recursion

Step through mutual recursion and a Call/Done trampoline to see deferred work, bounded worker depth, base cases, and the allocation tradeoff.

Comparisons/comparisons

Side-by-side deep dives on technical trade-offs

Expertise/expertise

Technical areas I cover, each linked to its reference page

Uses/uses

Tools, software, and hardware I use

Resume/resume

My professional experience and qualifications

Bookmarks/bookmarks

A curated collection of articles and resources I find valuable

Consulting/consulting

Services and consulting offerings

Sitemap/sitemap

Visual representation of the site structure

Privacy/privacy

How this site handles your data, cookies, and analytics

Mastodon