Topics by Categories

Snippets and gotchas for cleaner, faster Python.

Language and browser tricks for apps that feel snappy.

Types and tsconfig notes that catch bugs before runtime.

Small Ruby tricks that make scripts and gems feel nicer.

Modern PHP notes for apps that have to live on the web.

Practical Java notes for services that have to stay up.

Simple Go patterns for services that stay fast and boring.

Ownership and cargo notes that make the borrow checker a friend.

Pointers, memory, and C notes for code that has to be small and fast.

Modern C++ notes without drowning in the old corners.

Language and .NET notes for apps that feel tidy.

Joins, indexes, and query notes that make the database work for you.

Language and SwiftUI notes for iOS and Mac apps.

Null safety, coroutines, and less boilerplate.

Stats, plots, and R notes for people who live in data frames.

Null safety and language notes for Dart that is not only UI.

Functional Scala notes for services that still like types.

OTP, processes, and Elixir notes for systems that do not die.

Processes, messages, and reliability notes that still hold up.

REPL, data, and Lisp notes on the JVM.

Pure functions and type notes for brains that like proofs.

Embeddable Lua notes for games, Neovim, and tiny scripts.

One liners and text tricks from the original glue language.

Fast scientific Julia notes when Python is not enough.

Explicit Zig notes for people who want C, but safer.

Compiled Nim notes for scripts that need to go fast.

Typed Crystal notes for people who miss Ruby at runtime speed.

Contract notes so you do not learn fees the hard way.

Numeric Fortran notes still running in labs and clusters.

Practical COBOL notes for systems that still move money.

Strong Ada notes for code that cannot shrug at bugs.

Registers, calling, and asm notes when you have to go lower.

Message sends and runtime notes for apps that have not gone Swift.

VB notes for desktop and Office code that is still in prod.

Matrix and toolbox notes for science and engineering work.

Gradle and Groovy notes for build files and scripts.

Object Pascal notes for desktop apps that last.

The Elm architecture for UIs that refuse to crash.

Functional F# notes for people who want types and less noise.

Types and modules for compilers, tools, and serious backends.

Friendly types for people who like Elixir, but stricter.

Pins, shells, and flakes so "works on my machine" goes away.

Explicit Odin notes for games and tight systems work.

Scene and script notes for games you can actually finish.

Hardware description notes for FPGAs and chips.

Macros and lists for people who like code as data.

Minimal Lisp notes for language nerds and SICP fans.

Systems D notes when you want speed and a garbage collector.

Simple V notes for people chasing tiny binaries.

One Haxe codebase for web, games, and native.

Objects in the shell, not just blobs of text.

Script notes that fail less on other people's machines.

One liners that slice logs and CSV without a ceremony.

Governor limits and Apex notes for cloud that has rules.

Enterprise ABAP notes for systems that run the back office.

Procedures and packages that keep logic close to the data.

Procedures, windows, and T-SQL notes from the Microsoft side.

Logic notes for puzzles, rules, and a different way to think.

Sweeter JS notes for code that never got rewritten.

Sound types for front ends that want OCaml energy.

Haskell-like types for JS without the runtime mess.

Python-shaped notes for code that has to run hot.

Blocks and ideas for teaching people to think in code.

Enterprise stats notes that still show up in reports.

Hardware notes for people who describe wires, not objects.

CLOS, macros, and a language that never really left.

Lisp notes from the people who teach compilers.

Concatenative notes for embedded minds.

Clear structured notes that still teach well.

Expect, Tk, and script notes from the Unix workshop.

Objects all the way down, still a joy.

Syntax notes if you came from JS and stayed for types.

Kernels and memory notes for compute that has to fly.

Front of the site notes learned the hard way.

Browser UI notes for pages that feel fast and clear.

npm, streams, and server JS tricks you can paste into your brain.

Practical Rails notes for apps that stay maintainable.

Hooks, components, and patterns that keep React apps calm.

Vue notes for UIs that feel light and easy to change.

Components, RxJS, and patterns for big front ends.

DOM tricks for codebases that have not moved on yet.

Markup notes that make pages easier to read, style, and ship.

Semantic tags and browser APIs beyond the old cheat sheet.

