How I Made My Crush by Writing a Linux Device Driver at Office 💻❤️

A cold morning, coding a Linux device driver, and an unexpected office crush that turned a regular day into something special.

Linux Device Driver

It was a very cold day. The kind of cold that makes your fingers stiff even when you’re holding a warm coffee mug. The office was unusually quiet, except for the soft hum of computers and the occasional creak of chairs as someone moved in the distance. Outside, the wind rattled the windows, and the early morning sunlight struggled to pierce through the gray clouds. I wrapped my scarf tighter around my neck, sipping my coffee slowly, trying to keep warm, and stared at my screen. My task for the day? Writing a Linux device driver — a challenge I had done many times, yet today it felt… different.

I thought it would be just another boring day of coding, filled with debugging and endless lines of C code. But sometimes, life likes to surprise you in ways you never expect.

I had just started setting up my development environment when I sensed a presence near my desk. At first, I ignored it, thinking it was someone passing by. But the feeling lingered, a mix of curiosity and warmth that I couldn’t explain. Then I heard it — a soft, almost hesitant voice:

“Hey… what are you working on?”

I looked up and froze. There she was — her hair catching the weak morning light, her eyes wide and sparkling with curiosity. My heart skipped a beat. My mind, which had been buried in kernel logs and device registers, suddenly went blank.

“A… a Linux device driver,” I managed to say, my voice steadier than I felt inside.

Her eyebrows raised in surprise, and a small smile tugged at the corner of her lips. “Wow… that sounds… complicated. Can you show me?”

And just like that, everything changed. My terminal, my code, the monotonous hum of the office — all of it faded into the background. The world had narrowed down to two people, a laptop, and the tiny, thrilling connection forming between us.

As I began to explain, I realized that writing a Linux device driver had never felt this alive. Each line of code I typed was no longer just instructions for the machine — it was a message, a story I was sharing with her without even realizing it. “So, a device driver,” I said slowly, pointing to the screen, “is like a translator. It lets the computer talk to the hardware. Without it, the device can’t work. It’s… kind of like letting two worlds meet.”

She leaned closer, her eyes locked on the screen, but I could see her glancing at me every now and then. Her attention, her curiosity, it was intoxicating. I could feel a strange thrill, like a bug in my heart code had been triggered — a mixture of excitement, fear, and something dangerously close to… hope.

Minutes passed like hours. My fingers typed, my mind raced, and my heart hammered in my chest. I tried to focus on the code, but her presence was magnetic. Every glance, every word, every subtle smile pulled me in, faster than any interrupt handler could ever trigger.

And then it happened. She laughed — a soft, melodic sound that made my chest tighten. “You really love what you’re doing, don’t you?” she asked.

I nodded, unable to speak. How could I explain that my love for Linux device drivers had just been overtaken by… her? By this electric, unexpected, thrilling feeling that had nothing to do with code?

That cold morning, the Linux driver wasn’t the only thing I was building. A connection, fragile yet undeniable, was forming. Every heartbeat, every shared glance, every hesitant word felt like the first step in a story I didn’t want to end.

Because sometimes, life surprises you not with a bug fix, not with a successful compile — but with a glance, a smile, and the promise that something extraordinary is about to begin.

Step 1: Setting Up the Workspace

She was standing beside my desk, a little hesitant, her eyes curious as they followed every move on my screen. I glanced up and smiled. “Hey, why don’t you sit? It’ll be more comfortable,” I said, gesturing to the chair next to me.

She smiled back, her cheeks lightly flushed, and took a seat right beside me. From that moment, the office — usually cold and quiet — felt warmer. Her presence made everything feel… different.

I focused on the task ahead: writing a Linux device driver from scratch. First, I had to set up the workspace — create a folder for the driver, a main C file, and a Makefile.

I typed slowly, almost as if each keystroke mattered more than usual.

mkdir simple_driver
cd simple_driver
touch simple_driver.c
touch Makefile

As I worked, I kept glancing at her, noticing how her eyes followed every line I typed. I started explaining quietly, almost like telling a story rather than teaching:

“This is our project folder. The C file is where the driver will live, and the Makefile tells the system how to build it.”

I looked at her and smiled, trying to keep it simple. “Okay, so first, we need a folder to keep all our driver files organized,” I said, typing:

mkdir simple_driver

“That just makes a new folder called simple_driver,” I explained. “Think of it like a little box where all our work will live.”

Next, I moved into that folder:

cd simple_driver

“This just tells the computer, ‘Hey, we’re going to work inside this folder now,’” I said, pointing at the terminal. She nodded, leaning slightly closer to see better.

Then I created the main C file for the driver:

