OS is Life

Subscribe

Apple

Google

Spotify

Overcast

Stitcher

RSS

-->

About<br>Home

Life is pretty similar to an Operating System (OS) in many ways. :)<br>One of the most interesting parallels we can see is in lifetime management, which closely resembles OS process scheduling. Just as an OS uses different algorithms to manage processes between the CPU, disk, GPU, and other resources, we need frameworks to manage our daily tasks.<br>As you grow up, your responsibilities inevitably increase. That’s usually when burnout creeps in and things get frustrating. At this point, life leaves us with two choices: either ignore some of those responsibilities, or start planning. With good time management, you can extract the best out of your life.<br>This blog post is really just me thinking out loud. For the sake of simplicity, I’m treating the human brain as a single-core CPU. I personally don’t believe in human multitasking. Therefore, considering one CPU is the most realistic choice for now.<br>Introduction<br>Now that we have established this mindset, let's talk about how this post is structured. To make this OS-to-life metaphor work, I will break things down into two main parts.<br>First, we will do a quick (and definitely not too academic!) review of some classic CPU scheduling algorithms. We will look at how these computational concepts map directly to our daily routines and chore management.<br>Then, after setting the ground rules and understanding the tools at our disposal, I will introduce my own hypothesis: a custom, integrated framework that draws on the best of these algorithms to manage the chaos of everyday life. Let's dive in.<br>Preemptive vs. Non-Preemptive<br>Figure 1: OS CPU scheduling algorithms.As you can see in Figure 1, we can divide CPU scheduling algorithms into two main groups: Preemptive and Non-Preemptive.<br>Preemptive: If a new task meets the algorithm's conditions, it will interrupt the CPU, pausing the currently running process to take its place. (Think of this as dropping everything to handle an urgent phone call).<br>Non-Preemptive: We wait for the current task to complete before evaluating the queue and selecting the next best candidate.<br>The Classic Scheduling Algorithms<br>I will not go through all the algorithms individually (it’s not an OS course pal, lol). I will just explain a few key ones that I used to build my hypothesis.<br>Shortest Job First (SJF): In OS: The processor selects the waiting process with the smallest execution time.<br>In Life: Knocking out the quick, 2-minute chores first (like replying to an email or taking out the trash) to clear your queue and build momentum.

Highest Response Ratio Next (HRRN): In OS: Prioritizes processes based on how long they've been waiting and their estimated run time, preventing longer jobs from starving.<br>In Life: Finally tackling that big, annoying project you’ve been procrastinating on because the "waiting anxiety" has grown too large to ignore.

Round Robin (RR): In OS: Each process is assigned a fixed time slice (quantum). Once the time is up, the process is paused and sent to the back of the queue.<br>In Life: Time-blocking! For example, spending exactly 45 minutes on coding, then 45 minutes on studying, making incremental progress on everything without getting completely stuck on one bug.

Multilevel Feedback Queue (MLFQ): In OS: Processes dynamically move between different priority queues based on their behavior (e.g., taking too much CPU time drops them to a lower priority queue).<br>In Life: The ultimate dynamic management system. You categorize tasks by priority, but if a "high-priority" task is draining your energy and taking too long, you demote it to a background task for later so it doesn't crash your whole day.

My Hypothesis: The MLFQ (Multi-Level Feedback Queue)<br>Now, let's bring it all together. My algorithm is basically based on the classic MLFQ, but with some slight modifications. I kept the acronym but gave it some constructive new words: Multi-Level Fucked-up Queue .<br>Figure 2: My own algorithm (picture generated with Gemini)In a standard OS, a Multilevel Feedback Queue (MLFQ) typically punishes heavy, CPU-bound processes by pushing them down to lower-priority queues. For my life-management framework, I’m doing the exact opposite . I’ve designed my custom MLFQ consisting of 5 to 6 dynamic queues (the number can vary depending on your flavor of chaos). Next to each queue, I’ve assigned a "Time Budget" per day.<br>Here is the breakdown of my custom operating system for life:<br>1. Life Emergencies (LE) Queue<br>Algorithm: First-Come, First-Served (FCFS)<br>Time Budget: $\infty$ (Infinite)<br>The Logic: This queue is strictly non-preemptive . You cannot interrupt it, and you cannot ignore it. Imagine you get sick, or a sudden crisis hits. In that exact moment, you have zero other priorities. The CPU drops everything else. It doesn’t have a time slice because it takes as long as it takes. You simply have to handle it.<br>2. Life Main Focus (LMF) Queue<br>Algorithm: Round Robin...