Selectors, flex, and little CSS tricks for pages that look right.

Grid, animation, and modern CSS that used to need hacks.

Schema and resolver notes so clients get what they need.

App router, server components, and shipping React without a mess.

File routes and Vue notes that feel like a full stack.

Less runtime, more UI, fewer moving parts.

Routes, forms, and Svelte that acts like a framework.

Signals and components when React feels heavy.

Content sites that stay fast by default.

Nested routes and forms that lean on HTTP.

Build time notes for sites that still run on Gatsby.

HTML over the wire when JS frameworks feel like overkill.

Sprinkle behavior on HTML without a build.

Ambitious web app notes from a framework that lasts.

Models and views for apps that predate React.

Views, ORM, and admin notes for Python on the web.

Tiny Python web notes you can still hold in your head.

Python APIs that feel quick to write and quick to run.

Eloquent, queues, and Laravel notes that get out of the way.

Components and bundles for PHP that has to scale.

Beans, boot, and Java web notes from the enterprise default.

Auto config notes so you ship a service, not a XML file.

Middleware notes for the JS server everyone still has.

Decorators and modules for APIs that grew up.

Schema and plugin notes for Node APIs that care about speed.

Tiny web apps that run on workers, Node, and bun.

Elixir web notes for pages that update without a SPA.

C# web notes for APIs and sites on modern .NET.

Components for people who want .NET on both sides.

Fast handlers when net/http feels too bare.

Go HTTP notes if you came from Node.

Extractors and routes for Rust web services.

Actors and HTTP notes for Rust on the web.

Rust web notes with a friendly face.

Themes, hooks, and PHP notes for the CMS you cannot ignore.

Modules and CMS notes when WordPress is not enough.

Utility classes that still look like a design system.

Components for pages that need to look decent today.

Variables and mixins for stylesheets that grew.

Components you own, not a black box library.

State notes for when context is not enough.

Cache and fetch notes that stop the spinner soup.

Chromium plus Node notes for apps on the dock.

Rust shells for web UIs that should not weigh 200MB.

End to end TypeScript calls without writing a schema twice.

C#, ASP.NET, and LINQ tricks that keep services solid.

Swift and Xcode notes to ship apps a little faster.

Kotlin, Java, and Studio notes from building real apps.

Bridge, native modules, and JS notes for phones.

Widgets and Dart notes for apps on every screen.

Declarative Apple UI notes that still fight you sometimes.

Kotlin UI notes after the XML years.

React Native notes with less native pain.

Web UI on phones when native is too much.

C# mobile notes for codebases that have not moved.

Native plugins for PWAs that need a store listing.

Indexes, JSON, and Postgres notes that keep data honest.

Schema, indexes, and query notes for document data.

Cache, queues, and data structure notes for the hot path.

Indexes and InnoDB notes for the database everyone has.

File database notes for apps, agents, and local first.

Indexes, jobs, and T-SQL notes in production.

Planner and PL/SQL notes for databases that never sleep.

Mapping and query notes so relevance is not a guess.

Ring and partition notes for data that keeps growing.

Keys and indexes first, tables second.

Engine notes for the fork a lot of Linux boxes run.

Cypher notes when joins start to look like a maze.

Column notes for analytics that cannot wait.

SQL on files without standing up a cluster.

Warehouses and shares for data teams.

Slots and SQL notes on Google's warehouse.

Typed ORM notes for Node and TypeScript.

Lightweight TS ORM notes without the magic.

Core and ORM notes that stay close to SQL.

JPA notes so N+1 does not ruin the night.

Backend notes when you want Firebase, but SQL.

Auth, store, and functions without a server rack.

Topics, offsets, and notes for events that cannot drop.

Exchanges and workers for jobs that can wait a second.

Task notes so web requests do not do the heavy lifting.

Metrics notes when rows are really points in time.

Hypertables for metrics without leaving SQL.

Vitess notes for MySQL that ships like Git.

Branches and cold start notes for Postgres in the cloud.

Indexes for search that thinks in similarity, not strings.

Models and tests for analytics as code.

Deploy, ops, and automation tips without the buzzword fog.

Linux, macOS, and Windows tips to make the machine yours.

