144 posts · page 2 of 3
A practical tour of Rust variables and scalar types — let, mut, shadowing, integers, floats, booleans, chars, tuples, arrays, type inference, and constants. With runnable examples.
A practical introduction to Rust — where it came from, the three design goals that shape every decision, what it's the right tool for, and what it isn't. With your first Rust program.
A hands-on tour of Amazon S3 — buckets vs objects, naming rules, regions, public vs private access, presigned URLs, and the everyday aws s3 CLI commands.
A no-fluff introduction to Amazon Web Services — the mental model of compute, storage, database, and networking, regions and AZs, the free tier, and an IAM-first mindset.
A practical, opinionated guide to writing a software engineer's resume — impact bullets, tech stack lists, side projects, and the common mistakes that get resumes skipped in ten seconds.
Write your first GitHub Actions workflow from scratch — set up .github/workflows/ci.yml, run tests on every push and pull request, and add a status badge to your README.
A clear introduction to CI/CD — what continuous integration and continuous delivery actually mean, why teams adopt them, and the tools that implement them in practice.
A clear introduction to retrieval-augmented generation — why LLMs don't know your data, how embeddings and vector search solve it, and when RAG beats fine-tuning.
A clear introduction to FastAPI — ASGI and Starlette, Pydantic-driven validation, automatic OpenAPI docs, async support, and how it compares to Flask and Django.
Go's control flow in full — if with an init statement, the only loop (for) in all four forms, switch without break, type switches, and how defer fits in.
A complete guide to Go functions — declarations, parameters, multiple and named returns, the error idiom that defines Go, variadic parameters, and functions as values.
A complete setup guide for Go on macOS, Linux, and Windows — install the toolchain, verify with go version, create a module, and run a real program with go run and go build.
A practical guide to Go's two everyday collections — slices and maps. Covers arrays vs slices, make and append, len and cap, the shared-backing-array gotcha, and the comma-ok idiom.
A practical tour of Go's variable declarations and basic types — var vs :=, int and float64, strings, bool, byte and rune, zero values, type conversion, and constants.
A practical introduction to Go — where it came from, what it was designed to fix, the kinds of systems it excels at, and the kinds it doesn't. With your first Go program.
CSS Grid is the modern tool for two-dimensional layout. This guide covers tracks, the fr unit, gaps, spans, and responsive grids — everything you need to build real page layouts.
Responsive design makes a single site look right on every screen. This guide covers the viewport meta tag, mobile-first thinking, media queries, fluid units, and responsive images.
Selectors decide which elements get styled; specificity decides which rule wins when more than one applies. This guide covers every selector you need and how to read a specificity score.
Forms are how the web collects information. This guide covers every part of an HTML form — the form element, input types, labels, validation, and submission — so you can build forms users can actually use.
A hands-on tour of the three Kubernetes objects you will use every day — pods, deployments, and services — with real YAML, the kubectl commands to apply them, and how they fit together.
A practical introduction to Kubernetes — what problem it solves, the vocabulary you need (cluster, node, pod, deployment, service), and when running a single Docker container is enough.
Write your first bash scripts — shebangs, variables, arguments, conditionals, loops, command substitution, exit codes, and the safety line every script should start with.
A clear introduction to machine learning for developers — supervised vs unsupervised, features and labels, train/test split, when ML beats rules, and a tiny scikit-learn example.
A clear, honest introduction to large language models — tokens, next-token prediction, training vs inference, context windows, why hallucinations happen, and when LLMs are the right tool.
A practical guide to the daily DataFrame moves — read_csv and read_json, head and info, column selection, loc vs iloc, boolean filtering, sorting, and value_counts.
A clear introduction to pandas — what DataFrames and Series are, why analysts and ML engineers live in it, how to install it, and a tiny first end-to-end example.
A practical guide to installing Node.js with nvm on macOS, Linux, and Windows — checking versions, running .js files, and using the REPL for quick experiments.
A practical guide to file I/O in Node — fs/promises vs callback vs sync, path.join for safe paths, and how to find the current file with __dirname or import.meta.url.
A practical comparison of CommonJS and ES Modules in Node — require vs import, module.exports vs export, the type field in package.json, and the interop traps to avoid.
A practical tour of npm and package.json — npm init, dependencies vs devDependencies, scripts, the lockfile, semver basics, and the difference between npm install and npx.
A clear introduction to Node.js — the V8 engine, the event loop, non-blocking I/O, the npm ecosystem, and when Node is the right runtime for your project.
A practical guide to prompting LLMs — system vs user prompts, clarity over cleverness, few-shot examples, structured JSON output, chain-of-thought, and eval-driven iteration.
A clear introduction to REST — resources, URIs, HTTP verbs, statelessness, status codes, JSON conventions, and how REST compares to RPC and GraphQL.
A practical guide to conditional rendering in React — early returns, ternaries, the && shortcut and its zero pitfall, component maps, and the loading/error/empty pattern.
A practical guide to rendering lists in React with .map() — why the key prop matters, the difference between stable and index keys, and the bugs that come from getting keys wrong.
Build your first real schema — CREATE TABLE with the right column types, PRIMARY KEY, NOT NULL, DEFAULT, then load it with single and multi-row INSERT, and learn when to reach for ALTER or DROP.
Where each database shines, where each frustrates, the dialect differences that bite when you port code (LIMIT vs TOP, autoincrement, JSON, full-text), and the hosting concerns that decide for you.
A practical introduction to SELECT, FROM, WHERE, ORDER BY, LIMIT, and DISTINCT — with a running users and orders dataset so every query has real meaning.
A clear, no-hype introduction to SQL — what relational databases are, why declarative querying matters, the main dialects, and when SQL beats spreadsheets or NoSQL.
A practical walkthrough of installing Tailwind CSS v4 in a new project — the npm package, the @import directive, content sources, and quick integration notes for Vite and Astro.
An honest introduction to Tailwind CSS — what utility-first means, the design-token system, the JIT engine, the ugly-HTML tradeoff, and when component CSS is still better.
A practical introduction to pytest — installation, test discovery, the assert statement, parametrize, fixtures, and the command-line flags you will use every day.
A practical introduction to Vitest — why it exists, installation, describe and it, expect matchers, watch mode, and a small mock example for testing modern JavaScript.
An honest introduction to automated testing — unit, integration, and end-to-end tests, the testing pyramid, why tests pay back over time, and common excuses for skipping them.
Learn Docker Compose by building a small two-service app — a web API and a Postgres database — defined in a single compose.yaml file and started with one command.
A practical deep dive into how Docker images are stored as layers, how the build cache works, and the real difference between bind mounts and named volumes.
A step-by-step setup guide for Docker on Windows, macOS, and Linux. Install the engine, verify it works, and run your first container in under fifteen minutes.
Learn how to write a Dockerfile from scratch. Understand each instruction, build a real image for a small Node application, and run it as a container.