DEV Community: TheDevSide

I Tracked Every Context Switch for a Week. Here's What Broke My Brain.

TheDevSide — Mon, 08 Dec 2025 06:30:14 +0000

Last month, I felt like I was working 10 hours but only getting 4 hours of real work done.

So I ran an experiment: I tracked every single time I left my code editor for a whole week. Every tab switch. Every app open. Every "quick" Google search.

The results were embarrassing.

The Setup

Simple rules:

Tally mark every time I leave VS Code
Note what I left for
Be honest (no cheating)

I stuck a Post-it on my monitor and kept count.

Day 1: Denial

By lunch, I had 23 tally marks.

Most common reasons:

"What's 15% tip on $67?" → Google
"What time is it in Singapore?" → World clock app
"When's 3 weeks from today?" → Calendar

I told myself this was a weird day. Lots of meetings. Unusual.

Day 3: Reality

Average per day: 31 context switches

But here's what killed me — it wasn't the big stuff. It wasn't debugging or architecture decisions pulling me out of flow.

It was tiny things:

| Task | Time to Do | Time to Recover Focus |
|------|------------|----------------------|
| Currency conversion | 15 sec | 3-5 min |
| Timezone check | 10 sec | 3-5 min |
| Quick calculation | 20 sec | 3-5 min |

The actual task took seconds. Getting back into my code took minutes.

The Math That Hurt

Let's be conservative:

30 context switches/day
3 minutes average to refocus
That's 90 minutes of dead time. Every. Single. Day.

In a 5-day week: 7.5 hours lost

I was basically losing a full workday every week to "quick" searches.

Day 5: The Rabbit Holes

Tracked something else — what happened after the initial search.

Went to Google for "45 EUR to USD"...

Noticed an interesting headline
Clicked it
Read half the article
Remembered I was working
8 minutes gone

This happened 4-5 times a day.

The browser isn't just a tool. It's a trap with a search bar.

What I Changed

Week 2, I tried to fix it.

Rule 1: No browser for simple stuff

If it's a calculation, conversion, or quick lookup — don't open Chrome. The rabbit hole isn't worth it.

Rule 2: Reduce app switching

Every app I open is a chance to get distracted. Fewer apps = fewer escape routes.

Rule 3: Keep tools at keyboard distance

If I have to reach for my mouse, click through menus, or wait for page loads — I'll get distracted while waiting.

The Tools That Actually Helped

I started looking for single-purpose tools that do one thing fast.

For calculations, I switched to a text-based calculator. Type $67 + 15% tip → get answer → done. No browser. No buttons. No rabbit holes.

For timezones, same thing. Type time in Singapore → see the time → back to code.

Sounds small. But removing 20+ daily context switches changed everything.

One Week Later

Ran the experiment again.

| Metric | Before | After |
|--------|--------|-------|
| Context switches/day | 31 | 12 |
| Browser opens for "quick" stuff | 15+ | 2-3 |
| Rabbit holes | 4-5/day | ~1/day |
| Focus time | ~5 hrs | ~7 hrs |

Not perfect. But noticeably better.

The secret wasn't discipline. It was removing the opportunity to get distracted.

The Boring Takeaway

Productivity isn't about working harder. It's about protecting focus.

Every "quick" Google search is a gamble. Sometimes you get your answer in 10 seconds. Sometimes you lose 15 minutes to a Wikipedia spiral.

The fix isn't willpower. It's environment design.

Fewer tabs. Fewer apps. Faster tools.

What I Use Now

Built a small toolkit for myself:

Text-based calculator that understands natural language
Offline-first so there's no loading time
Keyboard-driven so I never touch the mouse

Eventually turned it into a real product: Octa

If you're losing time to the same "quick" distractions, might be worth trying something similar.

We write more about developer productivity and tools we're building at techyowls.io.

What's your biggest focus killer? I'm curious if others have the same "quick Google" problem.

Things I Wish I Knew Before Building My First Tauri App

TheDevSide — Fri, 05 Dec 2025 04:54:29 +0000

I built a small desktop calculator as a side project — nothing fancy, just wanted something where I could type stuff like 100 + 10% or time in Tokyo and get quick answers.

Chose Tauri because I didn't want another 150MB Electron app on my machine. Here's what I learned along the way.

Tauri is Great, But...

The good stuff first: my app ended up at ~5MB, uses barely any RAM, and starts instantly. Rust backend means actual native performance. No regrets there.

But I ran into some gotchas that nobody warned me about.

Percentage Math is Tricky

Spent an embarrassing amount of time wondering why 100 + 10% gave me 100.1 instead of 110.

Turns out I was treating 10% as 0.1 and just adding it. But that's not how humans think — when someone types $50 + 20% tip, they want 20% of $50 added, not 0.2 added.

Simple fix once I realized it, but it's the kind of thing you don't catch until you actually use your own app for real calculations.

Users Don't Think in Code

Built a timezone feature. time in tokyo worked great. time in New York? Nothing.

