A comprehensive deep-dive into version control systems — from Git's internal model to advanced CLI tricks, branching workflows, GitHub power features, AI-assisted workflows, and running a self-hosted Git platform in your home lab with Gitea, Forgejo, and Woodpecker CI.
Software Development
-
Version Control Mastery: Git, GitHub, AI Agents, and the Home Lab Stack -
ASP.NET Core Web Development Primer Modern, cross-platform web development on .NET for engineers who already know another backend — the hosting model and Kestrel, choosing between Minimal APIs, MVC, and Razor Pages, the middleware pipeline, dependency injection as a first-class citizen, configuration and options, Entity Framework Core, authentication, and a look at Blazor — all on .NET 10.
-
Fortran Is Not Dead Fortran still runs the world's most important numerical simulations. A deep technical look at why the language endures, how modern Fortran 2008/2018/2023 differs from FORTRAN 77, the parallelism story, the compiler landscape in 2026, and the honest costs of working in the ecosystem.
-
Modern C in 2026 (C23) A deep technical look at C23 (ISO/IEC 9899:2024) — what it adds, what compilers actually implement in 2026, the undefined-behavior minefield, and why the sanitizer-plus-fuzzer stack is the highest-leverage practice in C development.
-
Modern C++ (C++20/23) A dense technical tour of C++20 and C++23 — concepts, ranges, coroutines, modules, std::expected, and an honest accounting of where the language excels and where Rust wins.
-
Server-Driven UI with htmx and Alpine.js The hypermedia approach that lets backend engineers build modern interactive apps without a SPA framework — htmx for swapping server-rendered HTML over the wire, Alpine.js for sprinkles of client state, when this beats React and when it does not, progressive enhancement, and wiring it into a Go, Python, or Rust backend. A pragmatic alternative to the JavaScript-framework treadmill.
-
The Browser as a Platform How the thing on the other end of your API actually works — the DOM and the rendering pipeline (parse, style, layout, paint, composite), the event loop and the microtask queue, what reflow and repaint actually cost, the Web Platform APIs worth knowing, and the security model (same-origin, CORS, CSP). The mental model that makes frontend performance and bugs make sense.
-
The Modern Frontend Build Pipeline What actually happens between your source files and the browser, for engineers who live in the backend — module systems (ESM vs CommonJS), why bundling exists, transpilation, the Rust-and-Go speed revolution behind esbuild, SWC, Oxc and Rolldown, tree-shaking and code-splitting, source maps, and the Vite dev-server loop. Demystifying the toolchain so the frontend stops feeling like magic.
-
Ghostty and WezTerm as IDEs: Leaving VS Code's Integrated Terminal Behind Why a growing number of developers make the terminal — Ghostty or WezTerm, plus a multiplexer and a modal editor — the host application instead of a pane inside VS Code, and how to assemble that workflow.
-
Ghostty Terminal: Mitchell Hashimoto's GPU-Accelerated Terminal A look at Ghostty, Mitchell Hashimoto's GPU-accelerated terminal — where it fits among Alacritty, Kitty, and WezTerm, what its native-UI and zero-config approach gets right, and whether it should be your daily driver.
-
Helix Editor: Modal Editing Without Vim's Legacy Helix is modal editing rebuilt without Vim's thirty years of baggage — selection-first editing, built-in LSP and tree-sitter, and sane defaults with no plugin manager. What it gets right, and where the lack of plugins still bites.
-
Tiling Window Managers in 2026: Hyprland, Aerospace, and the End of the Linux Ghetto Tiling window managers have left the Linux ghetto — Hyprland on Wayland and AeroSpace on macOS bring keyboard-driven tiling to the mainstream. What they do, how they differ, and how to actually adopt one in 2026.
-
Zellij vs tmux: The Modern Terminal Multiplexer Zellij versus tmux — how the modern Rust multiplexer rethinks the crusty parts of tmux with discoverable keybindings, built-in layouts, and floating panes, and where tmux's ubiquity and maturity still win.
-
Bend: Automatic Parallelism via Interaction Combinators Bend is a Python-like language that automatically parallelizes on CPU and GPU without threads or locks, powered by the HVM2 interaction combinator runtime. Here's what the novel ideas actually are, what works today, and what's still research-grade.
-
Elixir and the BEAM: Concurrency That Actually Scales A deep technical guide to Elixir and the BEAM VM — processes, OTP supervisors, GenServer, Phoenix LiveView, Ecto, distributed nodes, and an honest assessment of where the Erlang VM dominates and where it doesn't.
-
Gleam: Type Safety on the BEAM Gleam brings Hindley-Milner type inference and ML-family ergonomics to the Erlang VM — fault-tolerant concurrency, actor-model supervision trees, and zero-null error handling, with JavaScript as a second compile target. A deep technical look at the language, its ecosystem, and when to reach for it over Elixir.
-
Odin: Data-Oriented Systems Programming A deep dive into the Odin programming language — its context system, explicit allocators, data-oriented features, parametric polymorphism, and where it fits in the systems programming landscape alongside C, Zig, and Rust.
-
Roc: Functional Programming Without the Complexity Tax Roc is a fast, friendly, functional language built around a radical idea: no I/O primitives in the language itself. Instead, platforms provide effects, and your code stays pure. Here's a deep look at what that means in practice — the type system, tag unions, error handling, tooling, and where Roc is worth serious attention today.
-
The WASI Component Model: WebAssembly's Missing Piece A deep technical guide to the WebAssembly Component Model — WIT interface files, wasm-tools, composing polyglot components, the Fermyon Spin and wasmtime ecosystems, plugin systems, and an honest assessment of what is production-ready today.
-
Carbon: Google's Bet on a C++ Successor A deep technical look at Carbon, Google's experimental C++ successor language — what's real, what's aspirational, the C++ interoperability story, checked generics, memory safety roadmap, and an honest assessment of whether it has any chance of succeeding.
-
Crystal: Ruby Syntax, C Speed Crystal brings Ruby's expressive syntax to native binaries: static typing with full inference, fibers for concurrency, a powerful macro system, and LLVM-backed performance — an honest deep dive for engineers evaluating it for production work.
-
Haskell: Pure Functional Programming in Practice A deep technical guide to Haskell for experienced engineers — pure functions, the type system, monads demystified, lazy evaluation, real-world libraries, and an honest assessment of where Haskell wins and loses.
-
Lua: The Embeddable Language A technically deep guide to Lua for experienced engineers — covering syntax, metatables, coroutines, the C API, LuaJIT, Neovim plugins, OpenResty, Redis scripting, and game engines. Not a beginner tutorial.
-
Mojo: Python Syntax, Metal-Level Performance A deep technical guide to Mojo — Modular's MLIR-based language that combines Python syntax with C/Rust-level performance for AI and ML workloads. Covers the type system, SIMD intrinsics, memory ownership, metaprogramming, Python interop, and an honest assessment of where Mojo stands today.
-
Nim: Efficient, Expressive, and Underrated A deep technical guide to Nim — Python-like syntax that compiles to C, a metaprogramming system that outclasses nearly every language, deterministic memory management with ORC, and an honest assessment of where Nim genuinely wins and where it still struggles.
-
Perl: Still Powering the World's Sysadmin Scripts Modern Perl, CPAN, regex power, and where it still wins — an honest technical deep-dive for engineers who've heard 'Perl is dead' and want to know what's actually true.
-
V: Fast Compilation and Simple Systems Programming A technically honest deep-dive into V (Vlang) — fast compilation, autofree memory management, built-in ORM, and where this ambitious but controversial language actually delivers today.
-
Zig: The Modern C Replacement A deep technical guide to Zig for systems programmers — manual memory management without undefined behavior, comptime metaprogramming, cross-compilation to any target, and using Zig as a build system for existing C/C++ projects.
-
C# and .NET for Backend Engineers ASP.NET Core, minimal APIs, Entity Framework Core, Native AOT, and the performance story that makes .NET a serious choice for backend development in 2026.
-
Chicken Scheme: A Practical Guide for Systems Engineers A deep technical guide to Chicken Scheme 5 — the Cheney-on-the-MTA GC strategy, compiling to native binaries, the FFI, the egg ecosystem, IUP for cross-platform GUIs, and how Chicken fits into the broader Scheme landscape.
-
Go for Systems and Backend Development Language fundamentals, concurrency model, standard library, and practical patterns for writing CLI tools and services in Go. A guide for ops engineers and backend developers.
-
Java in 2026: Still Relevant Modern Java (17–25), records, sealed classes, virtual threads (Project Loom), GraalVM native images, and an honest assessment of where Java stands today.
-
Kotlin for JVM and Beyond Coroutines, null safety, data classes, Kotlin Multiplatform, and how Kotlin improves on Java for modern backend and cross-platform development.
-
PHP: The Comeback Kid PHP 8.x features including fibers, enums, property hooks, and named arguments. Laravel 11, Livewire, Reverb, and why modern PHP deserves a second look from developers who wrote it off.
-
Ruby: The Language That Still Ships Ruby 3.x performance with YJIT, Ractors, RBS type signatures, Rails 8's Solid Stack, Kamal deployment, and why the self-hosting renaissance suits Ruby perfectly.
-
Scala: Functional Programming on the JVM A deep technical guide to Scala 3 — case classes, pattern matching, the type system, Cats, ZIO, build tooling, and an honest assessment of when Scala is the right choice and when it isn't.
-
Swift on the Server: A Technical Deep Dive for Experienced Engineers A technically rigorous guide to Swift beyond iOS and macOS — covering Swift NIO, Vapor, Hummingbird, the Swift 6 concurrency model, embedded Swift, Lambda deployments, and an honest assessment of where server-side Swift wins and where it doesn't.
-
The Modern Terminal Stack: A Complete CLI Upgrade Guide From fish/zsh with plugins to starship, zoxide, fzf, ripgrep, bat, eza, and atuin — the definitive guide to building a fast, ergonomic, and beautiful terminal setup in 2026.
-
TypeScript Deep Dive Type system, generics, decorators, tsconfig deep dive, and why TypeScript has replaced plain JavaScript for serious projects. Patterns for experienced developers.
-
Writing CLI Tools with Great UX: The Complete Guide Shell completion, structured output, config file conventions, cross-platform distribution with GoReleaser and cargo-dist, progress bars and logging — everything you need to write CLI tools people actually enjoy using.
-
Buf: The Modern Protobuf Toolchain Replace protoc with Buf for schema linting, breaking change detection, remote code generation, and a registry for your Protobuf APIs.
-
API Rate Limiting Patterns: Algorithms, Redis Implementations, and Client Communication A deep dive into rate limiting algorithms — token bucket, sliding window log, sliding window counter, fixed window, and leaky bucket — with production Redis implementations, distributed rate limiting, and how to communicate limits to clients.
-
Mise: The Universal Version Manager That Replaces Everything How mise replaces nvm, pyenv, rbenv, sdkman, and tfenv with a single tool — managing runtimes, environment variables, and tasks across every project with a unified .mise.toml config.
-
Taskfile: A Better Makefile for Modern Development Why Taskfile is replacing Makefiles for developer experience: defining tasks with dependencies, variable interpolation, cross-platform support, and seamless CI integration.
-
Writing a CLI Tool in Go: From Zero to Distributable Binary A complete walkthrough of building a production-quality CLI tool in Go using Cobra and Viper — covering commands, flags, config files, environment variables, graceful shutdown, testing, cross-compilation, and distributing binaries with GoReleaser.
-
GitHub Actions Advanced Patterns: Reusable Workflows, Composite Actions, Matrix Builds, and Self-Hosted Runners Move beyond basic GitHub Actions pipelines. This guide covers reusable workflows, composite actions, matrix strategies, self-hosted runners with autoscaling, advanced caching, security hardening, and patterns for managing CI across a large monorepo or multi-repo organization.
-
Go for DevOps Engineers A practical Go guide for DevOps engineers — concurrency patterns, building CLI tools with Cobra, writing HTTP servers and clients, working with the Kubernetes API, and packaging Go binaries for deployment.
-
Nix and NixOS for Developers: Reproducible Environments, Flakes, and devShells A practical guide to Nix — the purely functional package manager that makes development environments reproducible, declarative, and composable. Covers nix-shell, flakes, devShells, home-manager, and NixOS for those ready to go all in.
-
Pre-commit Hooks and Code Quality Gates: Enforcing Standards Before They Become Problems A comprehensive guide to the pre-commit framework — configuring hooks for every language, writing custom hooks, integrating with CI, and building a code quality strategy that catches issues before they reach a pull request.
-
Python Packaging and Distribution: pyproject.toml, uv, Wheels, PyPI, and Vendoring A modern guide to Python packaging — pyproject.toml as the single config file, uv for blazing-fast dependency management, building and publishing wheels to PyPI, and vendoring dependencies for reproducible deployments.
-
Rust for Systems Programming: Ownership, Safety, and Where It Beats C/C++ A practical guide to Rust for systems programmers — the ownership and borrowing model, lifetimes, practical use cases, building a real CLI tool, and an honest look at where Rust outshines C and C++.
-
WebAssembly Beyond the Browser: WASI, Kubernetes Sidecars, Spin, and the Future of Serverless A practical guide to server-side WebAssembly — WASI and the component model, running Wasm workloads in Kubernetes with runtimes like wasmtime and spin, Fermyon's Spin framework for serverless functions, and why Wasm may reshape the edge and serverless landscape.
-
Dependency Management: Lock Files, Vulnerability Scanning, and Keeping Deps Fresh Without Pain A practical guide to managing project dependencies across ecosystems: lock files, semantic versioning, vulnerability scanning, automated updates, and the processes that keep dependency rot from killing your project.
-
Feature Flags: Safe Deployments, Dark Launches, and Rolling Rollouts Feature flags decouple code deployment from feature release, letting you ship dark, roll out progressively, and kill switches instantly — without a redeploy.
-
Local Development Environments: Dev Containers, Nix Flakes, and Reproducible Setups A comprehensive guide to eliminating 'works on my machine' problems using Dev Containers, Nix flakes, and mise — covering everything from simple devcontainer.json configs to full Nix-based reproducible environments, docker-compose service integration, CI parity, and real-world examples by stack.
-
OpenAPI and Swagger: Designing and Documenting APIs Contract-First Learn how to design and document APIs contract-first using the OpenAPI Specification — covering document structure, schemas, security, code generation, and the full tooling ecosystem from Swagger UI to Prism mock servers.
-
Profiling Applications: Finding Bottlenecks in Go, Python, and Node.js Stop guessing why your application is slow. This guide covers systematic profiling tools and techniques for Go (pprof), Python (cProfile, py-spy, line_profiler), and Node.js (clinic.js, V8 profiler) so you can find the actual bottleneck and fix it with confidence.
-
vim/neovim for DevOps: Your Terminal Editor, Supercharged A practical guide to vim and neovim for DevOps engineers — modal editing, essential motions, macros, plugins, and making it your daily driver.
-
Writing Good READMEs: Documentation That Developers Actually Read A practical guide to writing READMEs that developers actually read — covering structure, examples, anti-patterns, and templates for open-source and internal projects alike.
-
The Art of Code Review Code review is not a bug-catching net; machines are better at that. Its real payoff is shared understanding, design pressure, and a team that can safely change code none of them wrote alone. This is a guide to reviewing and being reviewed well: what humans should actually look for, how to write comments that land, why small pull requests are the highest-leverage habit, and how to keep review from becoming a bottleneck or a battleground.
-
Systematic Debugging Strategies Debugging is not guessing with extra steps. It is a discipline of forming hypotheses, designing experiments that can disprove them, and binary-searching the gap between a working state and a broken one. This is a working engineer's field guide to reproduction, bisection, observability-driven debugging, concurrency and heisenbugs, production debugging without a debugger, and turning every fixed bug into a test that keeps it dead.
-
Testing Strategies That Actually Work Tests do not prove your code is correct; they buy you the confidence to change it. This is a working strategy for spending a finite testing budget well: what the pyramid gets right and where the testing trophy disagrees, why testing behavior beats testing implementation, the real cost of mocks and flakiness, and why coverage is a useful gauge and a terrible target.
-
Refactoring Legacy Code Safely Legacy code is not old code; it is code you are afraid to change because it has no tests and no one remembers how it works. This is a practical method for taming it: pinning current behavior with characterization tests, finding seams to break dependencies, making changes in reversible small steps, and using the strangler-fig pattern to replace whole subsystems without a big-bang rewrite.
-
REST API Design Principles A well-designed API is intuitive to use and hard to misuse. The principles that hold up under real traffic: resource modeling, the idempotency contract behind HTTP methods, status codes that tell the truth, a real error format (RFC 9457), offset vs cursor pagination honestly, versioning strategies and why most are wrong, idempotency keys, and treating the spec as the contract.