Three Types of Transformers
Encoder, decoder, and seq2seq transformers compared by what they output, an example model, typical use cases, and typical size.
Posts
All Posts
A chronological archive of projects, sketches, and technical notes.
LLM Basics: Transformers, Tools, and Agents
Notes on the three transformer architectures, chat templates and special tokens, tool calling and MCP, and the agent Thought/Action/Observation loop.
URL Shortener
Requirements, short code generation strategies, caching, and scaling reads and writes with separate read/write services.
YouDescribe: AI Audio Description Pipeline
A pipeline that turns raw video into scene-segmented, cross-checked, precisely-timed audio descriptions.
PPO vs DPO
A short note on PPO and DPO, two ways to align a model's responses with human preferences.
Agent and RAG Tradeoffs: Cost, Latency, Quality, and Evaluation
A practical note on cost-latency-quality tradeoffs in agent and RAG systems, how to evaluate RAG by separating retrieval quality from answer quality, and how to structure a project narrative.
Designing a Like Feature
A practical system design note for a post like feature, from database modeling to large-scale asynchronous like-count aggregation.
System Design Components
Nine components that show up in nearly every system design interview, what each one actually solves, and the one trade-off worth knowing for each.
VLM Basics: What a Model Actually Sees
A frame never reaches a vision-language model as pixels. Seven facts about images, JPEG, base64, vision encoders, and where VLMs still fall short, checked against a real evaluation pipeline.
Five Ways to Evaluate an AI System
Deterministic checks, reference-based metrics, LLM-as-judge, human review, and online feedback: what each one compares, and when to reach for which.
Malicious IP Detection
Requirements, QPS estimation, a hot/cold path split, and three deep dives: Bloom filter sizing, blacklist propagation, and layered detection.
Building a RAG Agent for a Public Health App: What Actually Broke
Five lessons from building and testing a LangGraph RAG agent for a public health app - history pollution, citations that must travel around the model, and a safety gate that backfired.
Inside a RAG Agent: Runtime, Memory, Tools, and Retrieval
Five design boundaries inside a LangGraph RAG agent: control flow, safety and tools, retrieval compatibility, checkpointed memory, and session isolation.
Pub/Sub + Cloud Run: Async Pipeline
A practical note on GCP Pub/Sub, Cloud Run, ack/retry semantics, DLQ, idempotent consumers, and the AWS SNS/SQS/Lambda mapping.
Python GIL: Why Multiple Threads Do Not Mean Parallel Python
The GIL means one CPython process can run only one Python-bytecode thread at a time. This is a threading issue, not an async/await issue.
Database Basic: Choosing Relational vs Non-relational Databases
A practical note on choosing relational vs non-relational databases based on query patterns, transactions, consistency, scale, and access model rather than only data relationships.
Postgres Indexing Review: B-tree, B+ Tree, and GIN
A compact poster and bilingual review note for Postgres indexing: table versus index, B-tree and B+ tree behavior, GIN indexes, jsonb operator traps, and index selection strategy.
Optimistic Lock vs Pessimistic Lock
A short database concurrency note on when to use pessimistic locking, optimistic locking, and database constraints.
WebSocket Connection Manager
A WebSocket connection manager lets the backend remember who is connected, push to a specific user, broadcast to everyone, and clean up disconnected sockets.
FastAPI WebSocket Handler Lifecycle
Understand why a FastAPI WebSocket handler lives as long as the connection lives, from accept to receive loop to disconnect cleanup.
WebSocket Protocol Fundamentals
WebSocket starts as an HTTP Upgrade request, switches to a frame-based protocol, and keeps one TCP connection open for full-duplex realtime communication.
Network Layering Model
A compact poster explaining the TCP/IP five-layer model, where common protocols belong, how HTTPS travels through the stack, and how to debug network issues by layer.
FastAPI Concurrency Implementation
How FastAPI actually runs sync and async routes: Uvicorn worker processes, one event-loop thread, AnyIO's thread pool, database pool sizing, and deployment traps.
Python Backend Concurrency Model
A Python backend concurrency cheat sheet: processes, threads, coroutines, sync versus async, the GIL, and how to choose between threads, async, and processes.
TCP Handshake Basics
A compact note on how TCP opens with SYN, SYN-ACK, ACK and closes with FIN, ACK, FIN, ACK.
Parking Lot OOD Basics
An entry-level object-oriented design note for a parking lot system, focused on vehicles, spots, and simple spot assignment.
OOD Interview Answer Flow
A compact interview reference for structuring object-oriented design answers and explaining the four core OOP principles.
Distributed Data Parallel
A compact visual guide to DDP: full model copies, per-GPU batches, gradient all-reduce, NCCL, and when Forge should use DDP versus FSDP.
HPC + GPU + PyTorch Practical Guide
A practical note for the full HPC to GPU to CUDA to PyTorch to backpropagation workflow on Northeastern Explorer.
Agent System Architecture
A simple overview of agent system architecture, the orchestrator and its four core components, LLM, tools, memory, and context engineering.
Distributed Databases: Why We Distribute, and What Gets Hard
A systems note on why databases get distributed, how scaling paths differ, and why partitioning, joins, and consistency become harder once data leaves a single machine.
Message Queues: Decoupling Work Without Losing Reliability
A systems note on why asynchronous messaging exists, how queues decouple producers and consumers, and why acknowledgments, persistence, and failover matter.
RabbitMQ in Python: Exchanges, Routing Keys, and Bindings
A practical RabbitMQ note in Python focused on the routing model: what an exchange does, what a routing key carries, and how bindings decide which queues receive a message.
A Practical AWS Migration Path for Mature Stateful Monoliths
A practical migration note for mature stateful monoliths, using a classic RuoYi-style Spring Boot system as the concrete example.
Building a ReAct Agent
A small ReAct agent project that makes the reasoning-action-observation loop visible instead of hiding tool use behind built-in function calling.
Agent Harness Overview
A sketch of how agent systems split responsibilities between the model and the harness around it.
Attention Is All You Need
A sketch of the Transformer paper, with the main architecture pieces and a few key questions to keep in mind while reading it.
Agentic Workflow: Reason, Act, Observe
A compact sketch of a tool-first agentic workflow, showing how reasoning, tool use, observation, memory, and human review fit together in one loop.
ReLU, Neural Nets, and Backpropagation
A compact sketch of ReLU activations, neural network structure, and backpropagation flow.
Redis Overview
A compact Redis sketch covering data types, commands, cache patterns, and configuration notes.
Native to Agentic RAG
A two-stage RAG project that moves from a local baseline to an agentic workflow with grading, routing, retries, and web fallback.
Git Command Cheatsheet
A quick Git command cheatsheet covering repository setup, branching, status checks, commits, sync, and rollback basics.
Python Command Cheatsheet
A quick command cheatsheet for checking Python, managing virtual environments, handling packages, and running files or modules.
RAG Overview
A visual overview of retrieval, ranking, and generation flow in a RAG pipeline.
Kafka Overview
A quick structural sketch of brokers, partitions, consumer groups, and replication.
AWS S3 Object Backup and Delayed Cleanup System
An event-driven AWS backup system that creates timestamped S3 copies, tracks lifecycle metadata in DynamoDB, and removes stale backups through a scheduled cleanup path.
AWS Event-Driven S3 Cleanup System
A serverless workflow that tracks S3 bucket size over time, triggers cleanup when thresholds are reached, and generates a final plot from workflow history.