My regex only matched single words. Took me way too long to realize most major cities have spaces in their names.

Same thing with country names — people type time in germany, not time in Europe/Berlin. Had to add a bunch of mappings for common country names to their capital city timezones.

Helpful Fallbacks Can Bite You

I had this clever fallback: if parsing fails, just extract any number from the input and show that. Great for partial typing, terrible for actual errors.

5 / 0 was returning 5 because my "helpful" fallback extracted the 5 and showed it. Division by zero? What division by zero?

Lesson: be explicit about which errors should trigger fallbacks and which should just fail.

Check the Plugin Ecosystem First

Wasted time building my own window position persistence. Then discovered tauri-plugin-window-state does it in one line.

Same with single-instance handling (preventing multiple windows when you click the app twice). There's a plugin for that too.

Tauri 2's plugin ecosystem is solid — check it before building something yourself.

Three-State Booleans

Had a loading flash where the wrong screen showed for a split second before the real content appeared.

The problem: I initialized my state as false, then async-loaded the real value. During that async gap, false meant "show the wrong thing."

Fix: use null for "I don't know yet", true for yes, false for no. Show a loader when it's null.

## Was It Worth It?

Definitely. The final app is tiny, fast, and actually feels native. Rust is fun once you stop fighting the borrow checker.

Would I use Tauri again? Yes — but I'd check the plugin ecosystem first and test with real inputs earlier.

## The Project

Built this for myself but figured others might find it useful too:

👉 octa.techyowls.io

It's a text calculator — type naturally, get answers. Works offline, runs on Mac/Windows/Linux.

Anyone else building with Tauri? What gotchas did you run into?

I Got Tired of Tab-Switching for Simple Calculations, So I Built This

TheDevSide — Wed, 03 Dec 2025 17:11:02 +0000

As developers, we spend our days solving complex problems. But somehow, the simplest tasks still break our flow:

"What's 150 EUR in USD?" → Open Google
"What time is it in Tokyo right now?" → Check world clock
"When is 45 days from today?" → Open calendar, count manually
"What's 18% tip on $85?" → Pull out phone calculator

Every tab switch is a context switch. Every context switch costs focus.

I kept thinking: why can't I just type what I'm thinking and get the answer?

The Problem with Traditional Calculators

Most calculators are built for numbers, not questions.

You can't type $150 + 20% tax into a standard calculator. You have to:

Type 150
Multiply by 0.20
Add the result to 150
Remember what you were doing before

And for currency? Time zones? Date math? Forget it. Those need separate apps entirely.

What If Your Calculator Understood You?

That's the idea behind Octa — a text-based calculator that works the way your brain does.

Instead of buttons and separate apps, you just type naturally:

What You Type	What You Get
`150 EUR to USD`	$162.45 (live rates)
`time in Tokyo`	2:30 AM JST
`today + 45 days`	February 17, 2026
`$85 + 18% tip`	$100.30
`5 miles in km`	8.05 km
`BMI 75kg, 1.80m`	23.15 (Normal)

No mode switching. No app hopping. Just type → answer.

Built for Developer Workflows

A few things that make it feel right for daily dev work:

Instant Results
Results appear as you type. No Enter key needed for simple stuff. Your brain stays in flow.

Multi-line Scratch Pad
Work through multiple calculations at once. Compare values. Keep notes. It's like a smart notepad that happens to calculate.

Works Offline
No internet needed for math, unit conversions, or date calculations. Currency and time zone sync when you're online, then work offline.

Keyboard-First
No mouse required. Global hotkey to summon it, type your question, get your answer, dismiss. Back to coding in seconds.

Dark Mode Native
Built with a dark interface that doesn't blast your eyes at 2 AM debugging sessions.

Things You Didn't Know You Needed

Once you start using natural input, you find uses everywhere:

Sprint planning: today + 14 days for sprint end dates
International meetings: 3pm PST in Berlin before scheduling
Freelance invoices: $2500 * 0.85 for after-platform fees
Quick health check: BMI 70kg, 175cm during a break
Travel planning: 500 USD to JPY for budget estimates

The pattern is always the same: type what you're thinking, get the answer.

Why Not Just Use Google?

You could. But:

Privacy — Your calculations stay on your machine, not in search history
Speed — No page load, no ads, no "did you mean..."
Offline — Works on planes, in tunnels, anywhere
Focus — No temptation to check "just one more thing" while the browser is open

Every time you open a browser for a quick calculation, you risk the rabbit hole.

Cross-Platform, Lightweight

Octa runs on macOS, Windows, and Linux.

Built with Tauri (not Electron), so it's about 5MB instead of 150MB+. Starts instantly, barely touches your RAM.

Try It

If you're tired of breaking flow for simple calculations, give it a shot:

👉 octa.techyowls.io

I'd love to hear what calculations you find yourself doing most often. Always looking for patterns to support better.

What's your most annoying "simple task" that breaks your coding flow? Drop it in the comments — curious if others have the same frustrations.

Tags: #productivity #tools #developers #workflow #showdev