OS is Life

Life is pretty similar to an Operating System (OS) in many ways. :)

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.

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.

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.

Introduction

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.

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.

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.

Preemptive vs. Non-Preemptive

As you can see in Figure 1, we can divide CPU scheduling algorithms into two main groups: Preemptive and Non-Preemptive.

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).
Non-Preemptive: We wait for the current task to complete before evaluating the queue and selecting the next best candidate.

The Classic Scheduling Algorithms

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.

Shortest Job First (SJF):
- In OS: The processor selects the waiting process with the smallest execution time.
- 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.
- 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.
- 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).
- 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)

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.

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.

Here is the breakdown of my custom operating system for life:

1. Life Emergencies (LE) Queue

Algorithm: First-Come, First-Served (FCFS)
Time Budget: $\infty$ (Infinite)
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.

2. Life Main Focus (LMF) Queue

Algorithm: Round Robin (RR)
Time Budget: ~10 Hours/Day
The Logic: This is where your biggest daily responsibilities live—your job, your heavy-lifting research, or running your business. Why Round Robin? Because you need structured time slices to make incremental, steady progress on these massive tasks without burning out your core processor.

3. Life Values [LV] Queue

Algorithm: Round Robin (with custom time quanta)
Time Budget: Configurable
The Logic: Notice the brackets [ ]? That’s because this is actually an array—a multi-queue within a queue. It holds the core pillars of who you are: family, self-development, or learning a new language. Each sub-queue gets its own specific time quantum via Round Robin, ensuring you don't neglect your family for personal growth, or vice versa.

4. Quick Wins / Micro-Tasks Queue (Formerly "Should-Do Things")

Algorithm: Shortest Job First (SJF)
Time Budget: Dynamic
The Logic: I live by a strict rule: If it takes less than 5 minutes, do it right away. This queue is for small tasks like taking out the trash or replying to a quick email. They might seem trivial, but running them through SJF gives you a fast burst of dopamine and a great sense of accomplishment that sets a positive tone for your entire day.

5. Wishlist / Procrastination Queue

Algorithm: Highest Response Ratio Next (HRRN)
Time Budget: $1/7$ (Once a week / "One Shot")
The Logic: We all have things we constantly postpone, or fun things we want to try but aren't urgent—like checking out that new restaurant down the street. I give this queue exactly one shot a week. Why HRRN? Because the longer a wish sits in this queue, its "waiting time" increases, boosting its priority ratio until it finally gets scheduled for your weekend!

The Feedback Loop: Debugging Your Life

An MLFQ is nothing without a feedback system, and here is how we optimize the runtime.

At the beginning of the week, you set your targets and allocate your time quanta. At the end of the week, you run a retrospective review. If you look at your logs and realize, "Oh, I completely missed my targets for this project... blah blah blah," it means there is a bug in your scheduling. Your time quantum was poorly calibrated.

Instead of panicking, you use this feedback to recalibrate. Over the next week, you can fine-tune the time slots, adjust the quantum, or completely reorder the priorities of your queues. You keep iterating and debugging until you find the perfect system configuration for your life.

Conclusion

Ultimately, I was trying to model life-task management using a professional MLFQ OS scheduling algorithm (and turning it into my very own Multi-Level Fucked-up Queue). However, I know real life is infinitely more complicated than this. It has countless unexpected parameters that we probably cannot model with any algorithm, even the most complex ones.

But I think this is just the result of my sick software-engineering brain needing to put everything in logical order. Or maybe I should just let the chaos of my life swallow me up. Chaos is fun, no?

GOF :]