Categories
Browse all posts by category.
-
Writing Technical Blog Posts That Actually Help People
Most technical posts teach syntax but skip the understanding. Here's how to write posts that give readers a genuine mental model, not just code to copy.
-
Technical Debt: When to Pay It Down and When to Ignore It
Not all technical debt is equal. Some debt slows you down every day; some sits quietly for years. Here's how to tell the difference and decide when to act.
-
Building a Second Brain as a Developer: Notes, References, and Recall
A second brain is a personal system for capturing and recalling the knowledge you need as a developer. Here's a practical approach that doesn't require perfect discipline.
-
How to Read Technical Documentation Effectively
Most developers skim docs and miss what matters. Here's a practical method for reading technical documentation that actually builds understanding and sticks.
-
The Art of the Technical Deep Dive: How to Understand Any System
A technical deep dive is a deliberate method for building real understanding of any system. Here's how to approach one without getting lost or wasting hours.
-
Code Review Best Practices: What to Look For and What to Skip
Effective code reviews catch real problems without slowing teams down. Here's what to focus on, what to automate away, and how to give feedback that actually lands.
-
Writing Effective Commit Messages: Conventional Commits Guide
Good commit messages make git history readable and automate changelogs. The Conventional Commits spec gives you a simple format to follow consistently across a team.
-
What is RAG? Building a Retrieval-Augmented Generation Pipeline
RAG lets LLMs answer questions about your own data without retraining. Learn how to build a retrieval-augmented generation pipeline from scratch with Python.
-
What is an AI Agent? (And How to Build a Simple One)
An AI agent combines an LLM with tools it can call and a loop that runs until the task is done. Here's what that means in practice, and how to build one from scratch.
-
VS Code Setup for Backend Developers: Extensions and Settings
A practical VS Code setup for backend developers: the extensions that actually help, settings worth changing, and keybindings for common workflows.
-
Semantic Versioning Explained: major.minor.patch and When to Bump
Semantic versioning gives version numbers meaning. Learn what major, minor, and patch represent, when to bump each, and how semver works with npm, pip, and git tags.
-
macOS Keyboard Shortcuts Every Developer Should Know
A practical cheat sheet of macOS keyboard shortcuts that save developers time every day — from Finder and terminal to text editing and window management.
-
Local LLMs with Ollama: Run AI on Your MacBook
Ollama makes running open-source LLMs like Llama 3, Mistral, and Phi-3 on your Mac as easy as a brew install. Here's everything you need to get started.
-
iTerm2 + Zsh + Oh My Zsh: The Ultimate macOS Terminal Setup
Set up a fast, beautiful, and productive terminal on macOS with iTerm2, Zsh, Oh My Zsh, and the plugins that actually save time. Step-by-step from scratch.
-
Homebrew: The Complete Guide for macOS Developers
Homebrew is the missing package manager for macOS. This guide covers installation, taps, casks, Brewfiles, and the commands you'll use every week as a developer.
-
Git Rebase vs Merge: When to Use Which
Rebase and merge both integrate changes but produce different histories. Here's a clear explanation of how each works, when to use which, and what to avoid.
-
Git Branching Strategies: Git Flow vs Trunk-Based Development
Git Flow and trunk-based development represent opposite ends of the branching spectrum. Here's how each works, when to use which, and the trade-offs that matter.
-
Fine-Tuning vs RAG: When to Use Which Approach
Fine-tuning and RAG both extend what an LLM knows, but they solve different problems. Here's how to decide which approach is right for your use case.
-
Understanding Embeddings and Vector Databases (pgvector, Pinecone)
Embeddings turn text into numbers, and vector databases make those numbers searchable. Here's how both work, with practical examples using pgvector and Pinecone.
-
Dotfiles: How to Manage and Sync Your Dev Environment
Dotfiles let you version-control your shell, editor, and tool configuration so any new machine is set up in minutes. Here's a practical approach using Git and symlinks.
-
Building a CLI Tool That Uses an LLM API
Build a real command-line tool backed by an LLM API using Python and Click. We'll cover streaming output, multi-turn conversations, and piping from stdin.
-
AI Coding Tools Compared: GitHub Copilot, Cursor, and Claude Code
GitHub Copilot, Cursor, and Claude Code each take a different approach to AI-assisted development. Here's a practical comparison to help you pick the right one.
-
XSS Attacks Explained: Types and Prevention
A practical guide to cross-site scripting (XSS) — the three types of XSS attacks, how each works, and how to prevent them with output encoding, CSP, and sanitization.
-
Understanding CORS: Why Your API Returns a Blocked Error
A practical explanation of CORS — why browsers block cross-origin requests, how preflight works, and how to configure CORS correctly in Nginx, Express, and FastAPI.
-
TypeScript Generics Explained with Practical Examples
A practical guide to TypeScript generics — type parameters, constraints, multiple generics, generic functions, generic interfaces, and built-in utility types with real examples.
-
System Design: How a URL Shortener Works
A practical walkthrough of how URL shorteners like bit.ly work under the hood — covering hashing, database design, redirects, and scaling.
-
System Design: Building a Notification Service
How to design a scalable notification service that handles push, email, and SMS — covering queue architecture, delivery guarantees, and failure handling.
-
SSH Key Management Best Practices
A practical guide to SSH key management — generating strong keys, using ssh-agent, organizing multiple keys, rotating credentials, and securing GitHub access.
-
SQL Injection: How It Works and How to Prevent It
A developer's guide to SQL injection — how attackers exploit vulnerable queries, the different attack types, and how parameterized queries and ORMs prevent them.
-
React Native Navigation: Stack, Tab, and Drawer Explained
A practical guide to React Native Navigation — setting up React Navigation, Stack, Tab, and Drawer navigators, passing params, and nesting navigators.
-
React Hooks Reference: useState, useEffect, useRef, useMemo
A practical React Hooks reference — useState, useEffect, useRef, useMemo, useCallback, useContext, and how to write custom hooks, with real usage patterns.
-
Prompt Engineering Basics: Patterns That Actually Work
A practical guide to prompt engineering — zero-shot, few-shot, chain-of-thought, role prompting, structured output, and patterns that reliably improve LLM responses.
-
OWASP Top 10 Explained with Code Examples
A developer-friendly walkthrough of the OWASP Top 10 web vulnerabilities — what they are, how attackers exploit them, and how to prevent each one.
-
Next.js App Router vs Pages Router: What Changed and Why
A practical comparison of Next.js App Router and Pages Router — file conventions, data fetching, layouts, server components, and when to migrate.
-
Load Balancing Strategies: Round Robin, Least Connections, Consistent Hashing
A practical guide to load balancing algorithms — round robin, least connections, IP hash, and consistent hashing — with Nginx and HAProxy config examples.
-
Message Queues Explained: Kafka vs RabbitMQ
A practical comparison of Kafka and RabbitMQ — how each works, what they're optimized for, and how to choose between them for your use case.
-
GraphQL vs REST: A Practical Comparison
A practical look at GraphQL vs REST — what each is good at, where each struggles, and how to choose between them for your next API project.
-
Getting Started with the Claude API: Your First AI-Powered App
A hands-on guide to building your first app with the Claude API — authentication, sending messages, system prompts, streaming responses, and handling errors.
-
CSS Grid Cheat Sheet: Real Layouts with Examples
A complete CSS Grid reference — grid-template-columns, grid-template-areas, auto-fill vs auto-fit, and real layouts like dashboards and card grids with working code.
-
CSS Flexbox Cheat Sheet: Every Property with Examples
A complete CSS Flexbox reference with visual examples — every container and item property explained, with common layout patterns you'll use every day.
-
Understanding Core Web Vitals: LCP, CLS, INP for Developers
A developer's guide to Core Web Vitals — what LCP, CLS, and INP measure, how to diagnose poor scores, and the code-level fixes that actually move the needle.
-
Caching Strategies: Redis, CDN, and In-Memory — Choosing the Right Layer
A practical guide to caching strategies — cache-aside, write-through, TTL, invalidation, and how to choose between in-process memory, Redis, and CDN caching.
-
Webhooks vs Polling: Which One and When
Compare webhooks and polling for API integrations — understand the trade-offs in latency, reliability, complexity, and security, with code examples for both approaches.
-
REST API Design Best Practices: Versioning, Errors, and Pagination
A practical guide to REST API design covering resource naming, HTTP status codes, versioning strategies, structured error formats, and cursor-based pagination.
-
Rate Limiting — Algorithms and Implementation Patterns
Learn the four main rate limiting algorithms — fixed window, sliding window, token bucket, and leaky bucket — and how to implement them with Redis and Nginx.
-
OAuth 2.0 and JWT Explained: How Auth Actually Works
A practical guide to OAuth 2.0 flows and JWT tokens — how they work together, when to use each grant type, and how to implement secure token validation in your API.
-
MongoDB Schema Design Patterns for Developers
Learn how to design MongoDB schemas using embedding and referencing patterns, with real examples of when to choose each approach for performance and scalability.
-
Connection Pooling Explained: Why max_connections Isn't Enough
Understand how database connection pooling works, why raising max_connections alone won't prevent connection storms, and how PgBouncer solves the problem at scale.
-
Writing Better Bash Scripts: Tips, Traps, and Patterns
A practical guide to writing robust, readable Bash scripts — covering safe mode flags, quoting rules, error handling, argument parsing, and common traps to avoid.
-
TypeScript for JavaScript Developers: A Quick-Start Guide
A practical introduction to TypeScript for JavaScript developers — covering types, interfaces, generics, and the tooling setup you need to get productive fast.
-
Query Optimization in SQL: EXPLAIN, Indexes, and Join Strategies
Learn how to read EXPLAIN ANALYZE output, choose the right indexes, and pick join strategies to diagnose and fix slow SQL queries in PostgreSQL.
-
Understanding Rust Ownership (Without Writing a Compiler)
A practical guide to Rust's ownership model — covering ownership rules, borrowing, lifetimes, and why the borrow checker exists, with concrete examples throughout.
-
Regular Expressions Cheat Sheet with Real-World Examples
A comprehensive regular expressions cheat sheet with real-world examples in Python, JavaScript, grep, and sed — covering anchors, groups, lookaheads, and common patterns.
-
Redis — Caching, Pub/Sub, and TTL: A Practical Guide
Learn how to use Redis for caching, publish/subscribe messaging, and TTL-based expiry with practical code examples in Python and CLI.
-
Python logging Module: A Practical Guide for Real Applications
A practical guide to Python's logging module — covering log levels, handlers, formatters, structured logging, and patterns for production applications.
-
Python Decorators: What They Are and When to Use Them
A practical guide to Python decorators — how they work, how to write your own, and when they genuinely simplify code versus when they add unnecessary magic.
-
Python Dataclasses vs Pydantic: When to Use Which
A practical comparison of Python dataclasses and Pydantic models — covering validation, serialization, performance, and when each tool is the right choice.
-
PostgreSQL vs MySQL: Key Differences Every Developer Should Know
A practical comparison of PostgreSQL and MySQL — covering data types, JSON support, transactions, full-text search, and which database is the right choice for your project.
-
ORM vs Raw SQL: Trade-offs and When to Switch
Compare ORMs like SQLAlchemy and Prisma against raw SQL, understand the performance and maintainability trade-offs, and know when to drop down to raw queries.
-
Go Goroutines and Channels: Concurrency Made Simple
Learn how Go goroutines and channels work together to make concurrent programming practical, safe, and surprisingly readable.
-
Go Error Handling Patterns: The errors Package and Beyond
A practical guide to Go error handling — covering sentinel errors, error wrapping, errors.Is and errors.As, custom error types, and patterns for clean production code.
-
Database Sharding and Partitioning: When and How
Understand the difference between database sharding and partitioning, when each technique applies, and what trade-offs you accept when you split your data.
-
Database Indexing Explained: B-Trees, Covering Indexes, and When Indexes Hurt
A practical guide to database indexing — how B-tree indexes work, when to use composite and covering indexes, and the hidden costs that make over-indexing a real problem.
-
Understanding the CAP Theorem with Practical Examples
The CAP theorem states you can only guarantee two of three properties in a distributed system. Here's what that actually means for the databases you use every day.
-
ACID Properties Explained with Real SQL Examples
Understand ACID — Atomicity, Consistency, Isolation, and Durability — with clear SQL examples showing what each property actually protects you from.
-
What is a Service Mesh? (Beyond Istio)
Understand what a service mesh does, when you actually need one, and how Istio, Linkerd, and Cilium differ in their approach to managing microservice traffic.
-
What is a Reverse Proxy? (And When to Use One)
Learn what a reverse proxy is, how it differs from a forward proxy, and how to configure one with Nginx — covering SSL termination, load balancing, and header forwarding.
-
What is a CDN and How Does Caching Work?
Understand how CDNs cache and serve content at the edge, how Cache-Control headers drive caching behavior, and how to use curl to inspect what your CDN is actually doing.
-
Understanding WebSockets vs HTTP Long Polling
Compare WebSockets, HTTP long polling, and Server-Sent Events for real-time features — with code examples and guidance on when to choose each approach.
-
tmux — Terminal Multiplexer Setup and Workflow
Learn tmux from scratch: sessions, windows, panes, keybindings, and a practical workflow for remote development and long-running processes.
-
Terraform Basics: Infrastructure as Code in 10 Minutes
Get started with Terraform by learning how to define, plan, and apply cloud infrastructure as code, with an AWS EC2 instance as a working example.
-
TCP vs UDP: When Each Protocol Matters
A practical explanation of TCP vs UDP — how each protocol works, their trade-offs, real-world use cases, and when to choose which for your application.
-
strace — Tracing System Calls for Debugging
A practical guide to strace for tracing system calls on Linux, with real examples for debugging crashes, slow programs, and permission errors.
-
SSL/TLS Certificates Explained: How HTTPS Actually Works
Understand how TLS certificates work, what the handshake does, how certificate authorities establish trust, and how to get and configure free HTTPS with Let's Encrypt.
-
ssh — Complete Guide: Keys, Config, Tunnels, and Agent Forwarding
A thorough SSH reference covering key generation, ssh-agent, the client config file, port forwarding, jump hosts, and agent forwarding with real examples.
-
sed — Stream Editor Guide for Text Manipulation
A practical guide to sed covering substitution, deletion, insertion, address ranges, and in-place editing with real terminal examples.
-
rsync — Syncing Files Like a Pro
A practical rsync guide covering flags, incremental transfers, remote syncing over SSH, excludes, dry runs, and real backup workflows.
-
jq — Querying JSON from the Terminal: A Practical Guide
Learn how to use jq to filter, transform, and reshape JSON data directly in the terminal with practical examples and real command output.
-
Python Virtual Environments: venv, pyenv, and conda Compared
Understand when to use venv, pyenv, or conda for Python environment management, with practical commands for each tool and advice on combining them.
-
Python asyncio — Async/Await Explained with Examples
Learn how Python's asyncio event loop, coroutines, and async/await syntax work, with practical examples covering concurrent HTTP requests and async I/O.
-
Prometheus + Grafana: Monitoring Your App from Scratch
Set up Prometheus and Grafana to collect, store, and visualize metrics for your application, with alerting rules and a working Docker Compose stack.
-
Understanding Ports, Sockets, and Network Interfaces
A clear explanation of how ports, sockets, and network interfaces work together — covering IP binding, common port numbers, and how to inspect network state with ss and lsof.
-
nslookup, dig, and host — DNS Lookup Tools Explained
Learn how to use nslookup, dig, and host to query DNS records, debug resolution issues, and inspect A, CNAME, MX, TXT, and NS records from the terminal.
-
Normal Forms in DBMS: A Practical Guide to Database Normalization
A practical guide to database normalization covering 1NF, 2NF, 3NF, BCNF, and 4NF with real SQL examples to help you design clean, efficient relational schemas.
-
netstat and ss — Diagnosing Network Connections on Linux
Learn how to use netstat and ss to inspect open ports, active connections, socket state, and listening services on Linux with practical examples.
-
make and Makefiles — Automating Tasks Beyond C Projects
A practical guide to writing Makefiles for task automation in any project — not just C — with real patterns for building, testing, linting, and deploying.
-
lsof — List Open Files and Diagnose Port Conflicts
Learn how to use lsof to list open files, find which process owns a port, and debug file handle leaks on Linux and macOS.
-
Linux File Permissions Explained: chmod, chown, umask
A clear explanation of Linux file permissions, the chmod octal and symbolic modes, chown for ownership changes, and how umask controls new file defaults.
-
Kubernetes Pods, Deployments, and Services Explained
Understand the three core Kubernetes building blocks — Pods, Deployments, and Services — with real YAML manifests and kubectl commands.
-
Understanding HTTP/2 and HTTP/3: What Changed and Why
A clear explanation of how HTTP/2 and HTTP/3 improve on HTTP/1.1 through multiplexing, header compression, QUIC, and 0-RTT connection setup.
-
htop vs top — Monitoring Processes in the Terminal
A practical comparison of htop and top for monitoring Linux processes, CPU, and memory — with interactive shortcuts and real-world usage tips.
-
Helm Charts — Packaging Kubernetes Applications
Learn how Helm charts work, how to install community charts, and how to write your own chart to package a Kubernetes application for repeatable deploys.
-
HAProxy Configuration Guide with Cheat Sheet
A practical HAProxy configuration guide covering global settings, frontends, backends, load balancing algorithms, health checks, ACLs, and SSL termination.
-
gRPC vs REST: Which One Should You Use?
A practical comparison of gRPC and REST APIs covering performance, tooling, streaming, and when each protocol is the right choice for your backend.
-
grep, egrep, and ripgrep — Pattern Matching Cheat Sheet
A complete reference for grep, egrep, and ripgrep covering flags, regex syntax, recursive search, and real-world one-liners for searching code and logs.
-
GitHub Actions CI/CD: Build, Test, and Deploy a Project
Set up a complete CI/CD pipeline with GitHub Actions that builds, tests, and deploys your app automatically on every push to main.
-
`find` — Advanced File Search with Real Examples
Master the Unix find command with real examples covering name, size, time, permissions, and exec — the most powerful file search tool in your terminal.
-
Docker Compose — Multi-Container App Setup Guide
Learn how to define, link, and run multi-container applications with Docker Compose using a practical web app and database example.
-
Docker Basics: Containers, Images, and Volumes Explained
Learn how Docker containers, images, and volumes work with practical examples you can run right now on any Linux or macOS machine.
-
DNS Deep Dive: A Records, CNAME, MX, TTL Explained
A complete guide to how DNS resolution works, the most important record types, TTL and caching, and how to debug DNS issues with dig and nslookup.
-
cron and crontab — Scheduling Jobs on Linux and macOS
A practical guide to cron and crontab for scheduling recurring tasks on Linux and macOS, with syntax breakdowns and real-world examples.
-
awk Command Cheat Sheet with Real Examples
A practical awk reference covering field splitting, patterns, built-in variables, and real one-liners for text processing on Linux and macOS.
-
Understanding ArgoCD: GitOps for Kubernetes
Learn how ArgoCD implements GitOps by syncing Kubernetes clusters to a Git repository, with a full setup walkthrough and real-world deployment patterns.
-
Ikigai: 10 Rules to a Fulfilling Life
Discover the 10 essential rules of Ikigai, a Japanese philosophy for a fulfilling life. Learn how to find purpose, embrace happiness, and live each day meaningfully.
-
Getting started with Go (Mac)
Learn how to set up Go (Golang) on a Mac and run a basic "Hello, world!" program. This step-by-step guide includes prerequisites, installation commands, and a simple program example.
-
The Apple Event 2024: A Glimpse into the Future of Technology
Discover the highlights from Apple's WWDC24 event, including VisionOS 2, iOS 18, macOS Sequoia, Apple Vision Pro updates, and more. Learn about the latest innovations and features announced by Apple.
-
Master SQL: A Comprehensive Guide to DDL, DML, DCL, and TCL
Structured Query Language (SQL) is the backbone of managing and manipulating relational databases. Whether you’re working with MySQL, PostgreSQL, SQLite, or any other SQL-based database, knowing the different facets of SQL is…
-
How “Atomic Habits” is Changing My Life
Discover how "Atomic Habits" by James Clear can transform your life with small, consistent changes. Read my personal review and key takeaways from the book.
-
Mastering the nginx.conf File: A Guide with Cheat Sheet
Introduction The nginx.conf file is the cornerstone of configuring NGINX, a versatile and powerful web server that excels in serving static content, acting as a reverse proxy, and handling load balancing with…
-
Understanding CPU Throttling: What It Is and How to Manage It
CPU throttling, a term that might sound daunting at first, is actually a protective measure for your computer. It’s like your CPU deciding to take a breather to avoid overheating or to…
-
Mastering Subprocess Management in Python with subprocess.run()
In the world of Python, executing external commands or scripts from within your Python application is a common task. Whether it’s for automating system tasks, using shell commands, or running other programs,…
-
UNIX: init command
Introduction: Unix-like operating systems provide a robust set of tools for managing processes, and at the heart of this process management is the init command. In this post, we’ll dive into the…
-
Understanding Istio Proxy: Enhancing Microservices Communication
In the evolving landscape of microservices architecture, managing communication and security between services can be complex. This is where Istio, a service mesh, steps in, bringing order and efficiency with its powerful…
-
Introduction to Markdown and Mermaid
Markdown is a lightweight markup language with plain text formatting syntax. It’s designed so that it can be converted to HTML and many other formats. Mermaid, on the other hand, is a…
-
React Native Stylesheet Cheat Sheet
Creating a cheat sheet for React Native’s StyleSheet can be very useful for quick reference. Here’s a concise overview of some of the most commonly used style properties in React Native: Layout…
-
What is /etc/hosts file?
The “/etc/hosts” file is a plain text file found in Unix-like operating systems, including Linux and macOS. It serves as a simple, local DNS (Domain Name System) resolver. But what does that…
-
Basics of Curl
In the vast landscape of command-line tools, one gem stands out for its versatility and power: the curl command. Whether you’re a seasoned sysadmin, a developer, or just someone curious about the…
-
Hello blog!
Hi! Welcome to my first blog post. Attempt 3. Previously, I lost my WordPress server due to some crashes. On this blog, I’ll share updates about programming, photography, music, and other things…
-
Git Basics
Git is a tool that helps people work on projects together. It’s like a super organized way to keep track of changes in projects, whether they’re small or really big. It’s not…
No posts in this category.