Niklas Weber

Problem: Understanding how a Unix shell works requires deep knowledge of operating system fundamentals. Most developers interact with shells as black boxes, unaware of the intricate machinery handling process spawning, signal management, and file descriptor manipulation beneath the surface. Building a shell from scratch meant confronting these abstraction layers directly—how does the OS actually execute commands? What happens when a child process terminates? How do pipes and redirections work at the kernel level?

Solution: I implemented a POSIX-compliant shell in C that replicates bash's core functionality. This wasn't a toy exercise; the shell handles the complete command execution pipeline: lexical analysis and parsing transform user input into an abstract syntax tree, and an execution engine processes these tokens using genuine Unix system calls. The implementation includes pipe management, input/output redirection, environment variable expansion, and comprehensive signal handling—everything necessary for a functional, production-aware shell.

Technical Approach: The project centers on three critical systems programming concepts. First, process management via fork and exec: each command spawns a child process using fork(), which then executes the target program with exec family calls. This separation of process creation and program execution is fundamental to Unix design. Second, file descriptor manipulation through dup2() redirects stdin/stdout/stderr, enabling pipes and file-based I/O redirection. Third, signal handling with sigaction() ensures the shell responds correctly to SIGCHLD when child processes terminate, preventing zombie processes. The parsing phase uses recursive descent techniques to build command structures, then the executor walks the tree and applies these low-level primitives. This project shares architectural rigor with the raytracer and ELO leaderboard, where systems-level understanding drives correctness.

Results & Learnings: The resulting shell executes complex commands with pipes, redirections, and background jobs reliably. Building minishell transformed my understanding of Unix architecture—I learned viscerally how shells are orchestrators of the OS, not autonomous entities. Signal handling taught me why race conditions in concurrent systems are insidious: a process could exit between checking its status and reaping it. This hands-on exploration of process management, file descriptors, and IPC deepened my appreciation for why low-level programming discipline matters. Every feature required reasoning about kernel behavior, not just abstract programming concepts—that alignment between code and hardware reality is what systems programming demands.