touch simple_driver.c

“This file is where all the code for our driver will go,” I said. “It starts empty, but we’ll fill it step by step.”

Finally, I made the Makefile:

touch Makefile

“And this file,” I added, smiling at her, “is what the system uses to build our driver. It’s like giving the computer instructions on how to turn our code into something it can actually use.”

She tilted her head, a little curious smile on her face. “So all these little files… are like pieces of a puzzle?” she asked.

I nodded. “Exactly. And when we put them together, they make the driver work perfectly. Every step matters.”

Step 2: Writing the Basic Driver Skeleton

Now came the real coding part. I opened simple_driver.c and began with the basic Linux module skeleton.

#include <linux/init.h>
#include <linux/module.h>
#include <linux/kernel.h>

MODULE_LICENSE("GPL");
MODULE_AUTHOR("Me");
MODULE_DESCRIPTION("A Simple Linux Device Driver");
MODULE_VERSION("1.0");

static int __init simple_driver_init(void) {
    printk(KERN_INFO "Simple Driver: Initialized\n");
    return 0;
}
static void __exit simple_driver_exit(void) {
    printk(KERN_INFO "Simple Driver: Exited\n");
}
module_init(simple_driver_init);
module_exit(simple_driver_exit);

I glanced to the side and saw her sitting right next to me, eyes quietly following every keystroke. Even though she didn’t say a word, her presence made each line of code feel alive, almost like the driver itself had a heartbeat.

watching me type, and somehow she smelled amazing — like fresh coffee mixed with the crisp morning air. My heart skipped a beat.

I started explaining the code to her in the simplest way I could. “These functions,” I said, pointing at the screen, “are kind of like the beginning and ending of a story. simple_driver_init runs when the driver starts, and simple_driver_exit runs when it’s removed.”

She leaned a little closer, curious and smiling. “Oh… so it’s like saying hello and goodbye?” she asked softly.

I nodded, smiling back. “Exactly. Just like little moments in life — start, end, and everything in between.”

Step 3: Writing the Makefile

Next was the Makefile, simple but essential.

obj-m += simple_driver.o
all:
    make -C /lib/modules/$(shell uname -r)/build M=$(PWD) modules
clean:
    make -C /lib/modules/$(shell uname -r)/build M=$(PWD) clean

I took a slow sip of my coffee, feeling the warmth spread through my hands. She was sitting right next to me, her eyes following every line I typed on the screen. I tried to explain the code gently, keeping it simple:

“The obj-m line tells the kernel what to build. The make -C command tells it where the kernel source is. And clean is for when we want to remove compiled files.”

Even these small, technical steps felt alive with her presence. Each command felt like a heartbeat, each line of code a quiet connection between us. She leaned a little closer, curious and smiling, and suddenly, writing a Linux device driver didn’t feel like just coding — it felt like a shared little adventure, a moment that was ours alone.

Step 4: Compiling the Driver

Finally, the moment of truth: compiling the driver.

make

I watched as the terminal blinked, lines of compilation messages scrolling by. No errors. Just a simple .ko module file waiting to be loaded. I whispered to myself:

“It works… just like I hoped.”

Step 5: Loading the Driver

Time to test it. I carefully typed:

sudo insmod simple_driver.ko
dmesg | tail

The kernel logs greeted me:

[INFO] Simple Driver: Initialized

I looked up and saw her leaning a little closer, curious. “So… it’s working?” she asked, smiling.

I nodded. “Yes! It works perfectly.”

She laughed softly, that little smile that made my heart skip a beat. “Wow… you make coding look fun,” she said.

I smiled back. “Maybe it is a little fun… with the right company.”

We looked at the screen together for a moment. The driver was working, yes — but the moment felt even more special. A little victory, a little connection, and a little spark that made the cold morning feel warm

Step 6: Removing the Driver

And to complete the cycle:

sudo rmmod simple_driver
dmesg | tail

[INFO] Simple Driver: Exited

I explained to her later: “Every module has a start and end, like moments in life. We make them count.”

Step 7: The Romance Behind the Code ❤️

As I worked through each step, I realized that writing a Linux device driver wasn’t just about code. It was about patience, focus, persistence — and, in my case, love. Every moment at the terminal reminded me of her laughter, her curiosity, and the thrill of sharing something I was passionate about.

By the end of the day, the driver worked perfectly. And more importantly, I knew that this little coding journey had quietly built a bridge between us.

Sometimes, the most unexpected things — like writing a Linux device driver on a cold morning — can lead to something extraordinary. A connection, a spark, a memory you’ll never forget

You can Explore more Linux Device Drivers here : https://lwn.net/Kernel/LDD3/