feeds - Daniel Cosenza's Blog

home | feeds |donate

Daniel Cosenza's Blog

Deep technical notes on operating systems, virtualization, and cloud-native infrastructure — kernels, filesystems, emulation, and the history behind the tools that keep systems running.

a recoverable launchbox setup: separate library backups from the full portable instance

across four xbox console generations: hardware, services, and compatibility

apache guacamole in production: proxy, authentication, and network boundaries

aqua image assurance and kubeenforcer: policy gates from registry to kubernetes

azure devops services operating map: boards, repos, pipelines, artifacts, and test plans

azure pipelines workload identity federation: secure service connections and migrate the issuer

batocera updates and recovery: protect userdata across system changes

cli vs. tui: terminal interfaces, automation, and interaction contracts

cachyos performance tuning: verify the kernel, packages, and workload

cemu mlc and save recovery: separate game paths, installed updates, and user data

choosing package managers across linux, windows, macos, and freebsd

choosing a linux filesystem: recovery, integrity, and workload tradeoffs

choosing a mac filesystem: apfs, mac os extended, and cross-platform media

choosing a rust gui stack for linux desktop applications

choosing a windows filesystem: ntfs, refs, fat32, and exfat by workload

cloudflare d1 migrations and time travel: safe schema changes and point-in-time recovery

cloudflare edge platform boundaries: dns, waf, access, workers, pages, and storage

cloudflare workers and pages: wrangler local development, staging, and safe rollouts

dosbox, dosbox staging, or dosbox-x? choose by compatibility evidence

dosbox-x profiles and midi: isolate game mounts, machine settings, and audio paths

debian, ubuntu, and rhel: compare release support before you upgrade

es-de gamelist migration: repair paths, media matching, and system definitions

fm towns and marty: fujitsu's multimedia computer family

from pong to the vcs and beyond: a source-led history of atari's console families

gnome and kde plasma: desktop integration, extensions, and configuration

github pages with custom actions: build artifacts, least privilege, and reliable releases

gitea actions runner security: isolate act runner jobs and scope their tokens

hashicorp vault database secrets: dynamic users, static-role rotation, and lease operations

hugo vs. zola: build and deployment contracts for static sites

hyprland operations: versioned configuration, monitors, and safe reloads

idira api integration architecture: service urls, bearer tokens, and least privilege

lakka storage and upgrades: preserve the writable state, replace the right image

linux desktop components: openbox, fluxbox, budgie, pantheon, and enlightenment

lutris vs. heroic: managing non-steam libraries, runners, and prefixes

nec's pc engine family: hucards, cd-rom, regional variants, and pc-fx

nintendo's console families: from the famicom to switch 2

notepad++ session recovery: what periodic backup saves and what it does not

omarchy configuration: keep personal overrides separate from managed defaults

qemu, kvm, and libvirt on linux: separate execution, devices, and vm ownership

retrobat feature precedence: control per-system and per-game emulator settings

snk's neogeo family: from multi-game arcades to home and handheld systems

sega's console lineage: sg-1000, genesis, saturn, and dreamcast

slackware package updates: match the branch, verify the transaction

steam on linux and proton: compatibility layers, runtimes, and evidence

sublime text projects and build systems: shareable configuration without shared state

the playstation family tree: five generations of sony consoles

trivy image and filesystem scanning: reproducible ci, triage, and evidence

vala and gobject: how high-level source targets the c abi

wiz security graph triage: turn cloud findings into verified remediation work

x11 and wayland: display protocols, compatibility, and trust boundaries

xdg base directories: a practical contract for linux user data

aks microsoft entra workload id: oidc federation without stored secrets

aws codedeploy ec2 blue/green: traffic cutover and rollback

aws eventbridge scheduler reliability: retries, time zones, and dlqs

aws lambda concurrency: capacity reservations, cold starts, and throttling

aws secrets manager rotation: idempotent stages and safe credential cutover

aws systems manager session manager: private access, iam, and session evidence

amazon eks access entries: authorization design and aws-auth migration

amazon eks pod identity: credential delivery, trust, and migration

amazon s3 object lock: immutable retention and recovery boundaries

ansible inventory in production: host selection, dynamic sources, and precedence

