28 Dec 2025
#sysadmin#linux
This post breaks down the different Linux kernel variants—Mainline, LTS, Zen, Hardened, and WSL2—and explains why they are often misunderstood. Instead of treating them as interchangeable options, it shows how each kernel is designed for a specific environment and use case, and why choosing the right one depends on where and how Linux is actually running.
21 Dec 2025
#programming#rust#error-handling#unsafe-rust
This article explains what unsafe really means in Rust and why it exists.
unsafe does not turn safety off; it shifts responsibility from the compiler to the programmer. By looking at real code examples, we see how raw pointers work, what Undefined Behavior is, and why it is far more dangerous than a simple panic. Finally, the article shows how unsafe should be used correctly: kept small, controlled, and hidden behind safe abstractions, with clear invariants that make the rest of the code safe to use.
10 Dec 2025
#linux#programming
In this project I build a tiny 64-bit Linux system from scratch.
First, I use tinyconfig plus a few manual tweaks to build a minimal x86_64 kernel and boot it in QEMU until I hit the classic no working init found error.
Then I write a very small init in Rust + assembly (no std, no libc) that talks directly to the kernel via system calls and runs as PID 1.
Finally, I statically compile Lua, bundle it together with my init into an initramfs, and use the kernel’s own tooling to create a bootable ISO that can run Lua inside this tiny Linux world. The goal is not a daily-driver distro, but to build the smallest Linux system that I actually understand from the inside out.
04 Dec 2025
#privacy#data-ownership
In this post, we examine the growing divide between Microsoft’s increasingly restrictive Windows ecosystem and Valve’s open, user-focused approach with Linux and SteamOS. We explain how Windows is turning core tools into monetized, cloud-dependent products, while Valve invests in open technologies that give users freedom and control. We highlight how Linux is rising not just because it’s improving, but because the alternatives are becoming more limiting. Ultimately, the post frames the future of the desktop as a choice between control and freedom.
03 Dec 2025
#rust#programming#error-handling#tokio#async
A small async Rust project shows how to run multiple HTTP requests in parallel, apply timeouts, isolate panics, and clearly classify errors. The focus is not just speed, but building predictable, meaningful concurrency in real-world systems. True async isn’t about writing code — it’s about understanding how to give structure to simultaneous work.
29 Nov 2025
#fibonacci#rust#python#algorithm#recursion#programming
This post explores two different approaches to the Fibonacci problem — the naive recursive method and the optimized memoized version — to show how a simple sequence reveals deep lessons about complexity, structure, recursion, and algorithmic thinking. The naive version demonstrates exponential growth and wasted computation, while the memoized version shows how adding memory transforms recursion into a powerful and efficient tool. Ultimately, Fibonacci becomes a metaphor for the essence of programming: making the right choices.
19 Nov 2025
#terminal#permissions#linux#sysadmin
what the id command shows in Linux, how to view a user’s UID, GID, and groups, and which options are most useful. It also highlights where id helps in real situations—like fixing permission errors, checking user access on a server, or validating script execution.