SecurityLab track — runtime and distributed systems, kernel debugging, eBPF, Go concurrency, memory models, bootloaders, and assembly walkthroughs. Code-first, source-cited, mechanism-deep.
Long-form writing and video on runtime, distributed systems, and kernel internals — the layers below the application where most production reliability is actually decided.
Topics: Go runtime and concurrency, distributed systems patterns (RPC, queues, idempotency), kernel debugging with GDB/QEMU, eBPF, memory models, bootloaders, and assembly walkthroughs.
Companion to the HarrisonSecurityLab YouTube channel. Blog and video are listed below — most recent first.
context.Context is not documentation, not a metadata bag, and not optional. A production-hardened guide to cancellation propagation, the background-goroutine trap, and the patterns that keep services alive when downstreams slow down.
After a few years writing production Go, I stopped thinking of chan as a data pipe and context as a parameter. They're both lifecycle primitives — chan draws the boundary of 'how many alive', context draws the boundary of 'when to die'. Here's why that mental model changes the code you write.
After Four Pillars of Concurrency, the natural question: what does a system actually look like when it uses all of them deliberately? IronSys is a composite blueprint — the concurrency architecture I'd build today if I were starting over, with the trade-offs each choice buys.
Most engineers still reach for the mutex. That's one of four options, and usually not the best one. A working engineer's map of shared-state, CSP, actors, and STM — and when each is the right tool.
Go isn't magic and it isn't faster than Java. It just stops asking the kernel to help. A first-principles look at goroutines, 2KB stacks, and why high-frequency trading engines chase the exact same answer.
The journey from 16-bit real mode into 32-bit protected mode. Hand-built Global Descriptor Table and Interrupt Descriptor Table — the foundation every modern OS rests on.
End-to-end workflow for embedded Linux: customizing, building, and debugging an ARM64 Linux kernel with Yocto, then booting under QEMU and attaching GDB.
Project overview of SentinelEdge — a professional-grade eBPF kernel security framework showcasing modern Linux kernel programming, deep system tracing, and production-style observability.
Compares Rust and C at the assembly level, focusing on ownership/memory management, immutability, and bounds checks. Real-world debug and analysis on disassembled output.
Technical deep-dive comparing kprobe and fentry eBPF program attachment in the Linux kernel: how each probe loads, where the hook lands in machine code, and what overhead each carries.
© 2026 HarrisonSec. All rights reserved.