ansible playbooks in production: idempotency, check mode, and rolling changes

ansible vault lifecycle: password ids, rekeying, and runtime exposure

argo rollouts analysis gates: canary metrics, promotion, and abort

btrfs scrub: verify checksums and repair from redundant copies

btrfs send and receive: snapshot-based replication with verifiable baselines

cluster api machinedeployment rollouts: surge, availability, and node replacement

docker compose production readiness: health, dependencies, and safe updates

ec2 auto scaling instance refresh: safe ami and launch template rollouts

flux kustomizations: reconciliation order, health gates, and pruning

freebsd cpu temperature monitoring: use coretemp and amdtemp carefully

freebsd cups operations: build observable ipp print queues

freebsd kea dhcp server operations: pools, leases, and safe rollouts

freebsd nut operations: monitor ups state and test shutdown readiness

freebsd posix shared memory and named semaphores: lifecycle without races

freebsd pseudo-terminal operations: allocation, identity, and cleanup

freebsd sane scanner operations: trace detection, backends, and test scans

freebsd scsi tape operations: position, stream, verify, and retire media

freebsd ufs snapshot operations: create, mount, inspect, and retire safely

freebsd virtio operations: trace guest devices from hypervisor to driver

freebsd zfs pool checkpoints: create, monitor, rewind, and discard

freebsd bsdinstall scripted provisioning: reproducible installs with guardrails

freebsd bsnmpd monitoring operations: load mib modules and verify metrics

freebsd cd9660 operations: verify and mount optical media safely

freebsd efibootmgr operations: inspect and repair uefi boot entries safely

freebsd ext2fs interoperability: mount linux volumes without guesswork

freebsd resolvconf operations: reconcile dns from dhcp, vpns, and local sources

freebsd sesutil operations: map drive bays and verify enclosure signals

freebsd zfsd operations: understand automated zfs fault responses

freebsd zpool iostat: measure zfs vdev activity without misreading samples

gke workload identity federation: principal scoping and metadata paths

github actions cache security: keys, trust boundaries, and poisoning

github actions ephemeral runners: one-job isolation and runner groups

github actions matrix builds: control coverage, failures, and runner pressure

gitlab ci production pipelines: dag dependencies, artifact contracts, and deployment locks

gitlab ci to aws with oidc: scope trust, assume roles, and verify identity

gitlab ci/cd components: typed inputs, version pins, and safe reuse

gitlab protected environments: deployment access and approval boundaries

haiku atomic operations: value updates, ordering, and publication

haiku bbitmapstream: translation i/o, header rules, and bitmap ownership

haiku bblockcache: fixed-size reuse, fallback allocation, and ownership

haiku bchannelcontrol: multichannel values, limits, and invocation

haiku bcollator: locale-aware sorting, natural numbers, and search keys

haiku bcontrollable: parameter state, timed changes, and notifications

haiku bdateformat and btimeformat: localized display and time boundaries

haiku bdirectory mutations: create, open, and revalidate entries

haiku bfileinterface: file-backed media nodes and reference semantics

haiku bflattenable: type codes, buffer bounds, and stable wire formats

haiku bgradient: experimental color stops and compatibility boundaries

haiku blayoutbuilder: compose layout trees without losing ownership

haiku blayoutitem: custom measurement and constraint negotiation

haiku bmediadecoder: chunk input, codec selection, and decoded frames

haiku bmediaencoder: codec output, chunk writing, and container boundaries

haiku bmediafiles: registering and resolving named media resources

haiku bmedianode: registration, identity, and reference lifetime

haiku bmediarecorder: capture a media source with bounded callbacks

haiku bmediaroster: discovering nodes and building media graphs

haiku bmediatheme: parameter controls, view factories, and fallbacks

haiku bmidistore: sequence capture, event ordering, and midi file limits

haiku bmiditext: timestamped midi diagnostics without hiding latency

haiku bnodeinfo: per-file mime types, icons, and app hints

haiku bparameterweb: describing typed controls on media nodes

haiku bpath: lexical normalization, relative bases, and filesystem identity

haiku bpolygon: vertex geometry, mapping, and safe drawing

haiku brect: inclusive edges, validity, and pixel geometry

