let there be jitterbug - part 1

Thu, 28 May 2026 11:00:12 +0300

the why:

I am a software engineer, mainly working on the backend, and I’ve been accustomed to writing APIs and Developer CLI tools for a while. Don’t get me wrong, I love working in the backend mines, it’s fun, it’s engaging, I excel in this part of building scalable backends. But, it does get less engaging when all you do is build CRUD apps (just kidding, APIs are not just CRUD apps, a lot goes into building scalable APIs and backend systems) for the better part of your day.

I write a lot of Go, and I wanted to dig a little bit deeper into what CLIs can actually do, beyond just wrapping external APIs. That’s how I stumbled into interacting with the Linux Kernel through eBPF ^[?]. A genuinely impressive piece of technology. The more I read about it, the more I wanted to build something real with it.

the what:

As a beginner project into this new tech, I am working on a network chaos engineering tool. I want to build a simple CLI tool that might help an engineer understand how their products behave when the network isn’t. You experiment on a running system to build confidence it will effectively tolerate failures (network failures).

the how:

This CLI tool will leverage eBPF (extended Berkeley Packet Filter) ^[?] and Linux Traffic Control (TC) ^[?] to inject realistic network conditions directly into the local development loop. The Go CLI binary will compile and load an eBPF program (written in C) into the kernel’s network interface.

man I haven’t written any C code in the longest

Anyway, the eBPF program will dynamically inject random packet drops, simulate high-jitter delays, and artificial TCP connection drops that exactly mimic a user’s network status in different conditions (congested-wifi, deep-rural, cellular-5g e.t.c). This will force the backend systems to prove they can survive real-world network infrastructure before deploying to production.

More coming soon!

Flow State

Thu, 20 Feb 2025 09:08:28 +0300

Flow State: Where Every Developer Should Strive to Be

In the fast-paced world of software development, there’s a sweet spot where productivity peaks, creativity flows effortlessly, and work feels almost like play. That sweet spot is called the Flow State — a psychological concept that developers (and honestly, anyone) should strive to reach. But what exactly is it, and why does it matter so much for programming? Let’s dive in.

What Is the Flow State?

The Flow State is that magical moment when you’re so immersed in a task that time seems to vanish. Coined by psychologist Mihaly Csikszentmihalyi ^[?], it happens when your skills perfectly balance the challenge of what you’re working on. Too much challenge with too little skill? That’s anxiety creeping in. Too little challenge with high skills? Hello, boredom. The Flow State sits right in the middle—a place of deep focus, energy, and peak performance.

The above diagram illustrates the relationship between an individual’s skill level and the challenge level of a task, and how these factors influence their psychological state. The diagram is plotted on a graph with two axes:

The vertical axis represents “Challenge,” ranging from low (at the bottom) to high (at the top).
The horizontal axis represents “Skills,” ranging from low (on the left) to high (on the right).

The graph is divided into several zones, each labeled with a different psychological state, depending on the balance or imbalance between challenge and skill:

Flow State (center diagonal band): This is the optimal state where skills and challenges are high and well-matched. It’s a state of complete immersion, focus, and enjoyment in an activity, often described as being “in the zone.”
Anxiety (top-left): This occurs when the challenge is high, but the individual’s skills are low. The person feels overwhelmed or stressed due to the difficulty of the task relative to their abilities.
Fear of Failure (upper-left corner): A more intense version of anxiety, this happens when the challenge is extremely high and skills are very low, leading to significant fear or panic.
Boredom (bottom-right): This occurs when skills are high, but the challenge is low. The task feels too easy, leading to disinterest or lack of engagement.
Loss of Interest (far right): An extension of boredom, this happens when skills are very high and the challenge is very low, causing the individual to lose motivation or engagement entirely.
Apathy (bottom-left): This is the state where both skills and challenges are low. The individual feels indifferent or unmotivated because the task is neither engaging nor demanding.
Doubt (middle-left): This occurs when challenges are moderately high, but skills are still relatively low, leading to uncertainty or hesitation.
Nostalgia (bottom-right, near boredom): This unique addition suggests a reflective or sentimental state that might occur when skills are high but challenges are low, possibly reminiscing about past challenges or experiences.

The goal is simple: aim for that central zone where you’re fully engaged and firing on all cylinders.

Why Flow Matters for Developers

For developers, the Flow State isn’t just a buzzword—it’s a superpower. Coding is a unique blend of problem-solving, creativity, and persistence, often requiring hours of uninterrupted focus. When you’re in flow:

Productivity Skyrockets: You’re not just churning out lines of code; you’re solving problems efficiently and elegantly.
Creativity Unleashes: Those “aha!” moments—new algorithms, cleaner architectures—come naturally.
Satisfaction Soars: There’s a deep sense of fulfillment when you’re lost in a project you love.

Think back to a time when you were debugging a stubborn bug or crafting a sleek new feature, and the hours just melted away. That’s flow—and it’s where the best work happens.

How to Get Into the Flow State

The good news? Flow isn’t random. You can cultivate it with the right approach. Here are some practical tips tailored for developers:

Set Clear Goals: Vague tasks like “work on the app” won’t cut it. Try “finish the user authentication module by noon” instead. Clarity fuels focus.
Kill Distractions: Silence Slack pings, close irrelevant tabs, and put your phone on Do Not Disturb. Flow thrives in uninterrupted space.
Balance Challenge and Skill: Pick tasks that stretch you but don’t break you. Too easy? Refactor or optimize. Too hard? Break it into smaller chunks or brush up on the basics.
Block Off Deep Work Time: Reserve 60–90 minutes for pure coding—no meetings, no emails. Protect this time like it’s gold.
Celebrate Progress: Finishing a function or squashing a bug? Take a second to savor it. Small wins keep the momentum going.

Flow in Action: A Real-World Example

Take Linus Torvalds, the mastermind behind Linux. He’s famous for losing himself in code for hours, a classic sign of flow. That kind of focus helped him build and sustain one of the most impactful open-source projects ever. You don’t need to be a tech titan to tap into this—flow is within reach for any developer willing to chase it.

Your Flow Challenge

Next time you fire up your IDE, ask yourself: Am I setting myself up for flow? Tweak your environment or task until the challenge feels exciting but doable. Notice what pulls you out—Slack notifications? A noisy room?—and minimize it. The Flow State isn’t reserved for the elite. It’s a mindset and a practice that can elevate your coding from good to great. Strive for it, and watch how it transforms your work—and maybe even how you feel about it.

What’s your trick for getting into flow? Drop it in the comments—I’d love to hear!

Alan Njogu