Systems Programming from the Ground Up

Welcome to my independent systems-programming lab.

This website explores how computers operate beneath application-level software, with a particular focus on Linux, ARM architecture, embedded systems, operating-system internals and low-level programming.

Many technical resources explain how to use an API or configure a system. Here, the objective is to go one level deeper:

  • What actually happens inside the Linux kernel?

  • In which execution context does a callback run?

  • Why can some kernel operations sleep while others cannot?

  • How does an ARM processor translate a virtual address?

  • What is required to boot a minimal Linux system?

  • How much of a general-purpose Linux kernel can be removed while preserving a useful embedded platform?

  • How can operating-system concepts be demonstrated on real hardware rather than studied only in theory?

The articles on this site will use practical experiments, source-code walkthroughs, build instructions, execution traces and hardware observations to investigate these questions.

Major Areas

Linux Kernel Internals

Practical exploration of Linux kernel mechanisms, execution contexts, deferred work, synchronization, memory management and driver interfaces.

Raspberry Pi 4 Kernel Lab

Hands-on Linux kernel experiments performed on Raspberry Pi 4 hardware, using independently developed code, UART output and minimal userspace tools.

Linux Kernel Trimming

A systematic study of reducing a general-purpose Linux kernel while retaining a deliberately selected set of embedded-system capabilities.

Tiny Linux from Scratch

An exploration of kernel boot, initramfs construction, minimal userspace, direct system calls, process management, filesystems and networking.

ARM Architecture

Practical explanations of ARMv8-A concepts including exception levels, exceptions, interrupts, virtual memory, translation tables, ASIDs, memory attributes, caches and virtualization extensions.

C and C++ Systems Programming

Articles about memory representation, pointers, object lifetime, compilation, linking, concurrency, atomics and interaction with hardware and operating systems.

Bare-Metal Software and Virtualization

Future experiments involving processor initialization, exception handling, memory management, device access and introductory hypervisor concepts.

How the Tutorials Will Work

The tutorials will be organized as progressive laboratory series rather than as disconnected code fragments.

A typical article will contain:

  • The problem being investigated

  • The underlying operating-system or architectural concept

  • A focused implementation

  • Build and deployment instructions

  • Expected output

  • Hardware or emulator observations

  • Common mistakes and debugging notes

  • Conclusions drawn from the experiment

  • Links to related public source code

The objective is to understand not only how to make something work, but also why it works and what happens inside the system when it runs.

Current Status

The website is currently being established.

The first planned detailed tutorial series will cover Linux kernel mechanisms on the Raspberry Pi 4. Additional series on kernel trimming, Tiny Linux, ARM architecture and systems programming will follow.

A Personal Engineering Notebook

Systems software is best understood by building, breaking, inspecting and rebuilding it.

The articles will therefore include lessons learned from compilation failures, incorrect assumptions, runtime observations and design changes, rather than showing only polished final results.

Welcome to the lab.