haiku bresourcestrings: read-only string resources and pointer lifetime

haiku bshelf: replicant admission, persistence, and recovery

haiku bstatable: node metadata, permissions, and freshness checks

haiku bstopwatch: measurement scope, laps, and benchmark limits

haiku bstringformat: localized message patterns and integer arguments

haiku btimecode: frame labels, drop-frame arithmetic, and clock boundaries

haiku kernel condition variables: experimental wait and notify semantics

haiku kernel ports: bounded message queues and ipc lifecycle

haiku kernel semaphores: counting, timeouts, and safe shutdown

haiku media producers and consumers: format negotiation and buffer ownership

haiku realtimealloc: pool sizing, contention, and callback boundaries

haiku thread-local storage: keys, initialization, and cleanup

haiku entry_ref: directory identity, stale names, and revalidation

jenkins pipeline reliability: controller load, agent work, and durability

kubernetes api encryption at rest: kms, rotation, and data rewrites

kubernetes pod security admission: audit, warn, enforce, and migrate

linux alsa pcm: ring buffers, periods, and xrun recovery

linux bridge vlan filtering: building and verifying layer-2 segmentation

linux cgroup v2 i/o control: weights, limits, latency, and verification

linux dm-integrity: journal, bitmap, and authenticated storage trade-offs

linux ftrace function-graph tracing: a bounded kernel call-path workflow

opentelemetry target allocator: prometheus scrape ownership at scale

opentelemetry k8sattributes: reliable kubernetes metadata enrichment

packer machine image pipelines: build, test, and promote immutable images

resizing ext4 safely: online growth, offline shrink, and layer order

terraform import blocks: adopt existing infrastructure through reviewed plans

bash namerefs: passing variables by name without eval

bash coproc: bidirectional pipes without building a named-pipe protocol

calling wsl from windows scripts: commands, working directories, streams, and exit codes

freebsd geom gate: exporting block devices without pretending they are files

freebsd netmap: memory-mapped packet i/o without a socket per packet

freebsd procctl: reapers, parent-death signals, and process hardening

freedos devload: loading dos device drivers after boot without guesswork

freedos share: file sharing modes and byte-range locks in real mode

freedos swsubst: mapping paths and drive letters through the cds table

haiku bresources: packaging typed data inside executables

haiku midi kit: roster-based endpoints, connections, and timestamped events

haiku's mime database: types, attributes, app signatures, and preferred handlers

how scummvm detects games, variants, and unknown releases

kubernetes api priority and fairness: protecting the control plane under load

kubernetes lease api: heartbeats, leader election, and failure boundaries

libretro's environment callback: how cores negotiate features with frontends

linux fanotify permission events: building access mediation that fails safely

linux openat2: constraining path resolution against symlink and mount escapes

linux's file-descriptor mount api: fsopen, fsmount, and move_mount

mame input recordings: deterministic playback, desyncs, and reproducible evidence

ntfs usn change journal: incremental file tracking without false guarantees

ntp: how david mills made distributed computers agree on time

prometheus native histograms: sparse buckets, mergeable resolution, and migration

repairing a wsl 2 ext4.vhdx without running e2fsck on a mounted filesystem

resizing a wsl 2 ext4.vhdx safely with wsl --manage

smappservice on macos: login items, launch agents, and user approval

shell exec: replacing a process without spawning another wrapper

the x window system: how mit project athena standardized a network-transparent gui

utf-8: the plan 9 design that made unicode fit existing systems

windows projfs: building a filesystem projection provider that hydrates on demand

windows restart manager: updating in-use files without rebooting the machine

macos disk arbitration: observing and approving mounts without racing finder

macos file coordination: nsfilecoordinator and nsfilepresenter without deadlocks

bash mapfile and readarray: loading lines without a fragile read loop

dolphin ubershaders: trading gpu work for stutter-free emulation

driverkit on macos: hardware drivers that run in user space

fdapm on freedos: power management, safe shutdown, and cache flushing

file provider on macos: domains, placeholders, and system-managed sync

freebsd rctl: resource limits for users, jails, and processes

freebsd procstat: process inspection beyond ps and fstat

haiku r1/beta6 ships after nearly two years of platform work

