Notes

Tool Calling

Tool calling enables LLMs to run code and perform tasks beyond text generation, introducing a 4-message architecture and requiring careful context and tool design for long-horizon agentic tasks.

Agent Communication

An overview of different communication topologies and patterns for multi-agent systems, including linear, hierarchical, and network-based flows.

Agents

An exploration of what defines an AI agent, focusing on the transition from simple chatbots to autonomous systems using reasoning, tools, and frameworks like ReAct.

Splitting Monolith

A guide on strategies and considerations for decomposing a monolith into microservices, focusing on extraction priorities and verification techniques.

Metastable Failures

Analysis of metastable failures, retry storms, and mitigation strategies like exponential backoff and circuit breakers in high-load systems.

Modular Monolith

A deep dive into why Modular Monoliths are often the best choice for maximizing development velocity and managing volatility without the "distributed system tax."

Splitting Microservices

A comprehensive guide on decomposing systems into microservices using DDD, volatility, data compliance, technology runtimes, and organizational structure.

Domain-Driven Design

A foundational overview of Domain-Driven Design core concepts including Ubiquitous Language, Aggregates, and Bounded Contexts within a microservices architecture.

Coupling

An overview of the four main coupling types in microservice systems — Domain, Temporal, Pass-Through, and Common — with strategies for minimising or replacing each.

Coupling Cohesion

Discusses the importance of loose coupling and high cohesion in microservice architectures, referencing Constantine's Law.

Service Boundaries

Exploration of service boundaries and information hiding in microservice architecture based on Sam Newman's Building Microservices.

C Const

C Restrict

C Volatile

Type Qualifiers in C

Advanced Datatypes in C

C

C Complex Numbers

C Flexible Array Members

C Typedef

C Variable Length Array

C Auto Storage Class

C Extern Storage Class

C Register Storage Class

C Static Storage Class

Storage Classes in C

Introducing Concurrency

Serial and Parallel Execution

Atomics

Condition Variables

Lazy Initialization

Lock Poisoning

Memory Ordering

Memory Ordering

Rust Arc

Rust Atomics

Rust Cell

Rust Mutex

Rust Rc

Rust RwLock

Rust Statics

Rust Threads

Scoped Threads

Send Sync

Thread Parking

Rust Concurrency

Latency Throughput

Constant Variables

Restricted Pointers

Volatile Variables

Complex Numbers

Flexible Array Member

Preprocessor Directives

Type Alias

Variable Length Array

Computed Gotos in C (Direct Threaded Code)

Automatic Storage Duration

Register Storage

Variable Lifetime

Variable Linkage

Variable Scope

TypeScript Satisfies

Demonstration of using the TypeScript 'satisfies' operator with switch statements to achieve exhaustive pattern matching.

Concurrency

Scalability

Atomic Operations

Atomic Refcounting

Condition Variables

Interior Mutability

Lazy Initialization

Lock Poisoning

Memory Ordering

Mutex

Race Conditions

Reference Counting

RwLock

Scoped Threads

Send Sync

Static Lifetime

Thread Joining

Thread Parking

Threads

CHIP-8

Grill: C Systems Programming Knowledge

Comprehensive diagnostic grilling session mapping C17 fundamentals, storage duration, linkage, array decay, heap mechanics, bitwise arithmetic, and function pointer dispatch.

MCP

A standard protocol by Anthropic built on top of tool calling that exposes JSON-RPC endpoints for LLMs to communicate with external services as plugins.

Router Pattern

An architectural pattern where an LLM or classifier acts as a dispatcher to direct incoming queries to specialized tools, indexes, or prompt pathways.

Speculative Decoding

An optimization technique using a smaller model to generate candidate tokens validated in a single pass by a larger model to increase token throughput.

vLLM

A high-throughput and memory-efficient inference engine for LLMs, featuring PagedAttention.

Decoder

Decoder layers generate tokens autoregressively with causal (left-to-right) attention; the dominant architecture for modern generative LLMs.

Encoder

Encoder layers in transformers extract features from the full input via bidirectional attention; used alone for NLU tasks or with a decoder in seq2seq models.

LLMs

Central hub for all notes related to Large Language Models (LLMs), including architecture, retrieval, and optimization.

Re-ranking

A two-stage retrieval process where initial candidates from a broad search are filtered by a specialized ranking engine to improve precision.

Agentic RAG

Evolution of RAG into dynamic, autonomous systems where an LLM uses reasoning to manage the retrieval process, tool selection, and self-correction.

Knowledge Graphs

Combining vector search with graph databases to capture complex entity relationships missed by pure semantic search.

LightRAG

A specialized implementation of GraphRAG designed for efficiency and streamlined retrieval.

LMCache

A specialized system for sharing token caches (KV caches) across multiple requests or instances to optimize LLM performance.

Microsoft GraphRAG

Microsoft's framework for building knowledge graph-enhanced retrieval-augmented generation systems.

Needle Haystack

Exploration of the needle-in-a-haystack problem, highlighting context retrieval biases and architectural limitations in long-context LLMs.

Quantization

Techniques for reducing the precision of model weights to decrease memory usage and speed up inference.

RAG

Overview of RAG modalities and strategies for augmenting LLM queries with external, up-to-date, or private data.

Token Caching

A mechanism for reusing previously computed token states to speed up LLM inference and reduce computational costs.

Tokenization

A research note exploring different tokenization methods used in LLMs, including character-level, word-level, and sub-word techniques like BPE.

TurboQuant

A specialized inference kernel optimized for fast, quantized LLM execution.

Eat Frog

Core concepts and actionable steps from Brian Tracy's 'Eat That Frog!' for overcoming procrastination and focusing on high-value tasks.

SLM

C17 Glossary

C17 Hub

C17 Resources

C17 Teacher Notes

Lesson 0001: ISO C17 Standards, Compiler Diagnostics & CMake with SDL2

Lesson 0002: Safe Binary File I/O & ROM Loading into Memory at 0x200

LR-0001: Learner Background & C17 Baseline

LR-0002: CHIP-8 Codebase Audit & Architecture Baseline

LR-0003: CMake SDL2 Resolution & Integer Precision Diagnostics

LR-0004: Standard I/O Return Conventions & fread Parameters

Mission: C17 Systems Mastery via CHIP-8 Emulator

Modern C17 Toolchain and CMake Reference

Standard I/O & Binary File Streams in C17

A tail of enterprise CYA devlopemnt

Function Abstraction

The real reason to extract functions is to maintain local reasoning, not just DRY reuse, preventing monolithic function bloat and multiple reasons to change.

Defensive Programming

Perspectives on when to apply defensive programming at input boundaries versus avoiding excessive defensive checks against internal backend services and broken invariants.

LangGraph

A graph-based framework for orchestrating stateful, multi-agent workflows with loops, branching, and state persistence.

Demystifying Binary Protocols