Images, compose, and container notes that make deploys boring.

YAML, pods, and k8s notes so deploys do not surprise you.

Services and IAM notes for cloud you can still explain.

Identity, apps, and resource notes that keep bills in check.

Projects, IAM, and service notes that stay readable.

State and module notes so apply is not a surprise.

Playbooks for servers you do not want to SSH one by one.

Charts for Kubernetes that you can version.

Cloud resources in real languages, not only HCL.

Workflows that build, test, and deploy from the repo.

Repos, CI, and review notes in one product.

Groovy and plugin notes for CI that predates Actions.

PromQL notes so alerts mean something.

Dashboards for when logs are not enough.

APM and monitor notes for teams that buy the suite.

Stack traces and release notes before users mail you.

Config notes for TLS, gzip, and not melting origin.

httpd notes for the server a lot of hosts never left.

DNS, workers, and cache notes that make the internet snappier.

Front end ship notes with a URL for every branch.

Forms, functions, and static notes that stay simple.

Dynos and add-ons for when you want PaaS, not YAML.

Droplets and spaces for cloud without a 400 page IAM doc.

Machines at the edge for apps that should feel local.

Cold starts, IAM, and function notes in AWS.

Pipelines that catch bugs without blocking every merge.

Distro, kernel, and sysadmin notes for boxes you actually own.

Apt and systemd notes for servers that run Ubuntu.

Packaging notes for the distro a lot of others fork.

Homebrew, defaults, and Unix notes on Apple hardware.

WSL, terminals, and notes for a non-Unix box.

Keys, tunnels, and session notes that are not a security hole.

PRs, actions, and repo notes for where the code lives.

Declarative OS notes for people who Nix all the way down.

Sync notes so Kubernetes matches the repo.

HashiCorp notes when Kubernetes is more than you need.

Catalog and mesh notes for apps that have to discover each other.

Lease and policy notes so passwords are not in git.

Boxes that match prod a little closer than "it works here".

Units and journals for Linux that actually boots your app.

Reverse proxy notes that do not need a 40 line nginx file.

Practical notes for models in products, not slide decks.

Features, evals, and ML notes that survive contact with data.

Nets, GPUs, and training notes that do not OOM on step 2.

Prompts, context, and model notes for apps that talk.

Chunks, embeddings, and notes so the model cites the right doc.

Tools, memory, and notes for bots that do work, not just chat.

Protocol notes for tools and context that IDEs can share.

Clear instructions for models that still need a nudge.

Everyday model notes for writing, code, and glue work.

Long context and coding notes for the other big chat.

Multimodal notes for the model in the Google stack.

Keys, models, and product notes beyond the chat box.

Glue notes for LLM apps when a raw call is not enough.

Hubs, transformers, and notes for weights you can actually pull.

Autograd and module notes for models you train yourself.

Graphs, Keras, and notes for TF in the wild.

Friendly deep learning notes on top of the hard bits.

Classic ML notes before you reach for a giant net.

Data frame notes for the messy CSV in the middle.

Array notes so you stop writing Python for loops on numbers.

Kernel and cell notes for work you can still rerun.

Run LLMs on your machine without sending the repo out.

Agent and inline notes for coding with a model in the loop.

Ghost text notes that help without merging junk.

Images, boxes, and model notes beyond a hello world classifier.

Tokens, parsers, and language notes from before and after LLMs.

Analysis notes from question to chart to caveat.

Vector notes for search, recs, and RAG.

Quantization and runtime notes for models at home.

Shipping with models without skipping the brain.

Fast Python installs and locks that actually lock.

Attention notes for models that read sequences.

Terminal agent notes for when the model runs the commands.

Practical notes so tests help, not just exist.

Tiny cycles for code you can change later.

Mocks and snapshots that do not rot overnight.

Vite-native tests for JS that should not wait on Jest.

Browser tests that wait for the page, not sleep(5).

E2E notes for teams still on Cypress.

WebDriver notes for the automation a lot of orgs still run.

Python test notes that stay readable.

Ruby test notes for Rails people.

Java test notes that CI already knows how to run.

Component notes you can click without the whole app.