haiku's broster and registrar: how applications are found and launched

kubernetes validatingadmissionpolicy: cel policy without a webhook

lbacache on freedos: sector caching without gambling with writes

linux pidfds: race-free process handles beyond numeric pids

mame software lists: identifying, verifying, and loading preserved media

ncsa mosaic: the browser that made the early web visible

oci image indexes: how one container tag selects multiple platforms

the mother of all demos: 90 minutes that reframed interactive computing

wsl plugins: how windows applications start and talk to linux agents

wsl settings: a gui for the same configuration model as .wslconfig

windows dpapi: protecting secrets with user and machine context

windows laps: rotating local administrator passwords safely

zsh compinit security: auditing completion paths before startup

fs-verity on linux: per-file integrity with merkle trees

alpc on windows: the message transport behind local system services

ansi console drivers on freedos: escape sequences, nansi, and compatibility

apple's endpoint security framework: auth events, notify events, and safe client design

audio resampling in emulators: reconciling console clocks with modern sound hardware

bmessage flattening and ipc: how haiku moves typed data between processes

battery-backed save ram and real-time clocks: persistent state beyond save states

bracketed paste mode: how terminals and shells mark pasted text safely

btrfs copy-on-write and snapshots: what is shared, what changes, and what can fail

chd explained: lossless compression, parent images, metadata, and verification

cartridge mappers and bank switching: how consoles addressed games larger than memory

dpmi on freedos: how protected-mode programs coexist with real-mode dos

fat32 on freedos: cluster addressing, compatibility, and practical limits

fsevents on macos: persistent change journals, event coalescing, and rescan boundaries

fixing 'device busy' on a freebsd geom provider without forcing data loss

fixing 'the trust relationship between this workstation and the primary domain failed'

fixing dpmi and protected-mode memory errors on freedos

fixing emulator save files whose in-game clock drifts or resets

fixing freebsd zfs boot environments that consume unexpected pool space

fixing incorrect colors in an emulator without hiding the cause with a shader

fixing missing dos drive letters caused by lastdrive and driver ordering

fixing prometheus cardinality explosions before they exhaust memory and storage

fixing unexpected disk usage from time machine local snapshots on macos

fixing windows schannel tls failures with protocol, certificate, and event evidence

fixing a haiku uefi installation that boots only from the installer media

fixing a haiku launch_daemon job that repeatedly restarts or never becomes ready

fixing a kubernetes namespace stuck in terminating without hiding the root cause

fixing a terminal left without echo or line editing after a command crashes

fixing an intel mac app that crashes or refuses to open under rosetta 2

fixing an initramfs that cannot find the linux root filesystem

fixing inotify watch exhaustion without blindly raising kernel limits

freedos code pages and nls: how keyboard, console, and application text align

github actions oidc: short-lived cloud credentials without repository secrets

haiku node monitoring: receiving live file-system changes through the storage kit

haiku launch_daemon: jobs, services, ports, and dependency-based startup

haiku's network kit http client: requests, listeners, cookies, and tls boundaries

here-documents in shell: expansion, delimiters, tabs, and temporary data

high-level vs. low-level emulation: replacing behavior or reproducing firmware

how to apply microsoft security baselines without overwriting business requirements

how to automate freebsd device events safely with devd rules

how to back up and restore kubernetes etcd without creating a false recovery plan

how to build resizable haiku interfaces with blayout instead of fixed coordinates

how to build a haiku replicant that can live on the desktop or deskbar

how to build and verify a unified kernel image for uefi linux boot

how to centralize windows events with windows event forwarding

how to configure cutemouse on freedos without wasting conventional memory

how to configure ephemeral encrypted swap on freebsd

how to configure persistent linux networking with networkmanager and nmcli

how to create bfs attributes and indexes for fast haiku queries

how to create temporary files safely from a shell script

how to design a haiku translation kit add-on without corrupting input data

how to diagnose a macos system extension that will not activate

how to diagnose macos problems with log stream, predicates, and signposts

how to enable powershell script block, module, and transcription logging

how to image and verify a freedos disk before repairing it

how to inspect and deploy macos configuration profiles without treating them as scripts

how to order argo cd deployments with sync phases, waves, and hooks

