All posts
PySide6 in Practice #5 Tray Residency and Reminders: An App That Survives Its Window
Implementing the residency that turns a habit tracker into a real tool: putting an icon and menu in the system tray with QSystemTrayIcon, converting window close into hide via closeEvent and the UX debate around it, sending daily reminders at a set hour with QTimer, the limits and platform differences of tray notifications, and single-instance handling that prevents two copies of the app.
GitHub Actions #8 Self-Hosted Runners: When to Adopt, Registration, and Security Principles
Three situations where hosted runners fall short — internal network access, cost, and special hardware — organized into adoption criteria, plus the registration procedure and routing jobs with labels. We cover why self-hosted runners must never be connected to public repositories, the ephemeral runner operating principle, and actions-runner-controller for auto-scaling runners on Kubernetes.
PySide6 in Practice #4 The Stats Screen: Painting a Contribution Heatmap with QPainter
Drawing the screen no stock widget provides: keeping statistics logic (completion rate, streaks) in the Qt-free core layer where it stays testable, painting a GitHub-style heatmap widget with paintEvent and QPainter, coordinate math and size handling with sizeHint, hit-testing the cell under the mouse for tooltips, and the custom-widget rule that repaints are requested through update().
GitHub Actions #7 AWS Deploys and OIDC: Credentials Without Access Keys
We look at the leak and rotation problems of storing access keys in secrets, then explain how a workflow assumes an AWS role with short-lived tokens through OIDC, walking the token exchange flow step by step. We cover the AWS-side trust configuration and sub claim restrictions, the configure-aws-credentials action and the id-token permission, and finish with an S3 static site deploy — closing out the credential problem in the deploy pipeline.
PySide6 in Practice #3 The Today Screen: A Custom Model and Check Toggling
Building the app's first real screen: why stuffing items directly into a list widget hits its limits fast in real apps, subclassing QAbstractListModel to connect the repository to the view, exposing multiple faces of data through roles, the path a check toggle travels from view through model to database, updating views precisely with the dataChanged signal, and the add-habit dialog.
GitHub Actions #6 Docker Build and GHCR Push: Tag Strategy and Build Cache
We assemble the standard pipeline that builds a container image and pushes it to GitHub Container Registry. From GHCR login with nothing but GITHUB_TOKEN, to how metadata-action decides tags automatically per event, to cutting build time with build-push-action and the gha cache — plus the practical baseline for branch, tag, and SHA tag strategies.
PySide6 in Practice #2 The SQLite Data Layer: Repository Pattern and Migrations
Building the app's memory: why SQLite is the default for desktop apps, finding the OS-specific app-data folder correctly, designing the habits and checks schema, the repository pattern that confines SQL to one place, and the tiny user_version-based migration scheme that keeps user data intact across app updates.
GitHub Actions #5 Reuse: Composite Actions and Reusable Workflows
Two ways to turn the step bundles repeated across workflows and repositories into components. We cover how to write action.yml for a composite action that packages a bundle of steps, reusable workflows that expose an entire job via workflow_call with inputs and secrets passing, the criteria for choosing between the two, and the pattern of standardizing on a shared repository at the organization level.
PySide6 in Practice #1 Project Design: App Architecture Through a Habit Tracker
First post of a hands-on series that takes a PySide6 beginner all the way to a finished app: what we build (a local habit tracker) and why this subject, breaking feature requirements into screens, splitting code into UI, core, and data layers and why, uv-based project setup, and the main-window skeleton that will carry the next seven parts.
GitHub Actions #4 Matrix, Cache, and Artifacts: Combination Runs and Saving Time and Money
We expand a single job definition into combinations of versions and operating systems with the matrix strategy, covering the include, exclude, and fail-fast options, then cut dependency install time with the key and restore-keys design of actions/cache and the built-in cache options of the setup actions. We finish with artifacts for passing files between jobs — upload, download, and retention settings — all through the lens of reducing run time and runner cost.
REST vs GraphQL vs tRPC: Choosing an API Style
The criteria for deciding what to build a new API with: the strengths of REST standing on resources and HTTP semantics and its overfetching problem, what GraphQL solves by letting clients declare the data they need and the costs it takes on in exchange, the appeal of tRPC wiring types end-to-end in a TypeScript monorepo and its clearly bounded applicability, and the decision axes of public exposure, client diversity, and team structure.
eBPF Explained: Extending the Kernel Without Recompiling It
A summary of eBPF, the technology underneath modern observability, networking, and security tools: the third road it opens between dangerous kernel modules and slow userspace, the safety model where a verifier rejects unbounded loops and invalid memory access, hook points like kprobes, tracepoints, and XDP, the tool ladder from bpftrace one-liners through bcc to libbpf, flagship uses like Cilium and Falco, and the practical constraints of kernel versions and privileges.