One liners and shell tricks that make the prompt feel like home.

Small git tricks that keep history clean and your team sane.

Shortcuts and tweaks so you spend less time fighting the editor.

Editors, CLIs, and gadgets that keep a hacker moving.

Bundling notes for configs you still have to live with.

Settings, extensions, and editor notes for the default IDE.

Lua config notes for a modal editor that plugins well.

Lisp and buffer notes for the other lifetime editor.

JetBrains notes for Java, Kotlin, and friends.

Modal editing notes that ship batteries.

Package notes for the JS registry we all use.

Fast installs when node_modules got out of hand.

JS package notes for repos that never left Yarn.

Dev server and build notes after Webpack fatigue.

Go-speed JS tooling when you want less config.

Runtime, installs, and tests in one fast binary.

TS runtime notes with permissions and fewer node_modules.

Rules that catch bugs, not style wars.

Format on save and stop arguing about semicolons.

Preset notes for JS that still needs a time machine.

Task graphs so packages do not rebuild forever.

Monorepo notes with generators and affected builds.

One tool when ESLint plus Prettier feels heavy.

Cross platform notes for C and C++ projects.

Targets and recipes for the build tool that never died.

Design notes so clients do not break every week.

Resources and verbs for APIs that look like the web.

Protobuf notes for calls that need to be tight.

Service notes for when a monolith actually hurts.

Timeouts, retries, and notes for more than one box.

Messages and handlers for work that should not wait in-request.

Tradeoffs you can draw on a whiteboard, then ship.

Structure notes so the next person can still find the code.

Big O notes you can use on a real list of data.

Trees, maps, and notes for picking the right shape.

Objects and messages without a 12 layer hierarchy.

Immutability and composition without a purity lecture.

Catalog notes for when a pattern actually helps.

Names, size, and notes for code you can change next month.

Speed notes that start with a profile, not a guess.

Auth, input, and notes that are not an afterthought.

Threat notes for people who keep systems unowned.

Data notes for products that do not need every field.

a11y notes for keyboards, screens, and contrast.

Markup and performance notes search engines still like.

Sessions, tokens, and notes that do not store passwords in git.

Flows and scopes for "sign in with" without a footgun.

Token notes so you do not treat a blob as a session store.

Compile notes for code that JS should not have to do.

Service workers and install notes for web apps that feel installed.

Static and CDN notes for sites that barely need a server.

Function notes for ops you do not want to babysit.

Logs, traces, and metrics you can actually query.

Error budgets and toil notes from the ops side of engineering.

Issues, licenses, and notes for projects other people use.

Interviews, leveling, and notes from the path after hello world.

Setup and habit notes that are not hustle cosplay.

Breakpoints, logs, and notes for when it only fails on Friday.

Comments that improve the code, not the author's week.

README and comment notes for the next person, including you.

Parse, type, and emit notes for language nerds.

Desk setups, gear, and workspace notes from people who ship.

TCP, DNS, and notes for when the app is fine and the path is not.

Status, cache, and protocol notes for the web you already use.

Push notes for when polling is a bad joke.

Ledgers and consensus notes for when you actually need one.

Gas, contracts, and chain notes from building on Ethereum.

Wallets and dapp notes for the decentralized corner of the web.

CRDTs and file notes for apps that work in airplane mode.

Golden paths so every team is not reinventing deploy.

Repo as source of truth for clusters and config.

Firmware and fleet notes for computers that are not laptops.

Bare metal and RTOS notes for code with no room to waste.

Loops, assets, and notes for games that people can play.

C# and scene notes for 3D and 2D that still default to Unity.

Engine notes for games that want the heavy renderer.

Nodes and GDScript notes for games you can own.

GPIO and Linux notes for computers that cost lunch money.

Sketches for hardware that should just work.

Write notes for READMEs, docs, and tips.

Shape and schema notes for the format everything speaks.

Patterns that pull text out without summoning demons.

Devtools and engine notes for Chrome, Firefox, and friends.

Package notes for many apps in one git root.

APIs, data, and notes for the part users never see.

Notes for people who ship UI and the server too.

Layout and component notes that are more than pretty.

Flows and copy notes for software people do not have to fight.