how to pass secrets to systemd services with the credentials api

how to place freebsd tunables in sysctl.conf, loader.conf, or rc.conf correctly

how to preserve optical games with data, audio tracks, and subchannel evidence

how to replicate freebsd zfs datasets safely with send and receive

how to run parallel shell jobs and collect every exit status

how to test windows 3.1 on freedos without risking a working installation

how to verify game dumps against a dat without renaming away the evidence

how to verify signed container images with cosign and policy controller

intel 4004: how a calculator project produced a commercial microprocessor

january 1, 1983: what arpanet's tcp/ip flag day actually changed

java 1.0 ships: sun takes a portable virtual machine onto the early web

kubernetes qos classes: how requests and limits shape eviction and scheduling

kubernetes rbac impersonation: testing authorization without sharing credentials

kubernetes server-side apply: field ownership, conflicts, and managedfields

landlock on linux: unprivileged filesystem sandboxing with backward-compatible rulesets

linux kernel live patching: consistency models, transitions, and operational limits

linux pressure stall information: measuring cpu, memory, and i/o contention directly

netgraph on freebsd: building kernel networking graphs from reusable nodes

network extension on macos: vpns, content filters, dns proxies, and system boundaries

opentelemetry tail sampling: making trace decisions after the outcome is known

portable shell option parsing with getopts: state, errors, and reentrancy

public-key cryptography: from classified prehistory to diffie-hellman and rsa

refs on windows: integrity streams, scrubbing, block cloning, and deployment limits

rosetta 2 on apple silicon: translation, caching, and the boundaries of x86 compatibility

seccomp filters on linux: reducing the system-call surface without creating a sandbox myth

secure enclave keys on macos: keychain access control without exportable private material

shell file descriptors and redirection: ordering, duplication, and lifetime

sprite limits and scanlines: why accurate emulators preserve flicker and dropout

terminal line discipline and termios: canonical input, signals, echo, and raw mode

the berkeley raid paper: naming redundant disk arrays without inventing every technique

the dos packet driver api: one interrupt interface for many network cards

the freebsd mac framework: policy hooks beyond traditional unix permissions

the integrated circuit: how kilby and noyce solved different parts of the same problem

the risc research projects that changed commercial processor design

the transistor at bell labs: from point contact to a reproducible junction device

the windows object manager namespace: handles, named objects, and object directories

ufs soft updates and journaling on freebsd: what each mechanism protects

unix at bell labs: from a rejected timesharing project to a portable operating system

why printf is the portable shell output primitive and echo is not

why set -e is not exception handling: the real rules of shell errexit

windows file-system minifilters: filter manager, altitudes, and i/o interception

windows hello and passkeys: hardware-bound keys instead of reusable passwords

worldwideweb: the first web browser was also an editor

kqueue and kevent: freebsd's native scalable event notification interface

arpanet's first message: why 'lo' reached sri before the system crashed

aws app runner: from source or container image to a managed web service

aws fargate: serverless container compute for ecs and eks

aws step functions: reliable workflow orchestration without a custom coordinator

amazon ecr in production: iam, digests, scanning, lifecycle rules, and replication

amazon ecs architecture: tasks, services, capacity, and operational boundaries

amazon eks in production: control plane, compute, iam, networking, and upgrades

azure container apps: environments, revisions, keda scaling, and managed ingress

azure container registry: identity, oci artifacts, geo-replication, and governance

azure kubernetes service: managed control plane, node pools, identity, and networking

command substitution vs process substitution

container tags, digests, sboms, and provenance: building a verifiable release chain

diagnosing fat corruption on freedos without making recovery worse

dolphin introduces rvz as a lossless, emulation-ready disc format

environment variables, exports, and subshell boundaries

ethernet: from xerox parc's experimental network to ieee 802.3

fixing crlf line endings in shell scripts

fixing dos games that run too fast on modern hardware

fixing emulator netplay desyncs without guessing

fixing freedos keyboard layout and codepage mismatches

fixing himem and emm386 conflicts in a freedos memory configuration

fixing haiku applications that stop launching after a system update

fixing haikudepot and pkgman repository synchronization failures

fixing locale and encoding failures in shell tools

fixing missing or incorrect screen resolutions on haiku

fixing overscan and cropped edges without distorting the original image

fixing periodic emulator stutter caused by refresh-rate mismatch

fixing retroachievements that do not unlock or synchronize

fixing ssh agent forwarding without exposing more than necessary

fixing scripts that work interactively but fail under cron

fixing slow haiku package installs without interrupting the transaction

fixing a shell prompt that hangs inside git repositories

frame pacing and v-sync: why correct emulator timing is more than average fps

free software and open source: shared code, different historical arguments

freedos 1.4 publishes a floppy-only edition for original pc-class hardware

freedos adopts monthly test releases to replace release-candidate bottlenecks

freedos t2603 starts public testing of the new kernel and windows 3.x support

google artifact registry: repository modes, iam, cleanup, and deployment integration

google cloud run: services, jobs, revisions, and the container runtime contract

google container registry after shutdown: what gcr was and how migration works

google kubernetes engine: autopilot, standard, cluster architecture, and operations

haiku application scripting: bmessage suites and discoverable automation

haiku teams, threads, ports, and the kernel object model

haiku app_server: the desktop rendering service behind every native window

haiku on arm: porting challenges without pretending it is a finished product

haiku's jam build system: cross-tools, hybrid abis, packages, and images

haiku's locale kit: catalogs, formatting, and runtime language selection

haiku's scheduler: priorities, real-time work, and responsive multimedia

haiku's translation kit: roster-based media conversion between applications

helm architecture and release lifecycle: charts, values, hooks, rollbacks, and supply chain

how c became a standard language instead of one compiler's dialect

how crt light guns located the screen—and why they fail on flat panels

how gnu readline turns keystrokes into shell commands

how haiku's interface kit and app_server render native windows

how terminal multiplexers keep sessions alive

how to archive freedos files without losing names or metadata

how to bridge a freedos application to a modern print service

how to build auditable retroarch playlists and thumbnail sets

how to build a cross-shell dotfiles repository

how to build a reliable freedos serial link for retro hardware

how to build a reproducible fpga retro-gaming setup

how to build a reusable shell function library

how to build a safe freedos multi-configuration boot menu

how to catalog a physical game collection for preservation and insurance

how to configure ssh connection multiplexing

how to configure a low-latency display path for retro games

how to configure a multi-system arcade cabinet without one giant global profile

how to configure and test a non-us keymap on haiku

how to cross-compile haiku from a linux host

how to debug a native haiku application with debugger

how to evaluate a modern shell without breaking your workflow

how to keep a shell script shellcheck-clean from the start

how to package third-party software for haikuports

how to prepare and submit a haiku patch that maintainers can review

how to test a freedos monthly test release without risking your main installation

how to use freecom batch features beyond a linear startup script

how to use named pipes and process substitution safely

how to use retroachievements hardcore mode without invalid sessions

inside haiku's network stack: interfaces, protocol modules, and userland services

keda event-driven autoscaling: scaledobjects, scaledjobs, hpa, and safe scale-to-zero

karpenter node lifecycle: nodepools, nodeclaims, scheduling, consolidation, and disruption

kubernetes gateway api: separating infrastructure, routing, and application ownership

mame completes its move to gpl-compatible open-source licensing

microweb 2.1 brings xms and file downloads to a real-mode dos browser

nintendo ends new purchases on the wii u and nintendo 3ds eshops

nushell 0.114 keeps structured shell pipelines moving toward 1.0

opentelemetry collector pipelines: receivers, processors, exporters, and failure control

powershell became open source and cross-platform in 2016

preservation-grade game images: dumps, hashes, dats, and disc formats explained

recovering emulator save data after an interrupted or incompatible write

recovering haiku audio when media_server stops responding

recovering a freedos boot disk with a damaged mbr

retro sound chips: psg, fm, wavetable, and sample playback architectures

shell signal handling: trap, cleanup, and process groups

sony announces the final ps3 and ps vita store closure schedule

terraform state in production: backends, locking, drift, import, and recovery

tile-based rendering: how 2d consoles built scenes without a modern framebuffer

why dns replaced a centrally distributed hosts.txt file

eza continued exa's modern ls experiment

tmux 3.0 arrived in 2019