Kaushik Gopal's Website

Agentic Fluidity - OpenCode is OpenClaw for coding

Fri, 20 Feb 2026 21:04:46 GMT

One of the reasons OpenClaw got so popular was how fluidly you can chat with and operate your agents. Pull up your phone, send a quick message on WhatsApp, and you’re in business.

As we focus more on agent orchestration¹ in 2026, I think an important aspect will be access fluidity. How do you hop into your agent’s context from any device, terminal, or IDE and just start coding?

Claude Code supports this in a limited way, while others like Cursor and Codex take a cloud-based approach.

The best option I’ve found for this “on-the-go” agentic coding is an open-source one — OpenCode.

OpenCode - your best “on-the-go” option for agentic coding.

Server-client architecture #

OpenCode uses a native server-client architecture. You can simply spin it up in a regular terminal tab, just like claude or codex.

But the power move is running it as a server and connecting multiple clients.

A client can be your terminal tab, a mobile device, or a desktop computer. Each terminal tab becomes a new, isolated CLI session that connects to the server.

Couple this with Tailscale, and you can securely connect to a dev machine running an OpenCode server from anywhere.

Getting started #

I’d start by using opencode like a regular CLI tool. Once it feels familiar, switch to server/web mode.

# advertises server as opencode.local
opencode web --mdns

# attach to a session
# equivalent to starting a new claude code session
opencode attach http://opencode.local:4096 --dir /path/to/project

The beauty is you can open that opencode.local URL in any browser, and it’s fully synced.

Credit to my co-host Iury for tooting the OpenCode horn early, and my Instacart colleague Spencer for questioning my luddite tmux ways.²

I’ll write a future post singing OpenCode’s other praises. For now, if you’re exploring the bleeding edge of agent access fluidity, don’t sleep on it.

See my post on AI paradigms. ↩︎
I noticed some memory leaks when using tmux sessions with OpenCode, and Spencer asked me: why not lean on the server-client model more and use regular Ghostty tabs and splits. ↩︎

AI model choices 2026-01

Tue, 13 Jan 2026 19:39:48 GMT

Which AI model do I use?

This is a common question I get asked, but models evolve so rapidly that I never felt like I could give an answer that would stay relevant for more than a month or two.

This year, I finally feel like I have a stable set of model choices that consistently give me good results. I’m jotting it down here to share more broadly and to trace how my own choices evolve over time.

GPT 5.2 (High) for planning and writing, including plans
Opus 4.5 for anything coding, task automation, and tool calling
Gemini’s range of models for everything else:
- Gemini 3 (Thinking) for learning and understanding concepts (underrated)
- Gemini 3 (Flash) for quick fire questions
- Nano Banana (obv) for image generation
NVIDIA’s Parakeet for voice transcription

Forking subagents in an AI coding session with tmux

Mon, 29 Dec 2025 08:00:00 GMT

With agentic coding becoming the primary paradigm for coding, many have tried to come up with a smooth subagent workflow.¹

Many of these solutions are reasonable, but none match the simplicity of what I actually want:

Spin up another agent instance with the exact same context I’ve painstakingly built.
Pursue a tangential thought interactively in a separate session.
Sometimes that’s exploratory (understand a subsystem, ask follow-ups). Sometimes it’s parallel work (write tests while context is fresh, draft docs, spike an alternative).

That’s it. Open a new tab, resume the session, take a different path.

Sounds straightforward, but tack on a few more requirements and it becomes hard to find a satisfying solution. I’ve been using a thin shell script for this and it’s worked well.²

You can find the source here.

My requirements #

Super thin glue layer #

I’m deliberately not trying to build on top of existing agents. I use claude code, codex cli & gemini daily, and they change fast enough that anything with a thick layer (like a UI) will lag behind on features.

So: a Bash script and tmux. That’s it. Available on virtually any computer.

Tool-agnostic forks #

I want to start the main session in one tool and fork into another, keeping the same context.

So I might start a planning session with codex. After I have a decent plan, I might want to fork into claude code (with all the context I’ve built) and start a coding session. I might want to fork another subagent from gemini and, using something like the nanobanana MCP, build a before/after flow diagram.

Interactive, not one-shot #

When I fork a subagent, I want a real session I can keep interacting with. It’s rare that I can one-shot a request and get exactly what I want. Based on the initial response, I might want to go down the rabbit hole and explore more.

Many existing solutions are headless or try to merge results back automatically. In practice, I just copy-paste what I need from the fork back into the main session — tmux makes this trivial.

An early version of my script had something similar: the ability to manually “pull” in results from the subagents. In practice, I rarely used it that way. I typically copy-paste relevant lines from the agent response and paste them back into the main session. With tmux, if I highlight text with my mouse, it’s automatically copied to my clipboard. Removing this feature made the script simpler and more robust.

No context bloat #

The whole point of forking is keeping tangents out of the main session. I want the main session to stay focused on the “primary” change, while side quests happen elsewhere.

But I also want the context going into the forked subagent to be controlled. To that end, the script pulls in the text from the original window (courtesy of tmux) and checks the size. If the transcript is long, I summarize it before feeding it into the subagent.

In this way, the script keeps tangential context out of the main session while still seeding useful context to the subagent.

No personas #

Claude and other tools frame subagents around personas. I don’t find them as useful.

Don’t get me wrong, personas in prompts are powerful and can give good results. But I don’t need a subagent container for that. I find myself crafting specific agent skills and seeding those into the prompt. This gives me equally good results.

Label the subagents! #

Perhaps the trickiest part of having multiple agents working in parallel is keeping track of what each agent is doing.

My current solution to this is rather trivial. Every time an agent is spawned, I label the tmux window with something that will help me remember. It works rather well!

The solution #

Feel free to take a look at the Bash script here. You can also see my tmux.conf but there’s nothing special in there, and the subagent script should work with most configurations.

The script is conceptually pretty simple:

Start a coding session in tmux (as you regularly do).
Treat the current tmux pane as the main agent or session.
When you want to spawn a subagent, capture the transcript lines using tmux (configurable).
Prompt for the task you want to perform.
Spawn a new tmux window in the background with the chosen agent command, then paste in a payload:
- <context> ... </context> (raw transcript, or an optional summary created with possibly a different agent)
- <task> ... </task> (the prompt you typed)

Caveats #

I’ve been tweaking this script for my own setup (Ghostty terminal + fish shell + tmux). I haven’t polished or tested it for any setup other than mine, but it should be straightforward to adapt.
It’s easy to spawn too many forks. The marginal value drops quickly once you’re context-switching more than you’re building.
Summarization is optional, but if you use it, you’re trusting a model to compress your transcript. If accuracy matters, keep the threshold low enough that the raw context fits.

Here are some of the most compelling ones I’ve found:
- Goose has a way of doing it, but Goose itself is a new wrapper tool, around the underlying tools that we actually use (claude code, codex cli, gemini-cli). Which means it will always lag behind on features.
- Claude itself has subagents but it’s a very different take on subagents, focusing more on the multi-persona approach.
- Amazon has a sophisticated solution called CAO (CLI Agent Orchestrator) which feels like the closest but it is far more complex than necessary, with MCPs, etc.
- Conductor is a free tool that also looks really nice, but like Goose it sits on top of the agents and focuses on independent workspaces.
↩︎
I’ve heavily tweaked this script and it works great on my current Ghostty terminal + fish shell + tmux setup. I haven’t tried to polish it for other shells, and I don’t intend to, so feel free to copy, fork, and modify it to your heart’s content! ↩︎

Wi-Fi sharing is a killer Android feature

Fri, 26 Dec 2025 20:30:06 GMT

Ubiquiti announced a new travel router. Much of the internet is excited. So am I.

Then I tried to remember the last time I actually needed a travel router. You see, Android has supported a feature I’ll call Wi-Fi sharing for years.¹ Your phone connects to an existing Wi-Fi network and re-shares it as a hotspot.

This might sound like a regular hotspot feature that most phones (including the iPhone) come with. But it’s not. iPhones can share mobile data. They can’t re-share a Wi-Fi connection as a hotspot.

Wi-Fi sharing

Your phone connects to Wi-Fi, and then re-shares that same Wi-Fi as a hotspot.

This is different from typical hotspot functionality where the phone shares its mobile data connection (vs Wi-Fi).

Neat trick, but why bother? Can’t you just connect each device to Wi-Fi?

Avoid signing every device into a captive Wi-Fi portal #

Captive portals are annoying when you’re carrying multiple devices. I typically travel with 3-4 devices that want internet. Signing each one in, every time, gets old fast.

Some devices are worse: Chromecast and Fire TV sticks are particularly painful to get past captive portals. If everything connects to your hotspot, you only deal with the portal once.²

Work around “one device at a time” Wi-Fi plans #

On a plane, I sometimes want both my laptop and phone online. Some paid Wi-Fi plans only allow one device at a time. Unless you’re ok paying twice, Wi-Fi sharing is simpler.³

Hotels and conference centers do the same: sign-in plus device limits. Wi-Fi sharing works around it.

Fix “devices can’t see each other” networking #

This one is less obvious, but common in hotels and conference Wi-Fi: your devices have internet, but they can’t see each other locally. Chromecast (or printers) won’t show up as a cast target because it doesn’t appear on the network.

That’s usually client/AP isolation.⁴ Put your devices on your phone’s hotspot, and local discovery usually works again.

Secure networking with a Tailscale setup #

This is slightly advanced. With a Tailscale setup and an explicit exit node, you basically have a private VPN.⁵ On phones where hotspot traffic routes through that VPN, you only have to set it up on your Android phone, and every device that connects to your phone gets the same “safe” path out.

If I have to log in to bank accounts when roaming or connecting to “free” Wi-Fi, this helps me feel safer knowing the local network can’t see or tamper with the contents of my traffic.⁶

Connect your Android phone to the Wi-Fi network you want to share. If it’s behind a captive portal, sign in as needed.
Go to Settings → Hotspot & tethering → Wi-Fi hotspot (wording varies) and turn it on.

Typically, if your phone does not support Wi-Fi sharing, it will disable Wi-Fi. Some OEMs show a separate toggle to enable Wi-Fi sharing. On Pixel phones, it’s automatic.

Almost every Android phone #

I should pause my gloating over iPhones for a second: a few Android devices may not support this feature.

The Android OS has Wi-Fi sharing baked in, but it still requires hardware + driver support. Notable exceptions include the Pixel 7a, the Pixel 8a, and yes the (first generation) Pixel Fold.

Technical Details #

Wi-Fi sharing requires Wi-Fi hardware (chipset + drivers) that can run as both a client and an access point at the same time (STA + AP).⁷ Chipsets can implement this in a few ways (DBS, SBS, MCC, SCC).⁸

Android doesn’t mandate one mode; it depends on the Wi-Fi chipset. DBS/SBS use multiple radios, so the phone can keep the upstream connection and hotspot truly simultaneous (for example, 5 GHz upstream and a 2.4 GHz hotspot). MCC/SCC share a radio, so the hotspot either stays on the same channel (SCC) or the radio hops channels (MCC).

If a phone can’t do STA + AP concurrency well (or at all), OEMs disable Wi-Fi sharing (which is why some phones and many older devices don’t support it).

Travel routers still have their place: Ethernet ports, better radios, and an always-on box you can run a VPN on. But if you’re on Android and your phone supports Wi-Fi sharing, you already have the core trick.

Android doesn’t call it this in Settings, but it’s the best term I have for “connect to Wi-Fi, then share that Wi-Fi as a hotspot”. In strict networking terms, this isn’t L2 bridging; it’s typically tethering (routing/NAT) with a Wi-Fi upstream. ↩︎
This works because the captive portal only sees your phone; everything else is NATed behind it. ↩︎
Thank you Delta for being one of the few US domestic airlines that don’t place this restriction. Looking at you United. ↩︎
Hotel and conference Wi-Fi often blocks device-to-device traffic on purpose (“client isolation”) so guests can’t discover, scan, or connect to each other’s devices. Your phone’s hotspot creates a separate little LAN, so your devices can talk to each other again. ↩︎
I have a post in the making about this: “With Tailscale you don’t need to pay for a VPN”. ↩︎
HTTPS encrypts the bank session, but open Wi-Fi is still untrusted: a malicious access point can tamper with DNS and try to steer you into phishing. A VPN (or Tailscale exit node) reduces the surface area by encrypting your traffic to a trusted endpoint. ↩︎
Modern devices support AP (Access Point) + STA (Station) Mode, letting them act as both a client to one network and a hotspot for others, allowing Wi-Fi extension or tethering. ↩︎
Definitions from Android’s Wi-Fi vendor HAL (WifiNative.java): DBS (Dual Band Simultaneous), SBS (Single Band Simultaneous), MCC (Multi Channel Concurrency), SCC (Single Channel Concurrency). ↩︎

AI is a motorbike for the mind

Tue, 23 Dec 2025 06:01:28 GMT

Steve Jobs famously called the computer a bicycle for the mind.

We humans are tool builders… We can fashion tools that amplify these inherent abilities to spectacular magnitudes. So for me, a computer has always been the bicycle of the mind. Something that takes us far beyond our inherent abilities.

That sentiment feels prescient again today but the vehicle has changed.

If the personal computer was a bicycle, AI is a motorbike for the mind.

I choose this distinction carefully.

To ride a bicycle well, you must build muscle. The motorbike is different. You cover vast distances without any tax on your body. Ride it long enough, and the muscles you once relied on atrophy. It’s seductive to ship words or code while skipping the slow, painful work. But wrestling with edge cases is how you learn what “good” looks like: a skill you’ll need to sharpen even more with AI doing the typing.

Speed also changes the nature of failure. A fall at 10 mph is a bruise: a bug you can trace and learn from. A fall at 60 mph is fatal: a bug hidden in code you never wrote, its damage everywhere before you notice. Keep vibe-coding your entire system¹ without understanding every line, every trade-off; you’ll eventually crash.

Here’s the thing about motorbikes: everyone can twist the throttle. What separates riders who arrive from those who crash is knowing when to brake – when to stop, look, and understand before you ship. In an age where anyone can go fast, the true skill is no longer the throttle. It’s the brake.

as opposed to engineering with AI ↩︎

Combating AI coding atrophy with Rust

Fri, 05 Dec 2025 08:00:00 GMT

It’s no secret that I’ve fully embraced AI for my coding. A valid concern (and one I’ve been thinking about deeply) is the atrophying of the part of my brain that helps me code.

To push back on that, I’ve been learning Rust on the side for the last few months. I am absolutely loving it.

Why Rust? #

Systems level language #

Kotlin remains my go-to language. It’s the language I know like the back of my hand. If someone sends me a swath of Kotlin code, whether handwritten or AI generated, I can quickly grok it and form a strong opinion on how to improve it.

But Kotlin is a high-level language that runs on a JVM. There are structural limits to the performance you can eke out of it, and for most of my career¹ I’ve worked with garbage-collected languages.

For a change, I wanted a systems-level language, one without the training wheels of a garbage collector.

New paradigms #

I also wanted a language with a different core philosophy, something that would force me to think in new ways.

I picked up Go casually but it didn’t feel like a big enough departure from the languages I already knew.

It just felt more useful to ask AI to generate Go code than to learn it myself.

With Rust, I could get code translated, but then I’d stare at the generated code and realize I was missing some core concepts and fundamentals. I loved that!

The first time I hit a lifetime error, I had no mental model for it. That confusion was exactly what I was looking for.

Coming from a GC world, memory management is an afterthought — if it requires any thought at all. Rust really pushes you to think through the ownership and lifespan of your data, every step of the way.

In a bizarre way, AI made this gap obvious. It showed me where I didn’t understand things and pointed me toward something worth learning.

Built with Rust #

Here’s some software that’s either built entirely in Rust or uses it in fundamental ways:

fd (my tool of choice for finding files)
ripgrep (my tool of choice for searching files)
Fish shell (my shell of choice, recently rewrote in Rust)
Zed (my text/code editor of choice)
Firefox (my browser of choice)
Android?! That’s right: Rust now powers some of the internals of the OS, including the recent Quick Share feature.

Many of the most important tools I use daily are built with Rust. Can’t hurt to know the language they’re written in.

Kotlin developers will feel at home #

Rust is quite similar to Kotlin in many ways. Both use strict static typing with advanced type inference. Both support null safety and provide compile-time guarantees.

The compile-time strictness and higher-level constructs made it fairly easy for me to pick up the basics. Syntactically, it feels very familiar.

How I’m learning Rust #

I started by rewriting a couple of small CLI tools I used to keep in Bash or Go. Even in these tiny programs, the borrow checker forced me to be clear about who owns what and when data goes away. It can be quite the mental workout at times, which is perfect for keeping that atrophy from setting in.

After that, I started to graduate to slightly larger programs and small services.

Main Resources #

There are two main resources I keep coming back to:

Fondly referred to as “The Book”. There’s also a convenient YouTube series following the book.
Google’s Comprehensive Rust course, presumably created to ramp up their Android team. It even has a dedicated Android chapter. This worked beautifully for me.

Using AI as a Rust tutor #

There are times when the book or course mentions a concept and I want to go deeper. Typically, I’d spend time googling, searching Stack Overflow, finding references, diving into code snippets, and trying to clear up small nuances.

But that’s changed dramatically with AI. One of my early aha moments with AI was how easy it made ramping up on code. The same is true for learning a new language like Rust.

For example, what’s the difference² between these two:

let mut x_coord: &i32
let x_coord: &mut i32

Another thing I loved doing is asking AI: what are some idiomatic ways people use these concepts? Here’s a prompt I gave Gemini while learning:

i'm learning Rust; specifically focusing on the concepts of mutability, shared
and exclusive references etc. This is from my notes:

> [!tip] There are individual concepts:
>
> 1. Mutability and immutability (through `mut`) keyword
> 2. There is References and borrowing (enabled through `&` and `*`)
>  - when you see `&` - immediately think reading/"borrowing"
> 3. Things get interesting when you combine `&mut` which is exclusive
>  references

what are some usecases in rust where we use some combination of the above. i
want to understand if i become a daily rust programmer, what are some idiomatic
commonly used patterns I should get familiar with?

Here’s an abbreviated response (the full response was incredibly useful):

Great question! Let me break down the most common idiomatic patterns you'll
encounter daily in Rust with these concepts:

Key Daily Patterns to Remember:

1. Default to &T - Use immutable references unless you need mutation
2. Use &mut T for in-place operations - Sorting, filtering, modifying
3. Clone only when necessary - Prefer borrowing over cloning
4. Method receivers tell a story - &self reads, &mut self modifies, self
 consumes
5. Iterators are everywhere - Master .iter(), .iter_mut(), and .into_iter()

The beauty of Rust is that the compiler guides you - if you try the wrong
borrowing pattern, it'll suggest the right one. After a few weeks, these
patterns become second nature!

It’s easy to be doom and gloom about AI in coding — the “we’ll all forget how to program” anxiety is real. But I hope this offers a more hopeful perspective.

If you’re an experienced developer worried about skill atrophy, learn a language that forces you to think differently. AI can help you cross that gap faster. Use it as a tutor, not just a code generator.

I did a little C/C++ in high school, but nowhere close to proficiency. ↩︎
Think mutable var to a “shared reference” vs. immutable var to an “exclusive reference”. ↩︎

AI-assisted coding → Vibe Engineering ← Vibe Coding

Tue, 18 Nov 2025 00:00:00 GMT

We’re still wrestling with how much AI belongs in our day to day coding. Three phrases keep getting mixed together:

AI-assisted coding
Vibe coding
Vibe engineering

These are not the same.

	AI Assisted	Vibe coding	Vibe engineering
Generates the code	👨‍💻 (+ 🤖)	🤖	🤖
Owns the design	👨‍💻	︎🤖	👨‍💻 ︎

They differ along two dimensions: who generates most of the code and who owns the design and quality bar.

1. AI-assisted coding #

This is where we started.

You, the programmer, write most of the code.
AI acts as super-powered autocomplete.

You type most of the code yourself. AI handles completions, boilerplate, pieces of the logic and maybe small refactors. Your eyes stay on every line, and the AI rarely acts without you explicitly placing or accepting a suggestion. This is still “you drive, AI rides shotgun”.

GitHub Copilot was the early poster child. Here’s an early video of me dabbling with Copilot and scripts. Today, Cursor Tab has taken the crown: fast, inline help without giving up control of the codebase.

I particularly like how accurate Cursor is at predicting the next point of code entry or edit. When it works well, it disappears into the background and silently increases your productivity. Get it wrong, and you’re immediately frustrated with AI.

2. Vibe coding #

This took the world by storm.

AI generates most if not all of the code.
You, the programmer, react with feedback in English and are not as in tune with what the actual code shapes up to be.

You give up intentional design. In practice, you’re letting the model make the architectural calls: file structure, abstractions, naming, everything. As your codebase grows and needs ongoing maintenance, vibe coding breaks down. Your code turns into mystery‑meat: it runs, but nobody understands clearly how or why.

This is why experienced greybeards raise alarms and complain about AI bots on their lawns.

But Vibe coding does shine in a few scenarios:

Non‑programmers who need something working without caring about internals
Fast proofs of concept and one‑off scripts
Exploring an unfamiliar platform or stack where you don’t know what “good” looks like

Andrej Karpathy, the godfather of LLMs, coined the term. Some say it with affection, others with disdain. For better or worse, the term has stuck.

I vibe‑coded a script to check if your USB‑C cable is any good and can attest to some of this. It started as a bash shell script and, for a more cross‑platform version, I asked the AI to convert it to Go. That took a few minutes; I actually know very little Go (but I know enough to know that the output code quality was not great). I still haven’t gone through every line of that script, even after that post became somewhat popular.

And that’s the whole point of vibe coding: you get something that mostly works, very quickly. It serves the purpose, even if the code isn’t something you’d proudly own long term.

3. Vibe engineering #

This is where I think software engineering with AI is headed.

AI generates most of the code, but within your explicit constraints.
You design the architecture, set boundaries, and review structure & behavior.

Vibe coding and vibe engineering both have AI generating most of the code. The difference is who owns the design: in vibe coding, the model effectively owns it; in vibe engineering, you stay the architect.

Simon Willison, wizard of LLM CLIs and skilled pelicans, is trying to popularize the term vibe engineering. He uses it to describe seasoned engineers who use LLMs and coding agents to move faster, but stay accountable for design, quality, and long‑term maintainability. I know the term “vibe” annoys folks, but I don’t mind it tbh.¹

The difference from AI‑assisted coding is autonomy. With vibe engineering, you let the AI act in bigger chunks: run commands, edit files, refactor modules; all while you still stay on the hook for overall design and behavior, not every keystroke. You’re still doing real engineering: researching approaches, making architectural decisions, defining success criteria, and spending time on code review and QA.

It amplifies classic senior‑engineer habits: tests, planning, documentation, version control, and ruthless code review.

I vibe‑engineered a fairly complex Firefox add‑on (very proud of this one; it’s one of the few Firefox extensions with tests). That experience sold me on this approach. I wasn’t vibe coding: I decided the architecture, wrote the spec, set constraints, and then used LLMs and agents to explore implementations, generate code, and iterate based on test results and reviews.

In practice, you shape the playground for the AI:

Write a quick design doc: modules, responsibilities, key interfaces
Provide strong instructions (tech choices, dependencies to avoid, safety constraints)
Ask agents to implement one slice at a time (a feature, a module, a refactor), using exec-plans
Review diffs for structure and behavior: are the boundaries clean, tests meaningful, logs sane?
If the shape is wrong, steer; if the shape is right, let the details go

As I explored in programming paradigms, we’re fully in the agentic coding era. That shift demands vibe engineering discipline. Agentic vibe-coding feels like a recipe for scaling chaos.

An alternative name to this could be agent-driven coding but vibe-engineering has a better ring to it? Vibe Coding; AI Assisted Coding; Agent Driven Coding. hmm… ↩︎

Go with monthly AI subscriptions friends

Sun, 16 Nov 2025 18:46:05 GMT

Go with monthly AI subscriptions friends

I can’t remember where I read this tip, but given how fast the AI lab models move, it’s smarter to stick with a monthly plan instead of locking into an annual one, even if the annual price looks more attractive.

I hit a DI issue on Android and was too lazy to debug it myself, so I pointed two models at it. GPT Codex gave me the cleanest, correct fix. Claude Sonnet 4.5 found a fix, but it wasn’t idiomatic and was pretty aggressive with the changes.

A month ago, I wouldn’t have bothered with anything other than the Claude models for coding. Today, Codex clearly feels ahead. Google is about to ship its next Gemini model and, from what I’m hearing, it’s going to be absurdly good.

In these wonderfully unstable times, monthly subscriptions are the way to go.

Firefox + UbO is still better than Brave, Edge or any Chromium-based solution

Fri, 14 Nov 2025 04:38:50 GMT

I often find myself replying to claims that Brave, Edge, or other Chromium browsers effectively achieve the same privacy standards as Firefox + uBlock Origin (uBO).

This is simply not true.

Brave and other Chromium browsers are constrained by Google’s Manifest V3. Brave works around this by patching Chromium and self-hosting some MV2 extensions, but it is still swimming upstream against the underlying engine.

Firefox does not have these MV3 constraints, so uBlock Origin on Firefox retains more powerful, user-controllable blocking than MV3-constrained setups like Brave + uBO Lite.

Brave is an excellent product and what I used for a long time. But the comparison often ignores structural realities. There are important nuances that make Firefox the more future-proof platform for privacy-conscious users.

Manifest V3 permanently nerfs Chromium-based browsers #

The core issue is Manifest V3 (MV3). This is Google’s new extension architecture for Chromium (what Chrome, Brave, and Edge are built on).

Under Manifest V2, blockers like uBO used the blocking version of the webRequest API (webRequest + webRequestBlocking) to run their own code on each network request and decide whether to cancel, redirect, or modify it.

MV3 deprecates that blocking path for normal extensions and replaces it with the declarativeNetRequest (DNR) API: extensions must declare a capped set of static rules in advance, and the browser enforces those rules without running extension code per request. This preserves basic blocking but, as uBO’s developer documents, removes whole classes of filtering capabilities uBO relies on.

And Google is forcing this change by deprecating MV2.

Yeah, shitty.

Brave’s workaround for Manifest V3 #

To get around the problem, Brave is effectively swimming upstream against its own engine. It does this in two ways:

Native patching: It implements ad-blocking (Shields) natively in C++/Rust within the browser core to bypass extension limitations.
Manual extension hosting: Brave now has to manually host and update specific Manifest V2 extensions (like uBO and AdGuard) on its own servers to keep them alive as Google purges them from the store.

They wrote a great post about this too.

Brave is doing a great job, but it is operating with a sword of Damocles hanging over it. The team must manually patch a hostile underlying engine to maintain functionality that Firefox simply provides out of the box.

uBlock Origin Lite != uBlock Origin #

A lot of people also say, wait, we now have “uBlock Origin Lite” that does the same thing and is even more lightweight!

Nope.

It is “lite” for a reason. You are not getting the same blocking safeguards. uBO Lite is a stripped-down version necessitated by Google’s API restrictions.

As detailed in the uBlock Origin FAQ, the “Lite” version lacks in the following ways:

No on-demand list updates: uBO Lite compiles filter lists into the extension package. The resulting declarative rulesets are refreshed only when the extension itself updates, so you cannot trigger an immediate filter-list or malware-list update from within the extension.
No “Strict Blocking”: uBO Lite does not support uBlock Origin’s strict blocking modes or its per-site dynamic matrix. With full uBO on Firefox, my setup defines and exposes a custom, per-site rule set that ensures Facebook never sees my activity on other sites. uBO Lite does not let me express or maintain that kind of custom policy; I have to rely entirely on whatever blocking logic ships with the extension.
No dynamic filtering: You lose the advanced matrix to block specific scripts or frames per site.
Limited element picker: “Pointing and zapping” items requires specific, permission-gated steps rather than being seamless.
No custom filters: You cannot write your own custom rules to block nearly anything, from annoying widgets to entire domains.

Firefox offers the best experience with uBlock Origin #

uBlock Origin is widely accepted as the most effective content blocker available. Its creator, gorhill, has explicitly stated that uBlock Origin works best on Firefox.

So while using a browser like Brave is better than using Chrome or other browsers that lack a comprehensive blocker, it is not equivalent to Firefox + uBlock Origin.

Brave gives you strong, mostly automatic blocking on a Chromium base that is ultimately constrained by Google’s MV3 decisions. Firefox + uBlock Origin gives you a full-featured, user-controllable blocker on an engine that is not tied to MV3, which matters if you care about long-term, maximum control over what loads and who sees your traffic.

Cognitive Burden

Tue, 04 Nov 2025 22:24:00 GMT

A common argument I hear against AI tools: “It doesn’t do the job better or faster than me, so why am I using this again?”

Simple answer: cognitive burden.

My biggest unlock with AI was realizing I could get more done, not because I was faster, but because I wasn’t wringing my brain with needless tedium. Even if it took longer or needed more iterations, I’d finish less exhausted. That was the aha moment that sold me.

On Writing #

Simple example: when writing a technical¹ post, I start with bullet points. Sometimes there’s a turn of phrase or a bit of humor I enjoy, and I’ll throw those in too. Then a custom agent trained on my writing generates a draft in my voice.

After it drafts, I still review every single word.

A naysayer might ask: “Well, if you’re reviewing every single word anyway, at that point, why not just write the post from scratch?”

Because it’s dramatically easier and more enjoyable not to grind through and string together a bunch of prepositions to draft the whole post. I’ve captured the main points and added my creative touch; the AI handles the rest. With far less effort, I can publish more quickly — not due to raw speed, but because it’s low‑touch and I focus only on what makes it uniquely me.

Cognitive burden ↓.

On Coding #

About two years ago I pushed back on our CEO in a staff meeting: “Most of the time we engineers waste isn’t in writing the code. It’s the meetings, design discussions, working with PMs, fleshing out requirements — that’s where we should focus our AI efforts first.”²

I missed the same point. Yes, I enjoy crafting every line of code and I’m not bogged down by that process per se, but there’s a cognitive tax to pay. I’d even say I could still build a feature faster than some LLMs today (accounting for quality and iterations) before needing to take a break and recharge. Now I typically have 3–4 features in flight (with requisite docs, tests, and multiple variants to boot).

Yes, I’m more productive. And sure, I’m probably shipping faster. But that’s correlation, not causation. Speed is a byproduct. The real driver is less cognitive burden, which lets me carry more.

What’s invigorated me further as a product engineer is that I’m spending a lot more time on actually building a good product.

It’s not that I don’t know how to write every if statement; it’s just… no longer interesting. Others feel differently. Great! To each their own.

For me, that was the aha moment that sold me on AI. Reducing cognitive burden made me more effective; everything else followed.

I still craft the smaller personal posts from scratch. I do this mostly because it helps evolve my thinking as I write each word down — a sort of muscle memory formed over the years of writing here. ↩︎
In hindsight, maybe not one of my finest arguments especially given my recent fervor. To be fair, while I concede my pushback was wrong, I don’t think leaders then had the correct reasoning fully synthesized. ↩︎

Standardize with ⌘ O ⌘ P to reduce cognitive load

Sat, 01 Nov 2025 00:38:50 GMT

There are a few apps on macOS in the text manipulation category that I end up spending a lot of time on. For example: Obsidian (for notes), Zed (text editor + IDE lite), Android Studio & Intellij (IDE++), Cursor (IDE + AI), etc.

All these apps have two types of commands that I frequently use:

Open a specific file or note
Open the command palette (or find any action menu)

But by default, these apps use ever so slightly different shortcuts. One might use ⌘ P, another might use ⌘ ⇧ P, etc.

I’ve found it incredibly helpful to take a few minutes and make these specific keyboard shortcuts the same everywhere. So now I use:

⌘ O – Open a file/note
⌘ P – Open the command palette (or equivalent action menu)

This small change has reduced cognitive load significantly. I no longer have to think about which app I’m in, and what the shortcut is for that specific app. Muscle memory takes over, and I can just get things done faster. Highly recommended!

Product vs Model Innovation

Wed, 29 Oct 2025 19:32:07 GMT

Cursor is known to be the fastest growing SaaS company in history. Yet, because they don’t control the underlying model, I’ve always felt the writing was on the wall. They are an AI tool, not an AI product, and tool companies risk disruption from model providers who can build competing tools on their own platforms.

But Cursor has consistently shown they can deliver the highest quality product. The paradigms they introduce set the standard for how AI integrates into developer workflows. When Claude Code and other TUIs emerged with smoother agentic editing, I wondered how Cursor would respond.

Sure enough, Cursor 2.0 proves they can stay ahead by introducing some of the best UI paradigms for an agentic IDE.

What keeps Cursor going is product innovation, not model innovation. They aren’t trying to win the model game.¹ And while many worry the writing is on the wall, they continue to set the pace for how IDEs adopt AI.

Addendum #

The more I read their subsequent post on kernels and how they went about training Composer (their new custom model), I’m starting to change my thinking about Cursor and ever so slightly more bullish on the writing not being on the wall for them after all. Their first mover advantage (with a fantastic product) allowed them to collect data that’s unique to the coding IDE use case. This has now given them the ability to train a highly effective custom model that could potentially give the Sonnet 4.5s and GPT codexes of the world a run for their money.

Yes, I’m aware they have custom models and “Cursor Tab” is an example of them doing amazing work in that area. But their “product” still relies heavily on the primary model. If Cursor didn’t support Sonnet 4.5, for example, it would be a non-starter for most users. ↩︎

Agent Skills: How is it different from command and other tools?

Mon, 20 Oct 2025 11:45:11 GMT

Anthropic announced Claude Skills and my first reaction was: “So what?” We already have AGENTS.md, slash commands, nested instructions, or even MCPs. What’s new here?

But if Simon W thinks this is a big deal, then pelicans be damned; I must be missing something. So I dissected every word of Anthropic’s eng. blog post to find what I missed.

I don’t think the innovation is what Skills does or achieves, but rather how it does it that’s super interesting. This continues their push on context engineering as the next frontier.

Addendum

Skills has been out for sometime and Anthropic has even made it an open standard. Make sure to read the addedum at the end of this post, where I share some newer realizations I’ve had since first writing it.

Skills and how it works #

Skills are simple markdown files with YAML frontmatter. But what makes them different is the idea of progressive disclosure:

Progressive disclosure is the core design principle that makes Agent

Skills flexible and scalable. Like a well-organized manual that starts with a table of contents, then specific chapters, and finally a detailed appendix, skills let Claude load information only as needed:

So here’s how it works:

Scan at startup: Claude scans available Skills and reads only their YAML descriptions (name, summary, when to use)
Build lightweight index: This creates a catalog of capabilities (with minimal token cost); so think dozens of tokens per skill
Load on demand: The full content of a Skill only gets injected into context when Claude’s reasoning determines it’s relevant to the current task

This dynamic context loading mechanism is very token efficient; that’s the interesting development here. In this token-starved AI economy, that’s 🤑. Other solutions aren’t as good in this specific way.

Why the alternatives aren’t as good #

AGENTS.md (monolithic) #

✓ Auto-discovered and loaded
✗ Static: all context loaded upfront (bloats context window at scale)

Why not throw everything into AGENTS.md? You could add all the info directly and agents would load it at session start. The problem: loading everything fills up your context window fast, and your model starts outputting garbage unless you adopt other strategies. Not scalable.

Nested AGENTS.md #

✓ Scoped to directories
✗ Not portable across folders; overrides behavior, not composition

Place an AGENTS.md in each subfolder and agents read the nearest file in the tree. This splits context across folders and solves token bloat. But it’s not portable across directories and creates an override behavior instead of true composition.

Referenced instruction files #

✓ Organized and modular
✗ Still requires static loading when referenced

Place instructions in separate files and reference them in AGENTS.md. This fixes the portability problem vs the nested approach. But when referenced, the full content still loads statically. Feels closest to Skills, but lacks the JIT loading mechanism.

Slash commands #

✓ Powerful and procedural
✗ Manual invocation breaks agent autonomy

Slash commands (or /prompts in Codex) let you provide organized, hyper-specific instructions to the LLM. You can even script sequences of actions, just like Skills. The problem: these aren’t auto-discovered. You must manually invoke them, which breaks agent autonomy.

MCPs (Model Context Protocol) #

✓ Access to external data sources
✗ Heavyweight; vendor lock-in; overkill for procedural knowledge

Skills handle 80% of MCP use cases with 10% of the complexity. You don’t need a network protocol if you can drop a markdown file that says “to access GitHub API, use curl api.github.com with $GITHUB_API_KEY.” To be quite honest, I’ve never been a big fan of MCPs. I think they make a lot of sense for the inter-service communication but more often than not they’re overkill.

The Verdict #

Token-efficient context loading is the innovation. Everything else you can already do with existing tools.
If this gets adoption, it could replace slash commands and simplify MCP use cases.
I keep forgetting, this is for the Claude product generally (not just Claude Code) which is cool.

Skills is starting to solve the larger problem: “How do I give my agent deep expertise without paying the full context cost upfront?” That’s an architectural improvement definitely worth solving and Skills looks like a good attempt.

Addendum #

Dec 25, 2025

Skills has been out for sometime now. Here are some of the realizations I’ve since had:

Skills are an open standard #

Anthropic announced that they’ve made Agent Skills an open standard now. It’s telling how quickly the various AI labs & companies have adopted Agent Skills. I think the implication here is that agent skills will probably subsume other equivalent mechanisms and tools. Codex for example has a more flushed out version of skills than slash commands (even though slash commands was a feature that predates skills).

Skills is universal #

I missed this the first time around, but you can use custom Skills outside of developer environments. For example claude.ai supports uploading zip files as custom skills. This can be pretty powerful for non-developers. If I build a python script that generates a custom pdf from three uploads and some custom text, package it up as a custom skill and upload to claude.ai, mom and dad can leverage this without having to write a lick of code.

Cargo Culting

Sat, 18 Oct 2025 16:37:23 GMT

If you’re a software engineer long enough, you will meet some gray beards that throw out-of-left-field phrases to convey software wisdom.

For example, you should know if you’re yak-shaving or bike-shedding, and when that’s even a good thing.

A recent HN article¹ reminded me of another nugget – Cargo Culting (or Cargo Cult Programming).

Definition #

Cargo Culting: ritualizing a process without understanding it.

In the context of programming:

practice of applying a design pattern or coding style blindly without understanding the reasons behind it

Example #

I’m going to take this opportunity to air one of my personal cargo-culting pet peeves, sure to kick up another storm: Making everything small.

When I get PR feedback saying “this class is too long, split this!”, I get ready to launch into a tirade: you’re confusing small with logically small – ritualizing line count without understanding cohesion. You can make code small by being terse: removing whitespace, cramming logic into one-liners, using clever shorthand.² But you’ve just made it harder to read. A function that does one cohesive thing beats multiple smaller functions scattered across files.

Etymology #

As the parable goes, after the end of the Second World War, indigenous tribes believed that air delivery of cargo would resume if they carried out the proper rituals, such as building runways, lighting fires next to them, and wearing headphones carved from wood while sitting in fabricated control towers.

While on the surface amusing, there’s sadness if you dig into the history and contributing factors (value dominance, language & security barriers). I don’t think that’s reason to avoid the term altogether. We as humans sometimes have to embrace our dark history, acknowledge our wrongs and build kindness in our hearts. We cannot change our past, but we can change our present and future.

The next time someone on your team ritualizes a pattern without understanding it, you’ll know what to call it.

Who comes up with these terms anyway?

Now that you’re aware of the term, you’ll realize that the original article’s use of the term cargo-cult is weak at best. In HN style, the comments were quick to call this out. ↩︎
You know exactly what I’m thinking of, fellow Kotlin programmers. ↩︎

ExecPlans – How to get your coding agent to run for hours

Mon, 13 Oct 2025 01:01:48 GMT

I’ve long maintained that the biggest unlock with AI coding agents is the planning step. In my previous post, I describe how I use a .ai/plans directory and ask the agent to diligently write down its tasks before and during execution.

Most coding agents now include this as a feature. Cursor, for example, introduced it as an explicit feature recently.

While that all felt validating, on a plane ride home I watched OpenAI’s DevDay. One of the most valuable sessions was Shipping with Codex. Aaron Friel — credited with record-long sessions and token output — walked through his process and the idea of “ExecPlans.” It felt similar at first, but I quickly realized this was some god-level planning.

He said OpenAI would release his PLANS.md soon, but I couldn’t wait. On that flight, with janky wifi, I rebuilt what I could from the talk and grew my baby plan into something more mature — and I was already seeing better results. I pinged Aaron on BlueSky for the full doc, and he very kindly shared the PR that’s about to get merged with detailed information.

My god, this thing is a work of art. Aaron clearly spent a lot of time honing it. I’ve tried it on two PRs so far, and it’s working fantastically. I still need to put it through its paces on some larger work projects, but I feel comfortable preemptively calling it the gold standard for planning.

I’ve made a few small tactical tweaks to how I use it:

I instruct the agent to write plans to .ai/plans (works across coding agents)
In my AGENTS.md I tell agents to put temporary plans in .ai/plans/tmp (which I’ve gitignored)
I keep the master PLANS.md Aaron shared at @.ai/plans/PLANS.md

This is really a big unlock, folks. Try it now.

The latest PLANS.md can be found in Aaron’s PR. Use it as a template in your .ai/plans folder. Then instruct your agent via AGENTS.md to always write an ExecPlan when working on complex tasks.

I highly recommend you go watch Aaron’s part of the talk Shipping with Codex.

I’ll update this post once it’s merged or if anything changes.

Update: I’ve been using this for the last few days (~8 PRs so far) and on an average I’ve definitely gotten my agents to run for much longer successfully (longest was about ~1 hour but frequently >30 mts). This is the way.

We are becoming software Conductors

Sat, 11 Oct 2025 18:59:38 GMT

Engineers won’t be replaced by tools that do their tasks better; they’ll be replaced by systems that make those tasks nonessential.

Sangeet Paul Choudary wrote an insightful piece on AI-driven job displacement and a more transformative way to think about it:

To truly understand how AI affects jobs, we must look beyond individual tasks to comprehend AI’s impact on our workflows and organizations.

The task-centric view sees AI as a tool that improves how individual tasks are performed. Work remains structurally unchanged. AI is simply layered on top to improve speed or lower costs. …In this framing, the main risk is that a smarter tool might replace the person doing the task.

The system-centric view, on the other hand, looks at how AI reshapes the organization of work itself. It focuses on how tasks fit into broader workflows and how their value is determined by the logic of the overall system. In this view, even if tasks persist, the rationale for grouping them into a particular job, or even performing them within the company, may no longer hold once AI changes the system’s structure.

If we adopt a system-centric view, how does the role of a software engineer evolve?¹ I’ve had a notion for some time — the role will transform into a software “conductor”.

Software conductors #

music conductors

conducting is the art of directing the simultaneous performance of several players or singers by the use of gesture

The tasks a software conductor must master differ from those of today’s software engineer. Here are some of the shifts I can think of:

Task Orchestration Mastery #

The craft is knowing exactly how much detail to provide in prompts: too little and models thrash; too much and they overfit or hallucinate constraints. You’ll need to write spec-grade prompts that define interfaces, acceptance criteria, and boundaries — chunking work into units atomic enough for clear execution yet large enough to preserve context. Equally critical: recognizing when to interrupt and redirect — catching drift early and steering with surgical edits rather than expensive reruns or loops.

AI-Compatible System Design #

You’ll need to design systems that AI can both navigate and extend elegantly. This means clear module boundaries with explicit interfaces, descriptive naming that models can infer purpose from, and tests that double as executable specs. The goal: systems where AI agents can make surgical changes quickly and efficiently without cascading tech debt.

Parallel Experimentation #

We’re moving from building one solution to exploring many simultaneously. This unlocks three levels of experimentation:

Feature variants — Build competing product approaches in parallel. One agent implements phone-only authentication while another builds traditional email/password. Both ship behind feature flags. Let users decide which wins.

Implementation variants — Build the same feature with different architectures. Redis caching on path A, SQLite on path B. Run offline benchmarks and online canaries to measure which performs better under real load.

Personalized variants — Stop looking for a single winner. The most radical shift: each user might get their own variant. Not just enterprise vs consumer, but individual-level personalization where the system learns what works for you specifically. Power users get keyboard shortcuts and dense information; casual users get guided flows with progressive disclosure. Users who convert on social proof see testimonials; analytical users see feature comparisons. AI makes the economics work — what was prohibitively expensive (maintaining thousands of personalized codepaths manually) becomes viable when AI generates, tests, and synchronizes variants automatically.

The skill: running rigorous evals, measuring trade-offs with metrics, and orchestrating the complexity of multiple live variants.

Real-time Cost-Performance Arbitrage #

Every API call has a price, a latency budget, and quality trade-offs. You’ll need to master arbitrage between expensive reasoning models and cheaper models, knowing when to leverage MCPs, local tools, or cloud APIs. Learn how models approach refactors differently from new features or bug fixes, then tune prompts, context windows, and routing strategies accordingly.

Observability & Evals as a Discipline #

You’ll need to build golden test sets, trace model runs, classify failure modes, and treat evals like unit tests. Evaluation frameworks with baseline datasets, regression suites, and automated canaries that catch quality drift before production become non-negotiable. Without observability, you can’t iterate safely or validate that changes actually improve outcomes.

Generalist Thinking Over Specialist Skills #

Framework fluency loses value when AI handles syntax. What matters is depth in three areas:

Core computer science fundamentals — Not because AI doesn’t know them, but because you need to verify AI made the right trade-offs for your specific constraints. AI might use quicksort when your dataset is always 10 items. It might optimize a function that runs once a day while missing the N+1 query in your hot path — where you loop through 1000 users making a database call for each instead of batching. Your value is code review with context: catching when AI optimizes for the wrong thing, knowing when simple beats clever, and spotting performance cliffs before they ship.

Product judgment — Knowing which problem to solve, not just how to solve it. AI can build any feature you describe, but it can’t tell you whether that feature matters. Understanding user needs, prioritizing ruthlessly, and recognizing when you’re overbuilding becomes the bottleneck.

Domain expertise — Deep knowledge of your problem space — whether it’s payments, healthcare, logistics, or graphics. AI can write generic code, but it struggles with domain-specific edge cases, regulations, and the unwritten rules experts know. The more niche your expertise, the harder you are to replace.

These are the skills that matter for the next three years. But I don’t have a crystal ball beyond that. At the pace AI is evolving, even conductors might become a role that AI plays better. The orchestration itself could be automated, leaving us asking the same questions about the next evolution.

For now, learning to conduct is how we stay relevant.

Companies will change how they ship too; but the nearer shift is the individual’s role, so that’s my focus for this post. ↩︎

Sorting Prompts - LLMs are not wrong you just caught them mid thought

Fri, 10 Oct 2025 16:19:26 GMT

Good sensemaking processes iterate. We develop initial theories, note some alternative ones. We then take those theories that we’ve seen and stack up the evidence for one against the other (or others). Even while doing that we keep an eye out for other possible explanations to test. When new explanations stop appearing and we feel that the evidence pattern increasingly favors one idea significantly over another we call it a day.

LLMs are no different. What often is deemed a “wrong” response is often4 merely a first pass at describing the beliefs out there. And the solution is the same: iterate the process.

…

What I’ve found specifically is that pushing it to do a second pass without putting a thumb on the scale almost always leads to a better result. To do this I use what I call “sorting statements” that try to do a variety of things

Mike Caulfield is someone who cares about the veracity of information. The entire post is fascinating and has painted LLM search results in a new way for me.

I now have a Raycast Snippet aiprompt; which expands to this:

What is the evidence for and against the claim/guidance just stated?

Already I’m seeing much better results.

Build your own /init command like Claude Code

Tue, 07 Oct 2025 15:58:06 GMT

Build your own /init command

Claude’s /init makes it easy to add clear repo instructions. Build your own and use it with any agent to add or improve on an existing AGENTS.md Here’s the one I came up with.

Claude Code really nailed the onboarding experience for agentic coding. Open it, type /init, and you get a CLAUDE.md that delivers better results than a repo without proper system instructions (or an AGENTS.md).

It’s a clever way to ramp a repo fast. As I wrote last time, it hits one of the three levers for successful AI coding - seeding the right context. Even Codex CLI now comes with a built-in init prompt.

There’s no secret¹ sauce: /init is just a strong prompt that writes (or improves) an instructions file.

Here’s the prompt, per folks who’ve reverse‑engineered it:

Please analyze this codebase and create a CLAUDE.md file, which will be given to future instances of Claude Code to operate in this repository.

What to add:

1. Commands that will be commonly used, such as how to build, lint, and run tests. Include the necessary commands to develop in this codebase, such as how to run a single test.
2. High-level code architecture and structure so that future instances can be productive more quickly. Focus on the "big picture" architecture that requires reading multiple files to understand

Usage notes:

- If there's already a CLAUDE.md, suggest improvements to it.
- When you make the initial CLAUDE.md, do not repeat yourself and do not include obvious instructions like "Provide helpful error messages to users", "Write unit tests for all new utilities", "Never include sensitive information (API keys, tokens) in code or commits"
- Avoid listing every component or file structure that can be easily discovered
- Don't include generic development practices
- If there are Cursor rules (in .cursor/rules/ or .cursorrules) or Copilot rules (in .github/copilot-instructions.md), make sure to include the important parts.
- If there is a README.md, make sure to include the important parts.
- Do not make up information such as "Common Development Tasks", "Tips for Development", "Support and Documentation" unless this is expressly included in other files that you read.
- Be sure to prefix the file with the following text:

You can write your own and get the same result. I use a custom /initialize on new repos to get up and running fast.² I tweaked it to work across different coding agents and sprinkled in a few tips I collected along the way.

It should create a relevant AGENTS.md; if one exists, it updates it. Save this prompt as a custom command and use it with any tool — Gemini CLI, Codex, Amp, Firebender, etc. You aren’t stuck with any single tool.

One more tip: a reasoning model works best for these types of commands.

I must say: the more time I spend with these tools, the more “emperor‑has‑no‑clothes” moments I have. Some of the ways these things work are deceptively simple.

Claude does a few other things, like instructing its inner agent tools (BatchTool & GlobTool) to collect related files and existing instructions (package*.json, *.md, .cursor/rules/**, .github/copilot-instructions.md, etc.) as context for generating or updating CLAUDE.md. But the prompt is the meat. ↩︎
I used this prompt when I vibe‑engineered a maintainable Firefox add‑on. ↩︎

Three important things to get right for successful AI Coding

Sun, 05 Oct 2025 16:54:46 GMT

I often hear AI coding feels inconsistent or underwhelming. I’m surprised by this because more often than not, I get good results.

When working with any AI agent (or any LLM tool), there are really just three things that drive your results:

the context you provide
the prompt you write
executing in chunks

This may sound discouragingly obvious, but being deliberate about these three (every time you send a request to Claude Code, ChatGPT etc.) makes a noticeable difference.

…and it’s straightforward to get 80% of this right.

Context #

LLMs are pocket‑sized world knowledge machines. Every time you work on a task, you need to trim that machine to a surgical one that’s only focused on the task at hand. You do this by seeding context.

The simplest way to do this, especially for AI Coding:

System rules & agent instructions: This is basically your AGENTS.md file where you briefly explain what the project is, the architecture, conventions used in the repository, and navigation the project.¹
Tooling: Lot of folks miss this, but in your AGENTS.md, explicitly point to the commands you use yourself to build, test and verify. I’m a big fan of maintaining a single Makefile with the most important commands, that the assistant can invoke easily from the command line.
Real‑time data (MCP): when you need real-time data or connect to external tools, use MCPs. People love to go on about complex MCP setup but don’t over index on this. For e.g. instead of a github MCP just install the gh cli command let the agent run these directly. You can burn tokens if you’re not careful with MCPs. But of course, for things like Figma/JIRA where there’s no other obvious connection path, use it liberally.

There are many other ways, and engineering better context delivery is fast becoming the next frontier in AI development.²

Prompt #

Think of prompts as specs, not search queries. For example: ‘Write me a unit test for this authentication class’ 🙅‍♂️.

Instead of that one‑liner, here’s how I would start that same prompt:

Persona:
- You're an expert Android developer, well‑versed in industry norms and testing conventions
- You only use Kotlin, JUnit 5, and Mockito

Task:
Write the unit tests for @AuthService.kt

Context/Constraints:
- Follow the existing testing patterns as demonstrated in @RuleEngineService.kt
- Start by writing the tests for the three public methods first - `login`, `logout`, `refreshToken`
- Prefer fakes over mocks; if we don't have a convenient fake class, add one
 - Remember, never make real network or database calls in these tests
- Make sure to cover happy paths and error cases as well

Output:
- AuthServiceTest.kt in folder <src/test/...>
- Test names: methodName_condition_expectedResult

Verify:
- Use `make test AuthService` to test just this class
- Don't run lint while iterating; it will take a long time
- I need to hit a code coverage of at least 80%.
 - You can check coverage for this class with `make test-coverage AuthService`

First propose a plan before you start making changes or coding. Proceed only after I accept

I use a text‑expansion snippet, aiprompt;, almost every single time. It reminds me to structure any prompt:

Persona:
- {cursor}

Task:
-

Context/Details/Constraints:
-

Output:
-

Verify:
-

This structure forces you to think through the problem and gives the AI what it needs to make good decisions.

Custom commands #

Writing detailed prompts every single time gets tedious. So you might want to create “command” templates. These are just markdown files that capture your detailed prompts.

People don’t leverage this enough. If your team maintains a shared folder of commands that everyone iterates on, you end up with a powerful set of prompts you can quickly reuse for strong results. I have commands like /write-unit-test.md, /write-pr-desc.md, /debug-ticket.md, /understand-feature.md etc.

Chunking #

AI agents hit limits: context windows fill up, attention drifts, hallucinations creep in, results suffer. Newer models can run hours‑long coding sessions, but until that’s common, the simpler fix is to break work into discrete chunks and plan before coding.

Many developers miss this. I can’t stress how important it is, especially when you’re working on longer tasks. My post covers this; it was the single biggest step‑function improvement in my own AI coding practice.

Briefly, here’s how I go about it:

Session 1 — Plan only #

Share the high‑level goal and iterate with the agent
Don’t write code in this session; use it to tell the agent what it’s about to do.
Once you’re convinced, ask the agent to write the plan in detailed markdown in your .ai/plans/ folder
Reset context before you start executing

Session 2+ — Execute one task at a time #

Spawn a fresh agent, load task-1.md.
Implement only that task, verify & commit.
Reset or clear your session.
Proceed to task-2.md and repeat.

One‑shot requests force the agent to plan and execute simultaneously — which rarely produces great results. If you were to submit these as PRs to your colleagues for review, how would you break them up? You wouldn’t ship 10,000 lines, so don’t do that with your agents either.

Plan → chunk → execute → verify.

So the next time you’re not getting good results, ask yourself these three things:

Am I providing all the necessary context?
Is my prompt a clear spec?
Am I executing in small, verifiable chunks?

I wrote a post about this btw, on consolidating these instructions for various agents and tools. ↩︎
Anthropic’s recent post on “context engineering” is a good overview of techniques. ↩︎

Vibe-engineering a Firefox add-on: Container Traffic Control

Mon, 29 Sep 2025 02:31:35 GMT

I wanted to test a simple claim: you can ship maintainable software by vibe-engineering end to end. I set strict constraints:

New platform (I haven’t built a browser extension/add-on)
Language I’m no longer proficient in (JavaScript)
Zero manual code editing

In about a day¹ I had a working Firefox add-on I could submit for review. The code meets my bar for readability and long‑term change. Even the icon came from an image model.²

Introducing Container Traffic Control.

Install and source

• Install: Firefox add-on listing

• Code: github.com/kaushikgopal/ff-container-traffic-control

On the vibe-engineering process #

It’s in vogue to share horror stories of decimated vibe-coded repos.³ But I’m convinced that with the right fundamentals, you can vibe-engineer⁴ a codebase you’d comfortably hand to another engineer.

This was my experiment to vet my feelings on the subject. Granted, this was a small and arguably very simple repository, but I’ve also seen success with moderately larger codebases personally.

It comes down to scrupulous pruning: updating system instructions, diligent prompting, and code review. I plan to write much more about this later, but let’s talk about some of the mechanics of how it went:

I didn’t write a single line of JavaScript by hand. When I needed changes, better structure, reusable patterns, small refactors — I asked the agent. The goal throughout was simple: keep the codebase readable and maintainable. It now has a lot of the things we consider important for a decent codebase:

Tests (for the important parts)
Well-organized code
Clear, useful logging
Code comments (uses a style called space-shuttle style programming, which I think is increasingly valuable with vibe-engineering)

The best part: most of this came together over two days.⁵ Some example pull requests from the repository with the exact prompt I used and the plan that was generated:

Here’s the very first prompt I used to generate the guts of the code:

# Role/Persona:
- you are an expert javascript developer who is well versed with making firefox add-ons and extensions.
- you have a strong propensity to write clearly legible code with simple to understand code comments.

# Task/Goal:
- write the functionality for the firefox add-on "Container Traffic Control" (CTC). I will provide you with the
requirements
- work on first task which is adding the rules, running the validation check, then outputting clear debug logs


# Details:
- the container takes in rules from the preferences panel; it does it similarly to how the extension (see
screenshot)
 - you can find all the relevant code for the extension "conductor" that does something similar
https://github.com/mcortt/Conductor - this is where the screenshot is from
- where CTC is different from conductor is that CTC takes in a rule with 4 possible fields (each rule will have 4
fields)
 - 1. container name (name of firefox container)
 - 2. allow/block (drop down that says this rule should either "block" or "allow"
 - 3. url pattern (regex pattern that will match the website url someone is about to navigate to)
 - 4. high prioirty (is this rule a high prioirty rule)
- CTC will build a redirectRules object similar to Conductor based on the rules that a user inputs

[Image #1]

- on attempting to save a rule, CTC will always run a "validation check" on all rules:
 - same url pattern cannot have more than one high priority container
 - same url pattern cannot have both allow and block
 - Allow Only + `*` - invalid rule

in a future task i will provide how to process these rules. but for now, i would like to achieve the following:
- allow a user to input rules
- rule is saved if validated
- on each save, print an output log showing the table or list of rules object

the code must be extremely legible, simple and clean
- avoid overly nesting or including too many classes of fancy javascript

# Context:

- https://github.com/mcortt/Conductor/blob/6daa9ce23f2de0dc43f9e07378da03f141195fec/background.js is the main file
from conductor that you cna draw inspiration from
- i also like the addon https://github.com/kemayo/firefox-sticky-containers/blob/master/background.js which has a
clean style of code commenting and details - use this for inspiration in terms of how to write the code, add
comments, and debug logs
- container-redirect is an advanced add-on which provides almost the same set of complexity/functionality that CTC
will eventually achieve - code can be found here
https://github.com/max-dw-i/container-redirect/blob/master/src/index.js ; you may use this to figure out how
containers in firefox work, differnet functionality that can be achieved etc.

you are allowed to search the codebases of these plugins if necessary.

# Output Format:
- i want you to go through the asks
- if there are things that are unclear, raise them and ask me questions
- propose a set of tasks or plan on how you intend to go about achieving this feature first.

once i agree to the plan, i want you to write down a detailed checkpoint document in @.ai/plans/ctc-add-rule.md

I captured my prompts but wasn’t diligent about surfacing them in pull requests; here are a few I did capture:

Here’s a PR where midway I captured a major feature change: the original version of the add-on used a very different way of capturing the rules. It wasn’t as intuitive, so I decided to change it up.
This was more a fun one where I asked it to critique the code as an HN reader would. Some good suggestions came out of it, but the explicit persona callout didn’t generate anything helpful in this specific case.

The code is open source, so go ahead and check it out.

About the add-on itself #

In my last post, How to Firefox, I covered “Privacy power-up: Containers”.⁶ “Containers” let you log in to multiple Gmail accounts without separate browser profiles. Add Total Cookie Protection and you get strong isolation.

That’s great, but managing it automatically gets tedious fast. Examples:

Keep google.com searches in one container, but open result links in my default container.
From work Gmail, clicking a GitHub link: if it’s github.com/instacart, open in Work; if it’s github.com/kaushikgopal, open in Personal.
In Google Docs (Personal), clicking a Sheets or Drive link should stay in Personal — even though my default for Sheets is Work.

Added these test cases

I realized while writing this post I should probably have these exact use cases tested, so I did just that right now… as I continued to flush out this post.

You can’t achieve this level of control with default containers unless you micromanage every case — and even then, some are impossible. I tried various add-ons but kept hitting cases that just wouldn’t work.

So I built my own. I also prefer how this add-on asks you to set up rules:

Overall, I enjoyed the experiment. I’ve been happily using my add-on, and I feel confident that if I needed to make changes, I could do it in what I consider a maintainable codebase.

Stay tuned for my tips on how you can use AI coding more constructively.

vibe-coding vs vibe-engineering

Simon Willison started using the term vibe-engineering for precisely vibe-coding with this level of rigor. I’m trying to adopt this more. You can read more about this distinction in my follow up post.

The bulk took a few hours; the rest was tweaks between other work. ↩︎
Google’s new 🍌 model. ↩︎
which I don’t for a second deny exist. ↩︎
I intentionally am not using the term vibe-code here. ↩︎
Honestly, the work put together was probably a few hours. I was issuing commands mostly on the side and going about my business, coming back later when I had time to tweak and re-instruct. ↩︎
I’ve since updated the post to point to my new Firefox add-on. ↩︎

Terminal command that tells you which USB-C cable is bad

Tue, 16 Sep 2025 03:50:45 GMT

now includes macOS Tahoe support

Apple slightly altered the system command for Tahoe

You have a drawer full of USB cables. Half are junk that barely charge your phone. The other half transfer data at full speed. But which is which?

Android Studio solved this. Recent versions warn you when you connect a slow cable to your phone:

developers.android.com

I wanted this for the command line. So I “built”¹ usbi, a script to check your USB connections.

The script parses macOS’s system_profiler SPUSBHostDataType² command, which produces a dense, hard-to-scan raw output:

With a little bit of scripting, the output becomes much cleaner:

When I connect my Pixel³:

Quick notes on the vibe-coding experience #

The first version was a bash script I cobbled together with AI. It worked, but was a mess to maintain. Because I let AI take the wheel, even minor tweaks like changing output colors were difficult.

Second time around, I decided to vibe-code again but asked AI to rewrite the entire thing in Go. I chose Go because I felt I could structure the code more legibly and tweaks would be easier to follow. Go also has the unique ability to compile a cross-platform binary, which I can run on any machine.

But perhaps the biggest reason is, it took me a grand total of 10 minutes to have AI rewrite the entire thing. I was punching through my email actively as Claude was chugging on the side.

Two years ago, I wouldn’t have bothered with the rewrite, let alone creating the script in the first place. The friction was too high. Now, small utility scripts like this are almost free to build.

That’s the real story. Not the script, but how AI changes the calculus of what’s worth our time.

yes, vibe coded. Shamelessly, I might add. ↩︎
prevoius versoins of macOS used SPUSBDataType ↩︎
I had Claude pull specs for the most common Pixel phones. I’ll do the same for iPhones if I ever switch back. ↩︎

Google still knows how to really swag

Fri, 01 Aug 2025 23:38:42 GMT

Google still knows how to really swag

reclaiming em-en dashing back from AI and lowercasing

Mon, 28 Jul 2025 03:18:36 GMT

AI is transforming our tools, our writing, and — apparently now — our sense of typographic originality. But there are two quirks of my writing that now get me side-eye from friends:

em and en dashes
predominant lowercasing

I know, i know. nobody likes the guy who says he liked the band before they got famous. but here we are.

I was lowercasing and em-en dashing before AI and i’d like to claim this back please. my friends roll their eyes when i try. even the polite ones. so, since i can’t get a word in at dinner, i’ll do it here.

But first, receipts… #

I need to build some credibility before I attempt to explain myself. one of the advantages of writing this blog for some time now: I can do a quick git log -S¹ and show you some early mention of these “quirks”:

The earliest post I have here using an em dash is from 2017.

blog post from 2017 where i use an em dash 😎. click for proof

might I remind you, ChatGPT was introduced to this world in 2022.

And now the more egregious one that Sam Altman is attempting to rob me of²:

from an old version of my blog from 11 years ago

Reclaiming my quirks #

em & en dashes #

listen folks, — & – are beautiful characters that the english language provides us. Strunk & White, who wrote a once seminal guide have this to say:

A dash is a mark of separation stonger than a comma, less formal than a colon, and more relaxed than parentheses…

we cannot let the AI overlords claim these characters theirs. I have a proposal:

Put spaces around your em and en dashes.

you see when AI genereates text, it tends to do the typographically standard thing—not pad the dash with spaces, like i just demonstrated. but if you did pad it with spaces — it becomes a stylistic choice, and adds visual rhythm to boot.

we can now use em and en dashes and prove that ChatGPT didn’t write this!

about the lowercasing #

I’ve mentioned my rsi before and even the crazy keyboard hacks to help me with it. one important one is mapping caps-lock to escape. if i have to capitalize my characters often, that’s my pinky painfully stretching to one of the ⇧ (shift) keys while typing the character with the other hand. no bueno for me.

i now implore you: let’s normalize not calling people typing in all lowercase as AI zealots proving their humanness.

yeah, i know this one is a stretch. but my fingers will click-clack their way through the shame.

very cool git trick to search your history, by the way. yes, I was desperate to find the evidence. ↩︎
The eagle eye will notice that I sometimes use proper punctuation. this is purely accidental or most likely my Mac auto-correcting my away. ↩︎

Getting Into Flow State with Agentic Coding

Wed, 23 Jul 2025 07:15:47 GMT

I recently found myself in a deep state of flow while coding — the kind where time melts away and you gain real clarity about the software you’re building. The difference this time: I was using Claude Code primarily.

If my recent posts are any indication, I’ve been experimenting a lot with AI coding — not just with toy side projects, but high-stakes production code for my day job.

I have a flow that I think works pretty well. I’m documenting it here as a way to hone my own process and, hopefully, benefit others as well.

Skeptics vs cynics

Many of my friends and colleagues are understandably skeptical about AI’s role in development. That’s ok. That’s actually good. We should be skeptical of anything that’s upending our field with such ferociousness. We just shouldn’t be cynical.¹

Step 0: Set the stage #

You know what’ll definitely get you out of the flow? Having to constantly repeat basic instructions to your agent.

"This is an Android app that does X, using the Y architecture…"
"When styling the front end web client, only use tailwind css v4…"
"Use `make test` to run a single test; `make tests` to run the entire test suite…"
"To build the app without running lint use `make`…"
…

These are all very important instructions that you shouldn’t have to repeat to your agent every single time. Invest a little upfront in your master ai instructions file. It makes a big difference and gets you up and coding quickly with any agent.

trivial to get started with claude /init these days

Of course, I also recommend consolidating your ai instructions to a single source of truth, so you’re not locked in with any single vendor.

Step 1: Plan with the Agent #

Update:

Checkout my post ExecPlans. I now use OpenAI’s Aaron Friel ExecPlans approach for this.

I won’t lie. The idea of this step did not exactly spark joy for me. There are times where I plan my code out in a neat list, but rarely. More often than not, I peruse the code, formulate the plan in my head and let the code guide me. Yeah, that didn’t work at all with the agents.

Two phrases you’ll hear thrown around a lot: “Context is king” and “Garbage in, garbage out.” This planning phase is how you provide high-quality context to the agent and make sure it doesn’t spit garbage out.

After I got over my unease and explicitly spent time on this step, I started seeing dramatically better results. Importantly, it also allows you to pause and have the agent pick up the work at any later point of your session, without missing a beat. You might be in the flow, but if your agent runs out of tokens, it will lose its flow.

Here’s my process:

All my plans live in an .ai/plans/ folder. I treat them as fungible; as soon as a task is done, the plan is deleted.
Say I’m working on a ticket JIRA-1234 and intend to implement it with a stack² of 4 PRs.
Each of those PRs should have a corresponding one plan file: JIRA-1234-1.md, JIRA-1234-2.md, etc.
The plan (and PR) should be discrete and implement one aspect of the feature or ticket.
Of course, I make the agent write all the plans and store it in the folder. (I came this far in my career without being so studious about jira tasks and stories; I wasn’t about to start now).

This is the exact prompt I use:

You are an Expert Task Decomposer. Your entire purpose is to break down complex goals, problems, or ideas into simple, clear, and actionable tasks. You will not answer my request directly; you will instead convert it into one or more execution plans.

You **MUST** follow this three-step interactive process without deviation:

**Step 1: Propose a Task List.**
First, analyze my request and generate a concise, numbered list of the task titles you propose to create. Your first response to me must ONLY be this list. Do NOT write the full plans yet.

For example, if my request is "I want to create a simple blog," your first response should be something like:
"Understood. I propose the following tasks:
1. Choose and Purchase a Domain Name
2. Set Up Web Hosting
3. Install and Configure Content Management System (CMS)
4. Design and Customize Blog Theme
5. Write and Publish First Three Blog Posts"

**Step 2: Await User Approval.**
After presenting the list, **STOP**. Wait for my explicit confirmation. I will respond with something like "Proceed," "Yes," or request modifications. Do not proceed until you receive my approval.

**Step 3: Get Filename Format & Generate Plans.**
Once I approve the list, you will ask me for the desired filename format. For example: "What filename format would you like? (e.g., `<YYYY-MM-DD>-<TaskName>.md`, `Task-<ID>.txt`)"

After I provide the format, you will generate the full, detailed execution plan for EACH approved task. Each plan must be created in a separate, single file, adhering strictly to the `## OUTPUT FORMAT` specified below.

The files should be created in a @.ai/plans folder. If this folder doesn't exist, ask the user where they need to create it.

---

## OUTPUT FORMAT

Use the following markdown template for every plan you generate:

# Task: [A concise name for this specific, atomic task]

**Problem:** [Briefly explain what this specific task is solving or achieving.]

**Dependencies:** [List any other tasks that must be completed first. Write "None" if there are no dependencies.]

**Plan:**
1. [Clear, explicit Step 1 of the plan]
2. [Clear, explicit Step 2 of the plan]
3. ...

**Success Criteria:** [A simple checklist or a clear statement defining what "done" looks like for this specific task.]

---

## CRITICAL RULES

- **Atomicity:** Each task must be a single, focused unit of work. If a step in a plan feels too large, it should likely be its own task. Err on the side of creating more, smaller tasks rather than fewer, complex ones.
- **Clarity:** Write instructions that are explicit, unambiguous, and can be executed by someone without needing any additional context.
- **Strict Adherence:** The interactive workflow is not optional. Always propose the task list first and await my approval before asking for the filename and generating the plans.

Begin now. My first request is:

I have this prompt saved as a “plan-tasks.md” command in my .ai/commands folder so I don’t have to type this all the time.

What follows now is a clean back-and-forth conversation with the agent that will culminate with the agent writing down the task plan. Sometimes I may not understand or agree with the task or sequencing, so I’ll ask for an explanation and adapt the plan. Other times I’m certain a task isn’t needed and I’ll ask for it to be removed.

This is the most crucial step in the entire process.

A note on software engineering experience

If the future of software engineering is going to be AI reliant, I believe this planning step is what will distinguish the senior engineers from the junior ones. This is where your experience shines: you can spot the necessary tasks, question the unnecessary ones, challenge the agent’s assumptions, and ultimately shape a plan that is both robust and efficient.

I intently prune these tasks and want them to look as close to the sequence I would actually follow myself. To reiterate: the key here is to ask for the plan to be written so that another agent can execute it autonomously.

Step 2: The Fun Part - release the Agents! #

After committing all the plans (in your first PR), the real fun begins and we implement JIRA-1234-1.md.

You would think my process now is to spawn multiple agents in parallel and ask them to go execute the other plans as well. Maybe one day, but I’m not there yet. Instead, I start to parallelize the work around a single task.

Taking JIRA-1234-1.md as an example, I’ll spawn three agents simultaneously:

Agent 1: The Implementer. Executes the core logic laid out in the plan.
Agent 2: The Tester. Writes meaningful tests for the functionality, assuming the implementation will be completed correctly.
Agent 3: The Documenter. Updates my project documentation (typically in .ai/docs) with the task being executed.

I want you to execute the plan I provide by spawning multiple agents.

But before you start the work:
- Go through the plan, analyze it and see how it applies to the project.
- Come up with your execution steps
- Confirm the strategy with me
- After i confirm, start execution.


Three agents need to do the work.

1. **Agent 1: The Implementer.** Executes the core logic laid out in the plan.
2. **Agent 2: The Tester.** Writes meaningful tests for the functionality, assuming the implementation will be completed correctly.
3. **Agent 3: The Documenter.** Updates my project documentation (see /my-feature/README.md in `.ai/docs`) with the new feature being executed.

Assume the other agent will complete the work successfully.

Notice that with this approach, the likelihood of the agents causing merge conflicts is incredibly slim. Yet, all three tasks are crucial for delivering high-quality software.

This is typically when I’ll go grab a quick ☕. When I’m back, I’ll tab through the agents, but I spend most of my time with the implementer. As code is being written, I’ll pop open my IDE and review it, improving my own understanding of the surrounding codebase.

Sometimes I might realize there’s a better way to structure something, or a pattern I’d missed previously. I don’t hesitate to stop the agents, refine the plan, and set them off again.

Eventually, the agents complete their work. I commit the code as a checkpoint (I’m liberal with my git commits and use them as checkpoints).

Step 3: Verify and Refactor #

I run the tests, and more often than not, something usually fails. This isn’t a setback; it’s part of the process. I analyze whether the code was wrong or the test was incomplete, switch to that context, and fix it.

Refactor aggressively

This is also where I get aggressive with refactoring. It’s a painful but necessary habit for keeping the codebase clean. I still lead the strategy, devising the plan myself, and then direct the agent to execute it or validate my approach. While it usually agrees (which isn’t always comforting 🙄), it can sometimes spot details I might have otherwise missed.

Once I’m satisfied and the checks pass, I do a final commit and push up a draft PR.

Step 4: The Final Review #

I review the code again on GitHub, just as I would for any other PR. Seeing the diff in a different context often helps me spot mistakes I might have missed in the IDE. If it’s a small change, I’ll make it myself. For anything larger, I’ll head back to the agents.

All the while, I’m very much in the flow. I may be writing less of the boilerplate code, but I’m still doing a lot of “code thinking”. I’m also not “vibe coding” by any stretch. If anything, I’m spending more time thinking about different approaches to the same problem and working to find a better solution. In this way, I’m producing better code.

I’ve been building like this for the past few weeks and it’s been miraculously effective. Deep work beats busywork, every time. Let agents handle the gruntwork, so you can stay locked in on what matters most.

lest we get swept by this tide vs surfing smoothly over it ↩︎
I absolutely love deconstructing a feature into multiple stacked PRs. ↩︎

Introducing “shorts” for Henry (my Hugo blog engine/theme)

Sun, 20 Jul 2025 00:00:00 GMT

Introducing “shorts” for Henry (my Hugo blog engine/theme).

Often, I find myself wanting to post a quick thought or note without the ceremony of a full-blown “blog post”. That’s usually when I’d post to Bluesky, X, Threads, or Mastodon.

But as I’ve said before, I prefer investing in a feed I control. With Henry, I can effortlessly post a quick thought, and share it from a feed I own.

🦊 How to Firefox

Fri, 18 Jul 2025 00:00:00 GMT

Chrome finally pulled the trigger on the web’s best ad-blocker, uBlock Origin.

Now that Chrome has hobbled uBO, Firefox — my beloved —¹ is surging again. I want to do my part to convince you to switch to Firefox and show you how I use it.

Why Firefox #

Let’s get through the important talking points, in case you need a quick copy paste to convince a friend.

100% open-source
Un-enshittify the web
Android users rejoice
Customize to your heart’s content

100% open-source #

This section can be quick.

Here’s a github link to the source code of the Firefox browser. You can clone the repo, pop open your favorite AI code assistant and start asking questions about your browser - the most important app you use.

What libraries does their Android app use? libs.versions.toml boom! Also 8.11.1 on android gradle plugin? not bad Firefox.

Their license allows you to fork and distribute alternative versions. Vibe code a whole new browser.

Un-enshittify the web #

Most of the web today is enshittified with a cesspool of ads, popups, cookie notices, and tracking scripts. Our primary defense has been ad-blockers, with the most powerful being uBlock Origin.

uBO relies on community-curated filter lists that play a cat-and-mouse game to zap known ads, trackers, and other digital sludge. But with Chrome controlling the web, Google followed through on its promise to kneecap uBO with Manifest V3, effectively blocking the full version from its extension store.

Sure, there’s uBlock Origin “Lite” now, which does the same thing, right? Nope:

uBlock Origin Lite != uBlock Origin

Filter lists update only when the extension updates
- no fetching up to date lists from servers (this is a big one!)
No custom filters
- so no element picker which allows you to point and zap
Many filters are dropped at conversion time due to MV3’s limited filter syntax
No strict-blocked pages
No per-site switches
No dynamic filtering
No importing external lists

Did you know, uBlock Origin works best on Firefox. Why not just use the real thing then? My browsing experience is beautiful because I have most of the shit-bits blocked away.

On my Pixel too.

Android users rejoice #

With Firefox for Android, you get seamless sync of tabs, bookmarks, passwords between browser and phone.² Let’s face it, Safari between Mac and iPhone is a sublime experience. We can get that with Firefox.

Real browser extensions for mobile #

Here’s something the iPhone isn’t getting anytime soon: honest-to-god browser extensions that you use on your desktop, also on your phone. Which means… you can run uBlock Origin on Android, completely unnerfed.

Safari has extensions, but they still require an App Store review for distribution on Apple platforms. They also just got a version of the uBO “Lite” extension.

Customize to your heart’s content #

But… Firefox doesn’t look as clean and minimal as Safari. You can claw the vertical tabs out of my cold dead Arc hands!

This is what my Firefox browser looks like:

well akkva's of gwfox-css technically

It only takes about five minutes and a browser restart to get this look.

My Firefox Setup #

I’ll walk you through my setup now, from essential add-ons to privacy tweaks and a few “nice-to-have” extras.

Nerd Alert

This is my setup. I’m a nerd, so I find joy in tinkering. You don’t need to do all of this, but a few small tweaks can give you a massively better browser.

The Essentials: uBlock Origin #

Think of uBO as a powerful, wide-spectrum filter for the web. It uses community-maintained lists to block ads, trackers, cookie notices, and other digital sludge before it ever loads. Your browser stays faster and cleaner.

It can be confusing to know which filter lists to enable. I follow the advice of a uBO wizard on Reddit, and these settings alone make the web 90% better. Check the same boxes, and you’re good to go.

You're completely set with this.

Custom Filters are an exclusive uBO superpower

The “My filters” tab is where you can write your own rules to block nearly anything, from annoying widgets to entire domains.

Block outgoing network traffic to Facebook #

For the truly privacy-conscious, uBO can block all outgoing traffic to specific domains, like Facebook.³ In the past, Firefox’s Facebook Container add-on helped by isolating your Facebook activity. But if any other site embedded a Facebook widget or tracker, your data could still leak to Meta’s servers, fingerprinting you even if you never visit Facebook directly.

With a custom uBO rule, you can sever that connection entirely from non-Facebook sites. This is a level of control other browsers don’t offer.

uBO custom filter: courtesy the reddit wizard fsau again

The other line you see there? That one-liner blocks all those “Sign in with Google?” pop-ups. This granular control is only possible with the full uBlock Origin, not the “Lite” version found on other browsers.

If you want to go deeper, this video is a great showcase of its advanced capabilities.

Privacy power-up: Containers #

Firefox now includes Total Cookie Protection (TCP) by default. This automatically isolates cookies to the site that created them, giving each site its own “cookie jar”. Importantly it means sites aren’t allowed to read cookies from other site’s jars. This stops trackers from following you across the web.

Firefox first piloted this feature as the Multi-Account Containers (MAC) add-on. But with TCP, the containers feature is somewhat redundant for basic anti-tracking.

However, the container technology is still incredibly useful if you want to seamlessly manage multiple online identities. Instead of juggling separate browser profiles, you can use “Containers” to stay logged into two different Gmail accounts (e.g., “Work” and “Personal”) in the same browser window, with zero overlap.

The old MAC add-on made this possible, but it was really clunky to setup. It’s actually much easier to do this today without installing an additional add-on.

go to about:config
set privacy.userContext.newTabContainerOnLeftClick.enabled to true

That’s it. This works without the extra MAC add-on because the Container concept is baked natively into Firefox. So with the above config tweaks, you enable the default built-in containers and whenever you click the new tab button, you can choose which container to open. You can now open gmail in these containers and it’s as if you’re opening an entirely new browser.

even more control? #

But what about links? A work link (like Datadog or Sentry) clicked from your email in a Work container, might open in the default container and use the wrong Google account. You could right click the link and say “Open in Container >” but that gets old fast. Wouldn’t it be nice if you could give Firefox a set of rules and say, always open these websites or URLs in these containers? and everything just worked magically?

I created the firefox add-on Container Traffic Control to help with that exact requirement. It’s open source and pretty well documented + tested.

This combination of the native config tweak and my add-on provides a simple, but more powerful multi-profile setup (than even MAC).

Gravy add-ons #

These are also not essential, but they add a nice layer of polish.

Dark Reader: For a consistent, customizable dark mode on every site.
Stylus: To apply custom CSS. I use it to force my on code blocks.
Return YouTube Dislike: Does what it says on the tin.
Obsidian Web Clipper: To save notes and clippings directly to Obsidian, from desktop or mobile.
Auto Tab Discard: Suspends background tabs to save RAM. A holdover from my RAM-strapped MacBook days, but it still does its job silently.

Other Customizations #

Firefox is famously customizable via about:config. Besides the container tweak, I only use one other:

`browser.tabs.insertAfterCurrent` → `true` #

New tabs open next to your current tab, not at the end.
You catch that Mr.Gruber?

Hidden Gems #

I’m collecting in this section, some of the cooler Firefox features that’ll make you wonder why every browser doesn’t have them:

Type / and start typing for quick find (vs ⌘F). But dig this, ' and Firefox will only match text for hyper links⁴
If you have an obnoxious site disable right click, just hold Shift and Firefox will bypass and show it to you. No add-one required.
URL bar search shortcuts: * for bookmarks, % for open tabs, ^ for history

The web can still be beautiful. You just need the right tools to see it. Go download Firefox and make your web beautiful again.

If you try this setup or have suggestion, let me know in the comments.

No, goddammit, AI didn’t write this post. ↩︎
For the few who have reached this point of the article and furiously questioned why I don’t just use Zen browser or Libre. ↩︎
You can of course send outgoing traffic from Meta owned websites so Threads etc. still work. ↩︎
Seriously, try the apostrophe trick. It’s a game-changer for keyboard navigation. ↩︎

AI Programming Paradigms: A Timeline

Tue, 08 Jul 2025 00:00:00 GMT

A developer podcast host recently said they only use AI for autocomplete. This shocked me.

That’s two generations behind today’s state of the art. This is how the field is evolving:

I spoke about this topic in episode #301 of Fragmented. It was recorded more recently so reflects my more current thoughts on the topic.

Download directly

AI Programming Paradigms at a Glance

Super autocomplete: AI predicts code, not just keywords.
Conversational Coding: Chat with your IDE, direct the AI, iterate together.
Agentic Coding: AI acts independently - runs commands, checks work, iterates.
Simul Agentic? : Multiple sub-agents, parallel workflows, working together.

I. Super autocomplete #

This used to be one of the biggest selling points of certain IDEs like JetBrains & Visual Studio.¹

The first wave of AI changed this. IDEs now predict entire classes and logic blocks, not just keywords. They excel because they feed surrounding code context to the LLM for relevant suggestions.

GitHub deserves credit for kicking off the revolution with their Copilot offering. Here’s an early YouTube video of mine from June 2022² showing it in action.

Autocomplete keeps advancing. Cursor (today’s most popular AI IDE) has “Tab”. JetBrains, the pre-AI autocomplete champion, is building Mellum (an LLM built for code completion).

This paradigm is alive and well, but it’s become table stakes. Most developers use it, but it’s far from the frontier.

II – Conversational Coding #

When ChatGPT took the world by storm, a new paradigm emerged. Conversational coding, where you chat with the AI and pair program together.

Unlike the autocomplete era, where you trust the AI’s suggestions, here you direct the AI, give it context, and nudge it toward better solutions. This is arguably what most devs use today and envision when they hear “AI programming”.

It feels magical, productivity jumps are real, and it’s hard to think of every going backwards. Cursor leads this charge: chat with your IDE and have it make code changes on the fly.

The challenge with conversational coding though is IDE lock-in. Android developers love Android Studio, iOS developers love Xcode. Asking them to switch to Cursor is a big ask. There are workarounds: Firebender offers Cursor-like functionality to existing IDEs, JetBrains has Junie (though they’re late to the party), and Xcode developers… well, they wait for Apple.

This constraint is why the next paradigm is starting to shine.

III – Agentic Coding #

This is the bleeding edge.

Agentic coding works anywhere you can run commands. Pop open a terminal, fire up Claude Code, and let it work independently. The AI comes up with a plan, confirms the plan, makes changes, runs tests, fixes errors — all through your existing CLI tools.

Claude dominates here. The TUI feels retro but works brilliantly for terminal-heavy development. You give the agent a task. It runs commands, checks results, iterates. The feedback loop is tight: ask, execute, verify, repeat.

The space is exploding. Google’s Gemini CLI runs on Gemini 2.5 Pro with aggressive pricing.³ Cursor too has a similar take that they call background agent mode. There’s also agentic tools outside of the terminal like Jules (Google) and Codex (OpenAI) that run cloud agents with GUIs. But Claude nails the terminal workflow imho.

The core idea for agentic coding is the same: let the AI act on its own, not just suggest.

So what’s next?

IV – Simul Agentic Coding #

My guess: we’ll move from mono agentic coding to multi sub-agent workflows.

Claude can already do this today.⁴ Think of a chess master playing a (simul)taneous exhibition match: multiple agents building features in parallel, coordinating to avoid merge hell, and you at the center, reviewing each PR in its own tab.

The field evolves at breakneck speed. By the time you read this, this might feel like a mainstay. Revolutionary becomes quaint in two years. Today’s cutting edge is tomorrow’s baseline.

What About Vibe Coding? #

Ah, the million-dollar question. Where does vibe coding fit?

Andrej Karpathy (AI Programming Yoda) coined this term. But vibe coding isn’t a paradigm, it’s a style. It’s about trusting the AI to make big decisions with minimal guidance. You can apply it to any paradigm above, but the vibe gets strong in collaborative and agentic modes.

If you’re a programmer wondering where to invest today: don’t get too attached to one specific tool. Try them all liberally. Start getting conversant. It’s too early to say which tool or paradigm will dominate, but AI programming is inevitable and will probably just be what we call programming.

not that one. see intellisense. ↩︎
Over 2.5 years ago! This is what I mean by “2 generations behind” (in AI development time, each year seems to bring a fundamental shift in how we interact with these tools). ↩︎
Google is offering 60 requests per minute and 1,000 requests per day completely free. For context, Claude’s Pro plan at $20/mo gives you roughly 10–40 prompts every 5 hours. ↩︎
instruct it specifically to “use sub-agents for this workflow”. ↩︎

Keep your AGENTS.md in sync — One Source of Truth for AI Instructions

Thu, 03 Jul 2025 22:22:12 GMT

Getting useful results from your AI assistant often comes down to the instructions you give it. Most developers treat that step casually, then wonder why the output is mediocre.

One of the simplest ways¹ to improve this is to keep one set of master instructions in an AGENTS.md file. In it, you define persistent rules that shape every interaction with the agent.

Writing those instructions once is easy enough. Keeping them in sync is the annoying part.

If you use more than one tool, things drift fast. So I keep one repo as the source of truth for my AI setup, then wire my tools and projects back to it.

This post is the simple version of that setup.

Good news

Most coding tools have since consolidated around AGENTS.md as the standard. That makes this much simpler than it used to be.

How I organize my AI instructions #

I keep my setup at two levels:

User-level instructions: my personal defaults that I want available everywhere
Project-level instructions: the rules and context that only apply to one repo

User level: one source of truth #

I keep my shared AI setup in a single repo. That repo holds the things I want to maintain in one place:

AGENTS.md
reusable skills/
reusable commands/
compatibility shims like CLAUDE.md

Then I wire my local tools back to that repo with one command from the repo’s Makefile:

make setup

That command creates the symlinks for me. I am not updating the same instructions by hand for Claude, Codex, and OpenCode. I edit the shared files once in my repo, and the tools point back to them.

At the user level, I keep it direct. The repo is the source of truth, so the tool-specific paths symlink straight to it. For example:

~/.claude/agents -> ~/my-local-directory/aikado/agents
~/.config/opencode/agents -> ~/my-local-directory/aikado/agents

So the maintenance story is simple:

keep shared defaults in one repo
symlink tools back to that repo
edit once

Project level: thin local scaffolding #

For each codebase, I still want a project-local AGENTS.md and a place for project-specific assets.

So when I start a new repo, I run the project setup target from that same Makefile:

make setup-project dir=~/dev/oss/some-repo

That command creates the local directories and symlinks, and the result looks like this:

AGENTS.md
CLAUDE.md
.agents/
 agents/
 skills/
 commands/
 plans/
 tmp/
.claude/
 agents -> ../.agents/agents
 commands -> ../.agents/commands
 skills -> ../.agents/skills
.opencode/
 agents -> ../.agents/agents
.codex/
 prompts -> ../.agents/commands

The role of each piece is straightforward:

AGENTS.md: the main instructions for this project
CLAUDE.md: just points Claude back at AGENTS.md
.agents/agents/: project-specific agents shared by Claude and OpenCode
.agents/skills/: project-specific skills
.agents/commands/: project-specific reusable commands
.agents/plans/: execution plans for larger work
.agents/tmp/: scratch output for the current session

That gives me a clean split:

shared behavior lives in my AI repo.
project-specific behavior lives in the project’s AGENTS.md and .agents/

I do not force the exact same structure at both levels.

at the user level, direct symlinks are simpler
at the project level, .agents/ gives me one obvious place for agents, skills, commands, plans, and temp files

Generating your first AGENTS.md

If you do not already have a good project AGENTS.md, start with an init command that analyzes the repo and writes a first draft. I use a custom /initialize command for this.

Nested AGENTS.md

Most AI tools support nested AGENTS.md files. If one subdirectory needs extra instructions, add another one there and keep the root file lean.

Claude still needs a shim

Most tools now read AGENTS.md directly. Claude still wants CLAUDE.md, so I keep a tiny compatibility file that just says See @AGENTS.md.

Fine-Tuning Your Rules #

To see what context your AI is actually using, ask it: “What custom instructions or context files are you currently using for this project?” Use that feedback to prune redundancy and clarify ambiguous rules.

Revisions #

2026-03-08:
- clarify that user-level setup keeps direct symlinks to the aikado repo
- document the shared project-local .agents/agents directory
2026-03-07:
- simplify the post around the current aikado workflow
- clarify that shared instructions, skills, and commands live in one source of truth repo
- focus the setup story on make setup and make setup-project
2026-02-17: add OpenCode instructions (natively reads AGENTS.md and .agents/skills/)
2026-02-09: migrate .ai → .agents (and update symlink examples)
2026-01-02:
- skills is now an open standard
- cleaned up old instructions for clarity
2025-10-12: removing artifacts (then .ai/): rules, checkpoints, docs
- the notion of ExecPlans makes more sense than checkpoints
- AGENTS.md should have instructions, README.md should have docs
- rules should be incorporated into the AGENTS.md file
2025-09-18: switch to AGENTS.md as more tools consolidate around it

I wrote a later post distilling the three things that matter most for getting good AI coding results. ↩︎

AI won't replace good engineers - it'll make them invaluable

Sat, 21 Jun 2025 00:00:00 GMT

I just read a good piece by the Nilenso crew on AI-assisted coding for teams that can’t get away with vibes.

Blog post title aside, it helped me synthesize my own thoughts better on a question that keeps coming up: will AI replace all software engineers?".

Not only won’t it replace us, it’ll make the best engineers even more valuable.

Here’s why.

AI amplifies what you already have #

AI is a multiplier.

To make AI good, get good yourself. AI is a multiplier. If you are a small coefficient, you won’t see much gain. If you are a negative coefficient, expect negative gains.

🎯. The best engineers extract far more value from AI tools. Why? Because they already have the fundamentals that AI needs to work with:

They communicate technical ideas clearly - AI responds to good prompts, and good prompts require clear thinking.
They have “the mechanic’s touch” - that intuitive sense for what makes good systems work. They steer AI toward better solutions.
They have strong fundamentals - they can quickly evaluate AI suggestions and know when something’s off.
They have taste - AI mirrors your sensibilities. Experienced engineers get better results because they ask for better things.

I’ve seen this repeatedly. Give the same AI tool to a junior and senior engineer. The senior gets dramatically better results. Not because they’re smarter, but because they know what questions to ask.

What helps humans helps AI #

Here’s where it gets interesting. From the article:

Messy code confuses AI too

Our AI coding assistant struggled to complete a task of equal difficulty on the latter codebase when compared to the former! This is likely because the messier codebase was as confusing for the AI as it would be for a human.

Clean architecture, good naming, clear patterns - everything that makes codebases maintainable for humans also makes them effective for AI.

So if you want to be more effective with AI, you still need all the craftsmanship skills that good software engineers have always needed. The fundamentals matter more now, not less.

The craftsmen still matter.

Software engineering was never just about coding #

writing isn’t a wrist exercise with ink on paper

Software engineering is not about writing code. Or at least, that’s not the defining characteristic, much like how writing is not wrist exercises with ink on paper.

The real value has always been in the decisions: what to build, how to architect it, when to make tradeoffs, why a particular approach makes sense. The actual typing? That’s just execution.

AI is getting scary good at execution. But judgment calls (understanding context, business requirements, user needs, system constraints) — that’s still very much human territory.

my take on above

and by this definition I think LLM AIs will systematically replace coding first, programming next (😢) and software engineering last.

so to remain relevant in this new world, imho become a stronger software engineer.

I’ll leave you with quote from an article that Simon Willison[^sw] wrote:

LLMs are no replacement for human intuition and experience.

I’ve spent enough time with GitHub Actions that I know what LLMs are no replacement for human intuition and experience. kind of things to look for, and in this case it was faster for me to step in and finish the project rather than keep on trying to get there with prompts.

Simon maintains the llm cli project and a voice you should be following to keep abreast of all the AI news around software engineering.

Configure Karabiner with ease (& Kotlin)

Sat, 17 May 2025 20:23:40 GMT

If you’re obsessed with productivity hacks, you’ve probably heard of Karabiner – the ultimate tool for keyboard customization on macOS. But maintaining Karabiner’s config is a pain. In this post I’ll show you a simpler, Kotlin-powered way to wrangle your Karabiner setup, so you don’t have to wrestle with massive, unwieldy JSON.

On Karabiner #

Here’s the gist: Karabiner lets you intercept any keystroke and remap it to… well, pretty much anything. Want to turn Caps Lock into a Hyper key? Make your keyboard launch confetti? It’s all possible.

Take the classic usecase: remap Caps Lock to Hyper (⌘⌥⌃⇧) when held, Escape when tapped. That’s easy to do but just scratches the surface. With Karabiner, you can build many more customizations that supercharge your workflow.

Maintaining that karabiner.json #

I was watching a video by Max Stoiber where he uses Raycast¹ & Karabiner. But what struck me was how he customized and maintained his karabiner setup.

Karabiner runs off a single .json config file. But that .json configuration can become unwieldy and difficult to manage, as your rules grow in complexity. For example: I require a ~2700 line .json for all my hacks. It’s impossible to maintain it as pure json.

Max uses TypeScript to maintain his rules -which then compiles down to a .json file- that Karabiner can consume. I really like this approach. If you read my previous blog post, I also ran into a very similar problem and used goku, which in turn used the very esoteric and terse edn format.

I like TypeScript over edn but you know what I’d like even better? Kotlin! So on a ✈️ ride back home, I decided to whip up karabiner-kt.

I’m really happy with my solution. Kotlin affords a much more pleasant DSL than most other² languages.

Here’s what a Karabiner rule looks like in Kotlin :

karabinerRule {
 description = "Right Cmd -> Ctrl (Enter alone)"
 mapping {
 fromKey = RightCommand
 toKey = RightControl
 toKeyIfAlone = KeyCode.ReturnOrEnter
 forDevice { identifiers = DeviceIdentifier.APPLE_KEYBOARDS }
 }
},

Clean, expressive, and type-safe!

Or here’s a fun one. Hold the “O” key and tap “0” for showing the Raycast Confetti:

karabinerRuleSingle {
 description = "O + 0 -> Raycast Confetti"
 layerKey = KeyCode.O
 fromKey = KeyCode.Num0
 shellCommand = "open raycast://extensions/raycast/raycast/confetti"
},

Here’s a slightly more complex modification: If I hold the “f” key and tap j/k, it types out an open and closed bracket respectively.

karabinerRule {
 description = "F-key layer mappings"
 layerKey = KeyCode.F
 // J K
 // ( )
 mapping {
 fromKey = KeyCode.J
 toKey = KeyCode.Num9
 toModifiers = listOf(LeftShift)
 }
 mapping {
 fromKey = KeyCode.K
 toKey = KeyCode.Num0
 toModifiers = listOf(LeftShift)
 }

 // M ,
 // [ ]
 mapping {
 fromKey = KeyCode.M
 toKey = KeyCode.OpenBracket
 }
 mapping {
 fromKey = KeyCode.Comma
 toKey = KeyCode.CloseBracket
 }

 // . /
 // { }
 mapping {
 fromKey = KeyCode.Period
 toKey = KeyCode.OpenBracket
 toModifiers = listOf(LeftShift)
 }
 mapping {
 fromKey = KeyCode.Slash
 toKey = KeyCode.CloseBracket
 toModifiers = listOf(LeftShift)
 }
}

Installation #

The repo is open source, so feel free to take a look and customize.

Getting started is easy. Here’s how to set it up from scratch:

# install karabiner-elements
brew install --cask karabiner-elements

# app uses a simple gradle app
brew install gradle

# let's clean up the karabiner folder if they existed
rm -rf ~/.config/karabiner
mkdir -p ~/.config/karabiner

# clone the repo
git clone https://github.com/kaushikgopal/karabiner-kt.git ~/.config/karabiner/karabiner-kt

Run the configurator #

Now every time you want to run the configurator:

cd ~/.config/karabiner/karabiner-kt
make

# you might have to do this once a while (if you restart your mac etc.)
make restart-karabiner

Try your own Rules! #

All your customizations live in Rules.kt. My own config is about 300 lines of Kotlin. Compare that to the monstrous 2736-line JSON it generates. 😅

You should start with a really simple setup and build your Rules over time. Give it a shot and let me know if you run into issues!

my launcher of choice. ↩︎
maybe TypeScript allows this but I understand Kotlin better ↩︎

Taildrop - transfer files between Android and MacOS

Thu, 01 May 2025 15:03:32 GMT

I use the Pixel 9 Pro as my daily driver and love it. But one notable feature I’ve always missed from the Apple ecosystem is AirDrop.

I typically have WhatsApp for Mac open and dump things there for quick access between devices. Clunky, but it worked.

Until I realized Tailscale — a VPN¹ that I love and use — has a feature called Taildrop. The name suggests it’s meant as an AirDrop competitor, and I’ve been super happy with it.

I can now send images uncompressed² to any of my devices. I’m not restricted by Bluetooth, proximity, or other limitations. Just need Tailscale running on the device.

Advantages #

Not limited to the Apple ecosystem #

Probably the highlight here is that Taildrop works on any device that supports Tailscale. So between a Pixel, iPhone, MacBook, Windows machine — no walls here.

Unlimited file size #

There’s no filesize limit. In all fairness, AirDrop doesn’t have one either.

Taildrive #

Another alpha feature they’re working on, similar to Taildrop, is Taildrive. It’s effectively a shared folder on the internet. If you’re on the same network (Tailnet), you can download files from this folder from anywhere.

This basically allows any folder on your device to become a mini NAS or file server. Bonkers!

Constraints #

It’s not all sunshine and rainbows though. There are some constraints and issues with Taildrop.

Can only send to yourself #

Even if you add another user to your Tailscale network, you can still only send files to yourself. I imagine this is still an early restriction, but the good news is that Tailscale is thinking about relaxing this over time (maybe).

This is clearly an area where AirDrop is superior since it can more conveniently allow you to send files to anyone nearby.

Note this doesn’t apply to Taildrive, just to Taildrop. With Taildrive, anyone on your Tailnet can access the shared files.

Can only send files #

AirDrop handles sharing URLs or links elegantly. Share a URL from your phone to computer, and it automatically opens in your default browser. You can’t share links with Taildrop yet.

It’s a little buggy #

When Taildropping from Android, I’ve noticed it occasionally caches the previous files that were sent. If you’re not carefully watching the preview, you can end up sending the wrong file.

In all fairness, Tailscale has labeled it as an alpha, so they get a pass on this. Their solutions are typically rock solid, so I fully trust when they graduate it from alpha, it’ll be production ready.

Despite these limitations, Taildrop has become an essential tool in my cross-device workflow. For Android users longing for AirDrop-like functionality, it’s worth setting up Tailscale for this feature alone. And if you’re already using Tailscale for other purposes, enabling Taildrop is a no-brainer.

VPN might conjure up a different picture here. Think of it simply as a secure tunnel to any of your other devices. ↩︎
One of the notable problems with my lazy WhatsApp strategy. ↩︎

Why I still podcast for Fragmented

Tue, 08 Apr 2025 14:58:03 GMT

When you’ve been doing a podcast for so long and it’s a pure labor of love –time and again– you start to ask yourself: why am I doing this again?

This is a note for myself and others, who sometimes worry about the podcast.

Positive listener feedback #

Probably, the single most influential reason for doing it is those 2 or 3 notes or messages I get over the year when someone says that the podcast helped change the course of their life as a developer.

I’ll be honest. I didn’t think that would be the reason, when I started. I couldn’t fathom it would have that effect on me if I’m being even more honest. But every time I’ve hit a slump, it takes one email, a YouTube comment or a random tweet or Bluesky post to just reinject that dose of enthusiasm I need, to keep going.

I’ve had some incredible people with incredible stories write to me saying - they didn’t have money to be a developer and they used the podcast to learn while they saved up to eventually buy a phone. The only phone they could buy was an Android one and that allowed them to build their very first app and get a job in the process. Some have even written about being the first person in their family to use a computer and become a mobile developer by listening to Fragmented. I’ve had folks tell me they managed to get the dream jobs of their life because of the topics we covered and them being able to get through interviews because of that knowledge. I’ve had others write in saying they got promoted as a mobile developer, because of ideas they got listening to the podcast landing the impact and convincing their bosses.

I’m really not trying to sound more important here but even getting one of those messages, even the simple thanks for doing this! immediately gives me a kick in the butt.

We’re all searching for purpose and meaning. Being able to help people in this small way is a privilege, I don’t take lightly.

My own learning #

But to say, I only do this for the people would be disingenuous. The second most important reason is my own learning.

Having to talk about a topic or even interview an expert requires me to research a topic to a level of depth where I need to be able to grok it. In my job at Instacart, I no longer am paid just to code,¹ but as my manager repeatedly tells me - my job is to make the right calls at the right time.

Fragmented has allowed me to do that better. I don’t know how much self motivation I’d have personally to research every single topic, just for the curiosity of it. I know others who do and I remain envious of them.

This is also one really good reason why I constantly encourage people to write more blog posts about topics they’ve learned or create content about it in some way. It doesn’t matter that one of the experts you know has already written about it. It doesn’t matter that Google has an indepth guide. What matters the most is explaining it through your voice and your own transformative learning through the process.²

Access to Android community #

Lastly of course, the podcast is the reason I personally have access to some of the best Android developers and folks at Google.

If I don’t know something or cannot understand a topic, I can usually reach out to the author or the people who wrote the framework and get an answer. Again, I fully recognize this privilege.

I’ve managed to chat with some incredibly smart people working at Google on Android OS because they recognize Fragmented.

Also, Fragmented is solely the reason I remain a GDE. Fragmented is the reason anyone in the community even recognizes my name. Funnily enough I’m mostly not recognized at Google I/O until I’m striking a conversation with someone, typically when I’m in a group with one of the other more famous faces, and people usually get the 💡 moment after hearing me converse with them for a few minutes.

It’s been the privilege of my life to keep working on Fragmented. Donn and I put in an incredible number of extra hours into it, but we also got really lucky and I cannot be more grateful to the listeners we have.

Fragmented hit its 10 year mark 🥲 somewhat recently.

It evolves in different shapes and forms. On its most recent iteration with Donn bowing out, I’ve switched to a seasonal approach. Research for sometime and come out with a slew of episodes. Take the time to research some more, and come out with another set.

As I said, it is a privilege to keep going but Fragmented also has to evolve with me, as I hit a big personal milestone myself this year! If you’re a listener, 🙇‍♂️ thank you for your ears.

This is the email I sent Donn - 28th Jan 2015.

Feb 17th 2015 is when we released our very first episode.

to be clear I still do a healthy amount of it, to keep my own sanity. ↩︎
I cannot say the number of times I’ve opted to instead read someone’s blog post over the technical docs, when getting up to speed on a topic. Blog posts by humans have a way of authentically trimming down all the fat and highlighting what’s important. Producing your own content even if it’s a blog post, giving a talk, or writing a note to yourself is one of the most powerful ways of learning. ↩︎

🖤 Automatic Dark mode for Hugo using Tailwind CSS

Fri, 04 Apr 2025 23:01:08 GMT

On a ✈️ back home, I decided to add Dark mode support to Henry. Having recently upgraded to Tailwind CSS 4.0, this was a piece of cake to do.

I leverage the widely supported CSS @media prefers-color-scheme feature and Tailwind’s native dark-mode support.

The implementation only required a few changes:

1. update main theme.css #

In my main theme.css file where I declare the existing colors, I add the CSS @media selector for the “dark” variable indicator.

@theme {
 /* henry background */
 --color-hbg: var(--color-slate-50);
 --color-hbg-dark: var(--color-slate-200);
 /* ... */
 }

 @media (prefers-color-scheme: dark) {
 .dark {
 /* henry background */
 --color-hbg: #1c2b33;
 --color-hbg-dark: #152027;
 /* ... */
 }
 }

2. update base html body #

In my root html page, I simply add the “dark” variable indicator class

<html class="dark">

Now CSS automatically knows to pull in the dark variant of colors when the system indicates light/dark mode.

There is no step 3!

This was so easy to do, in fact, that I even managed to catch up on Gladiator II on the plane ride which I personally give a solid 3.0 just for Denzel.

AirPods Max: now great for podcasters with 0 latency!

Sat, 29 Mar 2025 03:36:53 GMT

Update is now out

The latest firmware update is out now. Update your Mac (iPhone or iPad) to the latest version & connect your Airpods Max should update its firmware.

Apple just announced ultra-low latency support for the USB-C AirPods Max, and it changes everything for podcasters.

Yes, they still cost an absurd $500. But now they’re worth their weight in starlight¹ gold.

Courtesy: Apple.com

Why AirPods Max Are Now Perfect for Podcasting #

Here’s the part that’s changing: you can now “monitor” your own voice in real-time while speaking into a mic and recording. This is an important feature for podcasters, to make sure they’re speaking into the mic clearly.

Until now, I needed two separate headphones: my trusty Sony MDR 7506 while recording my podcast for monitoring purposes and more fun sounding ones for everything else. This update eliminates that hassle of needing two headphones on my desk.²

This single update transforms the AirPods Max from luxury listening headphones into professional podcasting gear.

Here’s some notes that are also not immediately clear from their announcement but super exciting:

No special cable needed: The standard USB-C cable that came in the box will work perfectly for all this. Importantly you don’t need that $40 cable everyone is complaining about.
Wired mode: You can use your headphones in wired mode. They should charge and play audio in lossles quality. This is because the signal chain is digital all the way until they produce sound in your ears.

The $40 cable is still useful if you want to connect to an audio jack but I honestly prefer not having a special cable that’s not USB-C while traveling.³

Not the best sounding but still worth it #

The AirPods Max are not the best sounding headphones for your money but they are good enough. Like really really good enough.

They are also pretty comofortable (but can be slighlty heavy for some). I’m able to wear these headphones for 6 hours straight comfortably.

These are one of the best in noise cancelation. This is especially a godsend for me when I’m in a flight with crying babies and can’t do anything about it. Turn NC on and the volume ever so slightly up, and I can drown out all the noise.

That good USB-C one cable life baby. My phone, laptop and now headphones all can use the same cable.

For podcasters looking to simplify their setup without sacrificing quality, the AirPods Max now are an excellent choice.

Amazon currently has the Starlight color for $479 (lowest price I’ve seen). I personally bought mine from Costco because I also know I can return them if there’s a manufacturing defect without needing to shell out for that AppleCare+ surcharge. ↩︎
The Sony MDR 7506 are good for recording but are flat. Them being wired also means I’m tethered to my computer when I just want to do some casual listening. ↩︎
Use the compact Twelve South AirFly SE instead. ↩︎

AI & Software Engineering: Time for optimism

Sun, 09 Mar 2025 22:22:02 GMT

Many software engineers (myself included, not long ago) have been anxious about AI replacing our jobs. It’s a natural concern.

But I’ve been diving deep into using AI for software engineering. I’ve had a realization:

We should stop worrying about job losses. Start seeing AI as a tool to make us more valuable.

The key? Use AI for learning, not just code generation.

Relying solely on AI for code generation is the trap.

The truly valuable skill is judgment.¹ The judgment to decide what to build and how to build it.² AI excels at the actual building (code generation). Embrace this. It’s inevitable. Most future code will be written|generated with AI.

The good news? AI is amazing for learning.

Some examples #

I think back to my undergraduate days. A concept didn’t click? It meant a bike ride to the library. I’d search for textbooks, pull references, and try to piece it all together. Assuming the books were even available. Guess what I often did? I didn’t bother. Today, I’d just pull up my phone and look it up.

The internet was a game-changer for students. AI is the next game-changer for all of us willing to learn.

A more recent example: I’m doing an upcoming Fragmented episode on an article that my friend Colin³ wrote on Coroutine Dispatcher use.

I understood about 75% on the first pass. But a few gaps remained, especially around how they related to Coroutine fundamentals. I needed to brush up.

Without AI, my process would have been:

Open a bunch of articles and docs.
Read each one thoroughly.
Synthesize the information mentally.
Connect the dots with the article.
Time: 2-3 hours, plus significant mental bandwidth.

With AI:

Uploaded Colin’s article and official Kotlin docs to Google’s Notebook LM.
Asked targeted questions, addressing my knowledge gaps directly.
Time: 30 minutes to reach a firm understanding.

What would have taken 2-3 hours took about 30 minutes.⁴ And I understood the concepts better.

AI is your opportunity to level up. Learn faster. Position yourself to make the critical decisions: “what” and “how” to build. This is where software engineers, especially new ones, should focus. You don’t have the luxury of years of experience that some of us “senior” engineers had. AI lets you catch up, fast.

Yes, the bar will be raised. Getting into the field won’t be as easy. But for those willing to learn and adapt, AI is an incredible advantage. Embrace it.

My friend Vinay and someone who’s also working very closely with AI for software development eloquently mentioned this in ep #257. ↩︎
For now, AI isn’t as good as this. It will catch up but my bet is it’ll take longer to close this specific gap. ↩︎
Yes, that one. ↩︎
If i’m being honeset, a lart part of the time was spent thinking about how I’d connect the dots to write this blog post. ↩︎

Terrifyingly Inspiring - My Life in Weeks

Sat, 15 Feb 2025 22:22:12 GMT

I’ve been following the awesome Gina Trapani for quite some time.¹ She recently built a tool to track her life in weeks (inspired by Tim Urban of Wait But Why fame’s own article).

As I get close to another complete revolution around the sun, the only thought that went through my mind reading this:

Terrifyingly Inspiring.

Lifehacker ❤️. It shaped my early internet years. ↩︎

Styled checkboxes for Obsidian tasks without plugins or a custom theme

Mon, 10 Feb 2025 08:00:00 GMT

I use Obsidian for tracking my weekly tasks.¹ One thing I like to do, is mark tasks as “canceled”, “rescheduled”, “in progress”, etc. in case I move them between weeks. These tasks should visually stand out from the rest.

Custom themes like Obsidian Minimal provide this as an option. There’s also plugins that do this. But I like to keep my Obsidian setup lean and only wanted this feature without other cruft.

CSS to the rescue again! The linked forum post had the starting css snippet I needed. I customized further to include some more options that the Minimal theme includes.

You can find my custom css snippet here.

that’s another post in itself. ↩︎

Age of the AI phone

Sun, 09 Feb 2025 18:53:19 GMT

In Vinay’s latest newsletter, he asks a few of us #AndroidDev to predict what the future of Android development is going to look like.

Yours truly had this as one of the predictions:

AI everything 🙄 … On the product side, we’ll see more on-device AI, with smaller models like Gemini Flash/o3-mini running locally to provide operator-like intelligence directly on phones and this will probably be what most folks are geared towards doing for mobile development.

Looking at this Youtube video that’s now doing the rounds, I’m starting to feel ever so slightly validated.

Google (or Samsung) truly have their shot of gaining significant Mobile market share again, especially given how much Apple has been floundering in the AI space.

How to enable custom fonts in Obsidian Mobile

Wed, 05 Feb 2025 08:00:00 GMT

One of the challenges with note taking apps on mobile is the limited font selection. While desktops let you install custom fonts system-wide, mobile platforms are much more restrictive.

However, there’s an elegant solution for Obsidian given it’s an electron app. Obsidian allows you to inject a CSS snippet to tweak the appearnace of the app. CSS allows you to embed base64 encoded fonts directly in them for styling text 💡.

I figured let’s try this and see if it works on mobile. Works like a charm!

Here’s how to do it:

1. convert your font¹ file to base64 and store in the clipboard #

# do this on a terminal app
base64 -i <path_to_font_file> | pbcopy

2. Create a new CSS snippet in Obsidian (Settings > Appearance > CSS snippets) and add your font declaration: #

@font-face {
 font-family: custom-font-name;
 font-weight: 350 900;
 src: url(data:application/octet-stream;base64,<paste_base64_string_here>);
}

Remember to enable the snippet after creating it. Also font files can get large when converted to base64. So you’re not going to be able to type out that encoded string.

3. Activate custom font in Obsidian #

Under Settings > Appearance > (Text|Monospace) Font, enter “custom-font-name”. It won’t show up in the dropdown but if you type the name exactly, you’ll see a checkmark after a second and your new font is enabled.

I typically do the above on my desktop and sync settings to my mobile. But nothing stops you from doing it directly on your mobile (if you don’t have sync enabled).

I now have my favorite reading font applied across my notes on mobile and my favorite monospace one applied to all the code in them!

Obsidian on Android with custom fonts

I encoded a variable font for convenience so i didn’t have to declare italicized, bolded, etc. versions of the font. ↩︎

Powering your Hugo blog with Bluesky Comments - invest in a feed you control

Sun, 19 Jan 2025 08:00:00 GMT

Twitter’s change in ownership triggered a cascade of events birthing various social media clones. It’s been tricky to decide which network to invest time and energy in. I’m not an influencer, but I’d be kidding myself if I thought having a presence on social media wasn’t important.

The recent TikTok drama has given me clarity on one extremely important principle that all creators should have learned by now: Invest in channels you control.

Invest in channels you control

I recently moved Fragmented (my podcast) from WordPress to Hugo in this same spirit; and was looking for a way to engage more closely with the community. With Bluesky gaining traction, it made sense to power my blog comments using a decentralized commenting system that I could control. Bluesky is built on the AT protocol, which aligns perfectly with this idea.

Thanks to Hugo’s flexibility, I was able to integrate Bluesky as a commenting system quite easily. I used this post as inspiration, but if you’d like to see my final implementation, you can check out the source code here:

comments-bsky.html (template for the comments)
comments-bsky.js (straightforward JS to load the comments)

I particularly like my implementation as it gently allows you to jump to the exact comment, and allows nesting. To see how this looks open the website on your browser and see the Comments sections below!

How to make the iPhone Continuity Camera work properly in Chrome

Thu, 12 Dec 2024 07:00:00 GMT

I use a pixel as my primary android phone. But as a mobile developer, I also keep an iPhone handy for those times I need to test how an app works on iOS (especially if it’s not available on Android¹).

But my iPhone doesn’t sit in a drawer unused. It doubles up as my webcam when not being used as a phone. This is possible because I use macOS for my primary desktop needs, and this wonderful feature it enables called “Continuity Camera”. I’ve removed a webcam from my setup thanks to this, and the camera actually works much better than most webcams out there today.

But there’s one really annoying thing about this setup. It won’t be recognized in Google Meet when using a chromium browser. Searching on Reddit points out that this is a bizzarre known security requirement for chromium browsers alone.

Your iPhone needs:

to be in landscape mode (so don’t have portrait lock on)
have the screen turned off
to be locked
motionless (so won’t work if handheld)
and have an unobstructed camera

wut 😵‍💫

But works like a charm. So if you run into this issue, fix those things and it’ll all work like a charm.

thinking about you Flighty. ↩︎

My new programming font - Commit Mono

Sat, 21 Sep 2024 07:00:00 GMT

I’ve been using this font for a while as my primary programming font and referenced it in one of my newsletters. Thought i’ll share this more prominently. This website now uses Commit Mono for code. I customized a few of the characters:

There are better ways to design than putting a big effort into making something look special. Special is generally less useful than normal, and less rewarding in the long term. Special things demand attention for the wrong reasons, interrupting potentially good atmosphere with their awkward presence.

— Jasper Morrison, Super Normal Manifesto

Coroutine Testing - Controlling time

Wed, 04 Sep 2024 07:00:00 GMT

series

This is part of a series of posts on Coroutine Testing:

Picking the right Dispatcher
Never ending tests & backgroundscope
Controlling time ←
Helpful @Junit TestRule extension (coming soon)
Full USF example for Android (coming soon)

My journey with coroutine testing started with this “simple” requirement — to control virtual time in concurrent logic.

From my previous post:

… If you don’t use a StandardTestDispatcher explicitly, then operators like runCurrent, advanceTimeBy etc. have no meaning.

I have a confession to make. I was coy saying “have no meaning”. I didn’t say “won’t work” because in reality those apis will “work” just not in the way you’d expect.

Let’s dive deeper.

The 3 apis #

There are 3 important apis in coroutine tests to play with time:

runCurrent - execute tasks scheduled at the current moment of virtual time
advanceTimeBy - advance virtual time by a number of milliseconds and then execute tasks scheduled in the meantime.
advanceUntilIdle - similar to advanceTimeBy but instead of advancing by a specific number of milliseconds, it keeps advancing until no more scheduled tasks are found.

In the context of coroutine testing, when you think of “time”, it refers simply to the order that the TestCoroutineScheduler decides to execute your scheduled coroutines. That’s why the definitions above stress on words “execute” vs “scheduled”.

In reality, these apis belong to the class TestCoroutineScheduler (not StandardTestDispatcher as the coy comment might have indicated).

Let’s attempt to understand this all, with some code.

StandardTestDispatcher & the 3 apis #

This animation should illustrate how the different apis are designed to work.¹

StandardTestDispatcher is good about respecting the 3 apis.

A basic test demonstrating the use of runCurrent that shouldn’t be surprising:

@Test
fun test() = runTest(StandardTestDispatcher()) {
 var result = "X"

 launch {
 result = "A"
 delay(1.seconds)
 result = "B"
 result = "C"
 delay(2.seconds)
 result = "D"
 }

 assertThat(result)
 .isEqualTo("X")

 runCurrent()
 assertThat(result)
 .isEqualTo("A")
}

Before runCurrent the coroutine isn’t launched so we expect the result “X”. On runCurrent we execute any scheduled coroutines without advancing the virtual clock, so expected result emitted² is A.

Let’s advanceTimeBy exactly 1 second (the first delay):

// ...
launch {
 result = "A"
 delay(1.seconds)
 result = "B"
 result = "C"
 delay(2.seconds)
 result = "D"
}

advanceTimeBy(1.seconds)
assertThat(result)
 .isEqualTo("A")
 .isNotEqualTo("B")
 .isNotEqualTo("C")

Notice that even though we advanced time by the delay, the result hasn’t updated or changed from A. This is because you’ve scheduled the next emit with the delay but haven’t executed it yet.

Throw in a runCurrent like before and it’ll proceed to execute, giving you the result you expect:

// ...
launch {
 result = "A"
 delay(1.seconds)
 result = "B"
 result = "C"
 delay(2.seconds)
 result = "D"
}

advanceTimeBy(1.seconds)
assertThat(result)
 .isEqualTo("A")
 .isNotEqualTo("B")
 .isNotEqualTo("C")

runCurrent()
assertThat(result)
 .isEqualTo("C")

To really test your understanding - what happens if you advance time by 2 seconds (greater than the first delay of 1 second but less than the next one of 2 more seconds):

// ...
launch {
 result = "A"
 delay(1.seconds)
 result = "B"
 result = "C"
 delay(2.seconds)
 result = "D"
}

advanceTimeBy(2.seconds)
assertThat(result)
 .isEqualTo("C")

Advancing it by 2 seconds means you’ve gone past the initial one second delay (where the job is scheduled) + an additional 1 second, nudges the job to execute (releasing B & C). We don’t need a runCurrent here like the previous example because you’ve nudged the virtual clock past the scheduled time, well into execution. This demonstrates how going past the scheduled delay -even by a small amount- will automatically execute on the results.

This entire test should now make sense:

@Test
fun test() = runTest(StandardTestDispatcher()) {
 var result = "X"

 launch {
 result = "A"
 delay(1.seconds)
 result = "B"
 result = "C"
 delay(2.seconds)
 result = "D"
 }

 advanceTimeBy(1.seconds)
 // result A executed
 // schedule B & C
 assertThat(result)
 .isEqualTo("A")

 runCurrent()
 // execute B & C
 assertThat(result)
 .isEqualTo("C")

 runCurrent()
 // no-op (no time advancement)
 assertThat(result)
 .isEqualTo("C")

 advanceTimeBy(2.seconds)
 // schedule D
 assertThat(result)
 .isEqualTo("C")

 runCurrent()
 // execute D
 assertThat(result)
 .isEqualTo("D")

 // 😉
}

The key point to take away with StandardTestDispatcher is that it respects the apis but you have to really understand the difference between scheduling a job and executing it.

UnconfinedTestDispatcher & the 3 apis #

This is where things get complicated. Don’t take my word for it , even the docs say so:

“Unusual” is correct.

I want to first point you to some source code that will help build the necessary context. If you look at the implementation for both TestDispatchers, you’ll see that they both utilize a TestCoroutineScheduler:

StandardTestDispatcher src

UnconfinedTestDispatcher src

Remember TestCoroutineScheduler is effectively your virtual clock and is the actual class that provides the 3 big apis. So it follows that UnconfinedTestDispatcher has some effect from the apis.

There’s two methods of interest isDispatchNeeded and dispatch.

isDispatchNeeded from CoroutineDispatcher

Looking at the implementation for the method dispatch in both TestDispatcher classes. You can piece together some things:

// UnconfinedTestDispatcher

override fun isDispatchNeeded(context: CoroutineContext): Boolean = false

override fun dispatch(context: CoroutineContext, block: Runnable) {
 checkSchedulerInContext(scheduler, context)
 scheduler.sendDispatchEvent(context)
 //...
}

// StandardTestDispatcher

// fun isDispatchNeeded not overridden so defaults to true

override fun dispatch(context: CoroutineContext, block: Runnable) {
 scheduler.registerEvent(this, 0, block, context) { false }
}

UnconfinedTestDispatcher sends the dispatch event right away. It further overrides isDispatchNeeded as false meaning - execute the coroutine immediately, don’t first register (or schedule) the coroutine just send or dispatch.

StandardTestDispatcher on the other hand is “simpler” and merely registers (or schedules) the event to be dispatched. When does it get executed or dispatched then if right away? That’s where the 3 apis come in 💡. This is why it feels like the 3 apis to advance time have more meaning with StandardTestDispatcher.

Let’s look at test code for UnconfinedTestDispatcher similar to our StandardTestDispatcher examples. This is a super basic test for UnconfinedTestDispatcher.

@Test
fun test() = runTest(UnconfinedTestDispatcher()) {
 var result = "X"

 launch {
 result = "A"
 delay(1.seconds)
 result = "B"
 result = "C"
 delay(2.seconds)
 result = "D"
 }

 assertThat(result).isEqualTo("A")
}

Already, we start with some unusual-ness. Notice that we didn’t runCurrent but the very first value “A” was eagerly emitted .³ In the case of StandardTestDispatcher, the value would have been “X”.

The docs actually point this behavior out:

* Like [Dispatchers.Unconfined], this one does not provide guarantees about the execution order when several coroutines
* are queued in this dispatcher. However, we ensure that the [launch] and [async] blocks at the top level of [runTest]
* are entered eagerly. This allows launching child coroutines and not calling [runCurrent] for them to start executing.

The funny thing is UnconfinedTestDispatcher will actually behave very similarly to StandardTestDispatcher now in terms of advancing time (after it is eagerly launched):

launch {
 result = "A"
 delay(1.seconds)
 result = "B"
 result = "C"
 delay(2.seconds)
 result = "D"
}

assertThat(result).isEqualTo("A")

// now it'll behave like StandardTestDispatcher
advanceTimeBy(1.seconds)
runCurrent()

assertThat(result).isEqualTo("C")
advanceTimeBy(2.seconds.plus(1.milliseconds))
assertThat(result).isEqualTo("D")

So it does respect the 3 apis but only after eagerly launching. Hopefully that clarifies the original comment.

To be honest I’ve asked myself many times what the point of having both kinds of TestDispatchers is, if this remains the only big difference. One important reason is that seismic change in apis with 1.6.0 — older testing apis like runBlockingTest (now deprecated) used to launch coroutines eagerly to make testing less tedious, so it was an easier migration path to swap in place with UnconfinedTestDispatchers.

Here’s my takeaway between the two dispatchers:

UnconfinedTestDispatcher launches the coroutine eagerly (explained above) which makes it less tedious during testing
Order is not guaranteed with UnconfinedTestDispatcher, so StandardTestDispatcher is more predictable especially in complicated concurrent scenarios
UnconfinedTestDispatcher is good about collecting every single item (this doesn’t have to do with time) but maybe in a future post I’ll show how testing StateFlows can benefit from UnconfinedTestDispatcher.

Just as manual and automatic transmission cars offer different levels of control and convenience in driving, the UnconfinedTestDispatcher and StandardTestDispatcher in Kotlin coroutines provide distinct approaches for managing the execution of test code.

I personally do prefer using StandardTestDispatcher because I’m not one to shy away from boilerplate, so I happily trade off tediousness with predictability but your mileage might vary.

My thanks to Márton for reviewing this post. Next up: A Helpful @Junit CoroutineTestRule extension (coming soon)

I spent way too much time making this animation, so I’m dropping it right at the start. Though if I’m being honest, it’s faster to look at the following code and understand. ↩︎
I’m using the terminology emit because the animation was meant to illustrate a MutableStateFlow. For the tests shown here, think of emit as the result being assigned a value. ↩︎
Again I’m using the terminology emit as before, but think of emit as the result being assigned a value. ↩︎

Mobile Rewrites & Crisis Management

Wed, 04 Sep 2024 07:00:00 GMT

My good friend Mustafa has some sage advice for Sonos on the recent rewrite fiasco.

Fix all issues and test the new app very thoroughly with external beta testers before relaunching.

Have the best crisis leader at the company take over. Find all ICs who have been raising the alarm and give them authority to move fast. Remove anything that gets in the way - …

Create a single source of truth - all issues, feedback and bugs should flow into a single place. Have a small team (<=3) triage and prioritize them. Everyone else focuses on fixing them.

Appoint DRIs - Divide problems by areas (feature x, stability, performance, etc) and appoint a single Directly Responsible Individual (DRI) for each. … Prioritize skill over titles/experience while picking them.

Sign the entire company up for testing - You can no longer rely on just the QA team to find bugs. Everyone needs to test the app daily, especially all managers and execs. All hands on deck.

gold.

Coroutine Testing - Never ending tests & backgroundScope

Fri, 30 Aug 2024 07:00:45 GMT

series

This is part of a series of posts on Coroutine Testing:

Picking the right Dispatcher
Never ending tests & backgroundscope ←
Controlling time
Helpful @Junit TestRule extension (coming soon)
Full USF example for Android (coming soon)

If you’ve spent some time testing Coroutines this exception should look familiar:

After waiting for 1m,
the test coroutine is not completing,
there were active child jobs

This tends to happen when you have a coroutine job in your test, that fails to complete on its own. Let’s take a simple example.

src on github

We use a Channel here which is the proverbial event bus for Coroutines.

source: kotlinlang.org

Channels don’t terminate on their own. So when you run a simple test checking the emission, while the items might get collected correctly per the assert statement in the test, the test itself fails like so:

test on github

The test here is waiting for that coroutine job to complete, which in turn requires the Channel to, but that never happens and the test times out.

Where else would I run into this problem? #

Channels aren’t the only case you’ll run into this problem. For example if you use a “hot” Flow like SharedFlow or StateFlow, they don’t terminate on their own, so the onus is on you to complete or cancel their Job in tests.

Android developers can frequently run into this problem too if you use ViewModels and have an internal StateFlow providing your “view level data” (what i personally like to call “view state”).

You typically use the viewModelScope to launch internal coroutine jobs in a ViewModel. The OS then calls the lifecycle method onClear when the Activity or Fragment no longer needs the ViewModel where all jobs started in the viewModelScope are canceled.

But when unit testing these ViewModels, you don’t have access to the viewModelScope and shouldn’t need it anyway.

Solving this problem #

There’s two ways to solve this problem:

1. Manually cancel the Job #

If you have access to the Job that spawns the never-ending coroutine, it’s trivial to cancel the Job. Here’s that first test, now passing:

A simple job.cancel does the trick.

2. Use a `backgroundScope` #

But you don’t always have access to the Job directly or it requires a level of pass-through that makes your code cumbersome.

That’s where backgroundScope comes in and is a pretty elegant solution to this problem.

Instead of getting access to the job directly, launch the desired coroutines within a backgroundScope.

backgroundScope is a special construct provided in coroutine tests alone that makes sure all child coroutines are explicitly canceled once the test body completes.

How does backgroundScope work? #

The beauty of Kotlin is everything is open source. Let’s go find the code that that powers this magic:

The relevant code can be found as part of runTest in TestBuilders.kt.Here’s the interesting parts of the implementation:

public fun TestScope.runTest(
 timeout: Duration = DEFAULT_TIMEOUT.getOrThrow(),
 testBody: suspend TestScope.() -> Unit
) { scope ->
 // ...

 createTestResult {
 val testBodyFinished = AtomicBoolean(false)

 scope.start(CoroutineStart.UNDISPATCHED, scope) {
 yield()
 try {
 testBody()
 } finally {
 testBodyFinished.value = true
 }
 }
 // ...
 try {
 withTimeout(timeout) {
 // ...
 testBodyFinished.value && activeChildren.isNotEmpty() ->
 "there were active child jobs: $activeChildren. " // ...
 testBodyFinished.value ->
 "the test completed, but only after the timeout"
 else -> "the test body did not run to completion"
 }
 } catch (_: TimeoutCancellationException) {
 // ...
 } finally {
 backgroundScope.cancel()
 // ...
 }
 }
}

Make backgroundScope a regular part of your testing arsenal. In most of my tests these days, I liberally use and inject backgroundScope to make sure those tests don’t hang.

Next up: Controlling time

Coroutine Testing

Sun, 25 Aug 2024 07:00:45 GMT

When the #androiddevs transitioned from Rx to coroutines the topic of testing didn’t get as much attention in this new world of concurrency.

It didn’t help that there was a seismic change in Kotlin’s testing apis with 1.6.0. A whole bunch of online resources and tutorials are now defunct courtesy this change.¹

My journey in the matter started because I simply couldn’t understand why test apis like advanceTimeBy wouldn’t work reliably for me. The name made sense… but my time wasn’t being advanced in any meaningful way.

Then there’s the issue of flaky tests. Here’s an example:

flaky test code on github

Run each test individually and it will pass; run them together as one test suite and test2 alone will fail. test1 passes but it takes a full 3s to run the test. If I have 300 of these in my app, are my tests going to take 15 minutes to run?

I needed to understand many core concepts in order to confidently explain all the above phenomena. I’d like to share my learnings from going down the rabbit hole, in this series of posts:

series

This is part of a series of posts on Coroutine Testing: ←

Picking the right Dispatcher
Never ending tests & backgroundscope
Controlling time
Helpful @Junit TestRule extension (coming soon)
Full USF example for Android (coming soon)

If you’re looking for the most current and useful resources on coroutine testing today:
↩︎

Coroutine Testing - Picking the right Dispatcher

Sun, 25 Aug 2024 07:00:45 GMT

series

This is part of a series of posts on Coroutine Testing:

Picking the right Dispatcher ←
Never ending tests & backgroundscope
Controlling time
Helpful @Junit TestRule extension (coming soon)
Full USF example for Android (coming soon)

Most of the problems and flakiness around coroutine testing stem from running them on different Dispatchers. This is because the choice of Dispatcher can significantly impact the behavior of coroutines. This was also the most confusing¹ part for me starting out — understanding the implications of using a Scope, Context or Dispatcher.

I recommend Roman’s article if you want to brush up on the fundamentals. But in a nutshell: think of CoroutineContext as a collection of elements that define the coroutine. It contains a Dispatcher, Job & a CoroutineName. When you launch a coroutine, it inherits the parent’s CoroutineContext (and Dispatcher), unless you specify it explicitly.

A CoroutineScope on the other hand is just a way to manage and cancel (multiple) coroutines. It also defines a context and lifecycle for the coroutines launched within it (the context could be linked to yet another Dispatcher). Any coroutine when launched, runs within a CoroutineScope.

Let’s take an example:

Notice how the current Dispatcher of the coroutine shifts from StandardTestDispatcher → UnconfinedTestDispatcher → Dispatcher.IO in the span of three innocuous lines based on the coroutine builder (runTest) or scope used (TestScope, turbineScope from the 3rd party library, App scope).

In my initial post I pointed out this flaky test:

flaky test code on github

The fix for this is as simple as explicitly injecting a TestScope and making sure the same scope is used throughout.

fixed test code on github

Explicitly injecting the CoroutineScope and substituting it with the TestScope works really well and is my preferred strategy. This approach allows for more control over the Dispatcher used in tests . For reasons you’ll see later, these tests also run instantly (72ms vs 6s 82ms).

But the story doesn’t end there.

If you look at the official android docs, they recommend using the same Scheduler. Not a Scope or Dispatcher.

developer.android.com

What is a Scheduler? #

This got me thinking… what Scheduler do my tests use? Easy enough to check:

StandardTestDispatcher[
 scheduler=TestCoroutineScheduler@1623134f
]

StandardTestDispatcher & TestCoroutineScheduler - the plot thickens. What even is a Scheduler? Rx had this concept but with Coroutines, Dispatchers is the only thing we deal with.

Let’s dive deeper.

Courtesy: Márton's talk on Coroutine testing

runTest is the basic api we use for coroutine testing and like other coroutine builders (runBlocking , launch, async etc.) implicitly uses a CoroutineScope. For testing, there is a special scope called TestScope. And given that CoroutineScopes get linked to a Dispatcher,² for this special scope there exists a special TestDispatcher (more on this later).

When testing coroutines, we often need precise control over their execution timing, especially when dealing with virtual time. TestCoroutineScheduler is the construct that provides us this fine-grained control. This is also why you don’t see or use Schedulers in production or your app code, where there isn’t this need.

In a future post, I’ll show you a @Junit test rule that makes sure the TestCoroutineScheduler is shared across injected dispatchers.

But before we get into that, let’s look at that official android doc again:

developer.android.com

Any number of TestDispatchers? How many are there?

TestDispatchers #

In testing, instead of using one of the regular Dispatchers (Default, IO, Main, Unconfined) you need to use a special TestDispatcher. Think of the TestCoroutineScheduler as the virtual clock and TestDispatchers as special Dispatchers. These special Dispatchers use the virtual clock to schedule and manage the execution of coroutines in tests.

TestDispatcher itself is an abstract class though and there exists two implementations that we can use - StandardTestDispatcher & UnconfinedTestDispatcher. Craig has an excellent post comparing the two but in a nutshell:

StandardTestDispatcher:

does not execute tasks automatically³
you have full control over what is executed and when
you have to use methods like runCurrent, advanceTimeBy & advanceUntilIdle

if not specified explicitly, runTest will use a StandardTestDispatcher by default

UnconfinedTestDispatcher:

starts new coroutines eagerly (which means you don’t need to manually advance the coroutines in your test)
there’s no guarantee on the order of your coroutines launched
far more convenient to use in tests (especially if you don’t care about concurrency in your tests).

Eager loading of coroutines in tests #

The fact that StandardTestDispatcher does not execute tasks automatically lands up being a pretty important difference in the world of concurrency. UnconfinedTestDispatchers are more convenient to use but you trade-off on a deterministic test run.

You’ll observe that the extremely convenient coroutine Flow testing library Turbine uses an UnconfinedTestDispatcher internally.⁴

My complaint in the initial post around why advanceTimeBy wasn’t working, should now make sense. If you don’t use a StandardTestDispatcher explicitly, then operators like runCurrent, advanceTimeBy etc. have no meaning.⁵ This is because coroutines are loaded eagerly, especially with vanilla Turbine test usage.

I strongly recommend using StandardTestDispatcher when you care about concurrency.

Phew! You’re now primed with the necessary fundamentals for Coroutine testing. The following posts should be targeted and a breeze.

My thanks to Márton & Robert for reviewing this post. Next up: Never ending tests & backgroundscope

and arguably one of the ways coroutines is more complex than RxJava ↩︎
In an earlier version of this post I mentioned CoroutineScopes contain a Dispatcher. This is strictly not true. It can for example have an EmptyCoroutineContext which is the object that usually contains the Dispatcher, but the EmptyCoroutineContext doesn’t specify a Dispatcher at all. When you launch though using a builder function, that function supplies the scope, since there’s nothing else to use. ↩︎
There’s a nuance here again. Most places mention the tasks do not execute automatically. That’s strictly not true. StandardTestDispatcher itself executes them for example if you manually yield the test thread. But the point still stands in terms of observed behavior/functionality. ↩︎
I can go into the nuances of Turbine in a future post. It’s more involved than a simple UnconfinedTestDispatcher replacement. ↩︎
Make sure to read my post on controlling time for more on this. ↩︎

Campground Pull Request

Sat, 06 Jul 2024 22:52:31 GMT

Before diving into a new feature, I always tell my team to scout the parts of the codebase that will need to change. As we explore, refactor for clarity.

These cleanup changes get their own pull request¹ (PR) before we touch the new feature. This PR shouldn’t change functionality, just tidy up the existing code.

This gives us a few big wins:

Better estimates: We can estimate the feature’s timeline more accurately now that we have a much better sense of what’s about to change.
Smoother reviews: Campground PRs are quicker to review, since no functionality has changed. Importantly, you don’t clutter your feature PR with refactors or distracting changes — prompting the ire of code reviewers.
Codebase quality: You gradually increase the code quality of your codebase — especially the parts that won’t get touched by your feature PR but could use the love.

This is not a new concept , you’ve probably seen versions of it before:

Boy Scout Rule: Leave your codebase cleaner than you found it.
Broken Windows: Fix small issues before they proliferate through your code base become big.

I haven’t found a popular name for this specific concept, so I’ve started calling them “Campground PRs”.

Don’t just leave the code better after your feature, do it before hand.

Got a better name? Let me know!

Or merge request (MR), for the Gitlab folks. ↩︎

Adding Tailwind CSS to a Hugo blog

Fri, 05 Jul 2024 18:36:23 GMT

Updated for Tailwind CSS V4

I veer away from CSS frameworks like Bootstrap because they result in sterilized designs. On a recent side project, I gave Tailwind CSS a try and am now a believer. “Rapidly build modern websites without ever leaving your HTML” makes a lot of sense to me.

Case in point: I rebuilt my Hugo theme, Henry, with Tailwind in three days.¹ I quite like how it’s turned out. Let me show you how to add it to a Hugo theme. This has become even simpler with Tailwind CSS v4.

Approach #

I like to keep things as simple as possible. So, it was important for me to use both Hugo & Tailwind as you would independently.

I don’t use Tailwind as a PostCSS plugin as much of the internet recommends. I prefer Tailwind CLI.

Installation #

Let’s assume you created your new site with hugo:

hugo new site my-blog
cd my-blog

From this root hugo project directory:

# create a package.json file (with default options)
npm init -y

# install Tailwind CSS as a dependency
npm install -D tailwindcss @tailwindcss/cli

Let’s create the necessary css files for Tailwind to latch on to:

mkdir -p my-blog/assets/css
touch my-blog/assets/css/input.css
touch my-blog/assets/css/theme.css

I use the input.css file to help Tailwind wire everything together, and output.css is the final css that Tailwind compiles out.

/* input.css */
@import "tailwindcss";

@import "./theme.css";

/* custom css you might want to add as overrides */

That’s it! You can now fire up Tailwind & Hugo:

# start tailwind
npx @tailwindcss/cli \
 -i ./assets/css/input.css \
 -o ./assets/css/output.css \
 --watch

# start hugo server
hugo server

Bonus tip #

Starting Tailwind and Hugo separately in two different shells is a bore. I use a Makefile that conveniently allows me to spin up both processes in parallel.

All I have to do when I’m ready to spin up my blog locally is:

# runs the default comand which is "run"
# it runs both taliwind css & the hugo server in parallel
make

Sometimes I want to just build the site, not run the servers:

make build

This runs the hugo build command and the tailwind css build command btw.

You can take a look at my Makefile to see how all the commands are wired up:

Just use Henry #

If you just want a solid Hugo theme that uses Tailwind and is easy to get up and running, just use Henry. This is everything you need to do:

# brew install hugo
hugo new site blog-henry
cd blog-henry
git clone https://github.com/kaushikgopal/henry-hugo.git themes/henry

mkdir -p assets/css
cp themes/henry/assets/css/input.css assets/css/

# brew install node # if you don't have npm installed
npm init -y
npm install -D tailwindcss @tailwindcss/cli

echo 'theme = "henry"' | cat - hugo.toml > temp && mv temp

cp themes/henry/Makefile ./
make

Revisions #

Upgrade to Tailwind CSS v4.
Remove convoluted Procfile + foreman setup with much simpler Makefile.
Changed the instructions to do the npm install of tailwind in my blog folder vs the theme. This allows more flexibility in customizing via tailwind.

That’s a lot of hand-wrangled css that I could port over pretty quickly. ↩︎

Pick the right JDK for Android Studio

Wed, 06 Mar 2024 08:00:00 GMT

If Android developers don’t setup the JDK correctly, you’ll be greeted with nasty errors like this:

Check your module classpath error

Cannot access 'java.lang.constant.Constable'
which is a supertype of 'java.lang.Class'.
Check your module classpath for missing or conflicting dependencies

Your app might compile fine but the IDE will keep surfacing pesky errors. This is because Android developers have a variety of ways to setup the JDK for your development environment. Too many.

On episode #249 of Fragmented we discussed the numerous JDK options and what they’re used for. Google now has an excellent developer doc for this.¹

Courtesy: Android Developer docs

If you don’t have time to catch up on all the valuable content above, here’s the takeaways:

1. Use the JDK that comes with Android Studio #

JBR² is battle tested with Android Studio and includes enhancements for running Android Studio well. To use it as your SDK, switch your Gradle JDK to JBR:

how to set jbr as your gradle jdk

Do a File > Invalidate Caches after this…

mother of all fixes

2. Match your`JAVA_HOME` with the Gradle JDK #

The Gradle JDK from Step 1 is used to compile your app from Android Studio. If you use the command line to build your app on the other hand, the JDK from your $JAVA_HOME³ is used.

If both of these don’t match, you can have multiple gradle daemons running around. Make sure to match the two.

# ~/.zshenv
export JAVA_HOME=$HOME/Applications/Android\ Studio.app/Contents/jbr/Contents/Home

If you’re not sure where the jbr-jdk is located:

This is the way.

no seriously, it’s really good. ↩︎
JetBrains Runtime ↩︎
…if you haven’t customized your environment too much. It’s a little more involved. ↩︎

letter.kau.sh – 2024 Mar

Fri, 01 Mar 2024 08:00:00 GMT

Welcome to the third installment of my newsletter. Your support as always means everything to me.

Let’s dive in.

What I’m watching, listening, reading #

[video] You’re Not Forgetful: My System for Memorizing Everything #

Most people think they have a terrible memory. I know I did. This video by a YouTuber doctor challenged me to rethink that. I haven’t noticed a change in my memory’s capacity, but I’ve learned how to remember more.

[video] Apple TV+ Masters of the Air #

Exceptionally shot. Solid 3.5 rating and worth the watch. Apple TV+ has been killing it.

[music video] Sample Breakdown: Daft Punk - Discovery #

Sampling is the art of reusing a portion of a sound recording in another recording. It’s had a complicated history, especially with music licensing concerns and whatnot. Young Guru (Jay-Z’s tour D.J) has a good video explaining this.

But to fully appreciate sampling as an art, it’s not enough to hear the music; you have to visually “see” it. See watch Daft Punk do their magic now.

[audio book] Leadership Strategy and Tactics #

I’ve been looking for good reads on leadership and this book by an ex-Navy seal came recommended. I have qualms with the narrator’s voice but I must say this was a good book with apt analogies.

Tips #

🚫 Apple Music #

I use bluetooth headphones with my Mac and it drives me 🦇 💩 🍌 😡 every time I hit the play/pause button and see this window:

I don’t use Apple Music. I don’t want it to open every time. I’d love to disable it. Heck, I’d love to uninstall it altogether. Sadly, Apple doesn’t allow you to do this. No worries, noTunes has got your back:

brew install --cask notunes

A minor yet significant annoyance, zapped away.

New font - CommitMono #

Readers of my blog know I’m obsessed with monospaced fonts. For my daily programming, I used a custom version of IBM Plex Mono and now more often San Francisco Mono ¹. I’m weary of using SF Mono though because of Apple’s restrictive licensing.

Imagine my happiness finding a new worthy contender - CommitMono. I admire the Danish creator’s philosophy around it:

There are better ways to design than putting a big effort into making something look special. Special is generally less useful than normal, and less rewarding in the long term. Special things demand attention for the wrong reasons, interrupting potentially good atmosphere with their awkward presence.

— Jasper Morrison, Super Normal Manifesto

There’s an option to customize it and you bet I did…

I do wish there was an alternative version of “r” with the extender at the baseline. That would make it 🧑‍🍳 💋.

Signing off #

This was a tough month. A few of my colleagues and friends who I deeply admire were let go. Turbulent times in tech :/.

Thank you once again for your support and readership. Your feedback is always welcome.

Until the next one.

which comes baked in with the Mac ↩︎

Option ⌥ key for shortcuts vs special characters

Sun, 04 Feb 2024 08:00:00 GMT

Ever tried using the option key (⌥) with another character as a keyboard shortcut in a macOS app?

For example, in Obsidian I use ⌥ r to replace templates in the active file; or ⌥ a to archive completed tasks for the day.

Using the default English > U.S. keyboard (or ABC) types special characters in your app like å or ® vs executing your app shortcuts. It’s frustrating.

If you’re heavy keyboard shortcut or a programmer wanting to use more keyboard shortcuts in your IDE like me, you’ll derive more use from ⌥ being used as a keyboard shortcut modifier.

Solution 1 ✗ #

I’m not one to shy away from keyboard hacking. So I tried Karabiner to force remap the ⌥ keystroke when typed with another character, sending it directly to the application. That didn’t work.

I then pulled out my trusty Keyboard Maestro which is the tool I fall back to when all else fails. Nope, macOS seems to hijack these keystrokes at a deeper level.¹

Solution 2 ~ #

There’s a quicker solution² – pick a different keyboard. A lot of online posts specifically recommend a “Unicode Hex Input” keyboard.

You can start using ⌥ a without å showing up, no sweat and the keyboard shortcuts work. The Unicode Hex Input keyboard is additionally cool cause it allows typing out unicode characters with their full code. Here’s an example: hold the ⌥ key and type 03c0 to see what you get.³

Problem solved? Not completely.

Open a program like iA writer⁴ or Arc and try using the keyboard shortcut ⌥ ⇧ → or ⌥ ⇧ ←. These basic macOS wide shortcuts should select the next/previous word respectively. Those no longer work. Let’s see if there’s any other options in there?

The selection shortcut start working in some apps but not all of them. Sigh. The search continues.

Solution 3 ✓ #

After scouring forums, apple support threads, reddit etc. I finally found a solution that works.

You’ll need to create a custom keyboard and provide it as an Input source to the Mac (as you saw in earlier screenshots). You can use a program like Ukelele or this online tool that someone kindly created for free.

Alternatively, download the keyboard I made called “US Plain” and copy it over to your ~/Library/Keyboard Layouts directory. Log out of the mac and log in again. When you go to add a keyboard in the Input Sources menu, you’ll now find your keyboard under “Others”.

This solution reliably resolves all issues.

probably redirecting control character codes differently 🤷🏽. ↩︎
one would incorrectly assume. ↩︎
π ↩︎
my favorite macOS app for writing. ↩︎

letter.kau.sh – 2024 Feb

Thu, 01 Feb 2024 20:00:00 GMT

Welcome to the second installment of my newsletter. Your support means the world to me.

I’ve been told the key to building an audience is consistency. I’m committing to this idea by releasing my letter on the first day of each month. This way, you’ll always know when to look out for a new letter.

Let’s dive in.

What I’m watching, listening, reading #

[podcast] What Now? – Trevor Noah’s standup is good but he’s an even better interview host. His “Between the Scenes” segments are some of my favorite. His new podcast is really good so far.
[tv] Slow Horses – Just finished Season 1 and I’m giddy that there are two additional seasons waiting for me. The best feeling.
[tv] Blue Eye Samurai – I’ve swooned about this show before but I’ll promote it again any chance I get. It’s the best thing I watched in 2023.
[video] Where are U Now | Diary of a Song – Yes, it’s the one you’re thinking of, and yes it’s Beiber, but this video is specifically around how Diplo & Skrillex collaborated to make the song. I’ve got a bunch of these to share, so stay tuned.

Tech Tips #

Making use of the `/tmp` directory #

Courtesy: Alex Xu via Twitter

Are you aware that Unix-based systems, like macOS, offer a “hidden” /tmp directory that clears out every time you reboot?

I set it as my default download location for files that are momentarily needed like downloads, screenshots, or installation packages. There’s no need for a manual cleanup of these files as your next reboot will just wipe them clean.

Caveat: since this directory is world-writable, other user profiles on your device can access these files.

Hiding your macOS dock #

The Dock is one of those macOS features that I never use and strangely, it can’t be disabled. Nicholas shared a workaround that effectively hides it:

defaults write com.apple.dock autohide-delay -int 60 && killall Dock

It’s been working like a charm.

From my blog #

Get to Inbox 0 with Gmail #

I wrote this post excited to share my tips on taming an email inbox. I shared it with the author of the plugin mentioned. He was kind and gracious but told me that my post was vapid (without using those words). He’s right. I rushed that post in an excitement to get it out. I oversold with that title.

This is why I love the internet and am willing to look foolish. It means I’m learning. I’ve since been thinking about re-editing that post. The title should have just been - how I use Gmail.

Replace git-number with git aliases #

I wanted to go on more about my simplify series and how pumped I am about a queue of posts I have in mind for this topic. But reason and restraint found me and I figured folks will find their way to it, in time.

But if you’re curious… dear newsletter reader (❤️) the ones I’m thinking of: “How I Obsidian”, “iTerm → Terminal & sane dotfiles”, “Fish → Zsh”, “VSCode + NeoVim → Jetbrains”, “KeyboardMaestro + Alfred + Pastebot + WorldClock widget + … → Raycast”

If there’s one that you’re eager to read, let me know.

Musings #

Programming for good #

As a programmer, I’m always looking for opportunities to apply my skills to benefit society and perform my civic duty. The opportunities are there…

The San Francisco subway system still runs on 5 1/4-inch floppies.

By way of Jason Kotke

SF has the best software engineers in the world and they’re riding the very Munis that run on 5¼ floppies, all around San Francisco. Yet, there isn’t an obvious way to volunteer time to help improve these systems. 💡

Free stuff getting better over time #

If you’re reading this letter on a browser, you’ll notice I’ve spruced the website up a lot. I’m going to write more about the numerous subtle features a casual reader might miss.

But every time I start to work on it, there’s this guilt of sinking time into the effort. But I’m writing this to remind future me: it’s ok. Working on Henry is meditative for me - low stakes programming that makes atleast one person happy (me).

There’s also something fulfilling about the idea of improving the work you give out for free, over time. How often can you say that about other free things in life? 🧘🏽

Resolutions & Goals #

[Tolerance in thinking] Platformer leaves Substack #

Casey Newton on leaving substack. I thought this was a measured response and he went about it the right way. I was especially curious how he’d handle the usual questions around freedom of speech & tolerance in thinking. His FAQ at the end does a good job.

[Self care] Back to Weightlifting #

My transformation from a 100kg (220 lbs) teenager to a 70kg (154 lbs) fit young adult was anything but easy. It wasn’t inspiration but severe back pain that drove me. An elderly chiropractor candidly remarked “you’re the youngest non-injured patient I’ve ever had in my career”. That scared the shit out of me cause that dude was old. I learnt then that the only activity I was consistent with is weightlifting (thankfully).

I’m aiming to regain my former fitness by starting simple. For now, I’m alternating between two full-body workouts that I found on this slapstick YouTube channel.

Next month, I’ll switch it up with a different set.

Signing off #

Thank you genuinely for subscribing or reading my letters. I’d love to always hear more from you.

What would you like to see more or less of — tech insights, programming chatter, personal stories?

I’m finding my way. I’d appreciate all the help.

Until the next one.

Simplify & replace git-number with git aliases

Sat, 27 Jan 2024 20:00:00 GMT

I wrote a blog post about git-number and how useful it was for my command line git usage. In an on-going effort to simplify my lifestyle & setup, I replaced git-number with a few git aliases. I’ll explain how I recreated the functionality in this blog post.

Why replace it? #

Looking at git-number’s source I realize it is written in Perl. I’m not here to cast judgement on another programming language but reading the code, it felt like overkill for my use cases.

It also meant I could eliminate one additional 3rd party library that I have to install every time.

Let’s go ahead and recreate it with some good old unix command line fu.

Building git add `<number>` #

To git add the first file, I have to manually type the entire path git add 0.collapse-categories-into.... This is tedious and error-prone. If your file is nested in a series of directories (like an Android or iOS app), it becomes worse.

With git-number, this is as simple as

git-number add 1
# where 1 stands for the order
# in which a file shows up in git status

Let’s recreate that with a git alias.

# in your .gitconfig file
[alias]
 a = !"a() { <UNIX COMMAND GOES HERE> ; }; a"

The key now is to come up with a unix command that will take in a number and pluck that file for you. Here’s a simple version of that command:

You can now make it a git alias by adding it to your .gitconfig file:

# .gitconfig
[alias]
 a = !"a() { git add $(git status --porcelain | cut -b4- | sed -n \"$1p;$1q\"); }; a"

You can systematically recreate all of the git-number functionality in pure git aliases!

Bonus tweaks #

Over time, I’ve tweaked the above command to a behemoth shell command that accounts for a variety of use cases:

g a - git add all files
g a . - git add all files
g a 2-3 - git add second and third file
g a 3-5 - git add second to fifth file

Here’s what my actual alias is, in all its glory:

# .gitconfig
[alias]
 a = "!f() { \
 if [[ $# -eq 0 || \"$1\" == \".\" ]]; then \
 git add .; \
 else \
 files_to_add=(); \
 for arg in $(seq $(git status --porcelain | wc -l)); do \
 files_to_add+=($(git status --porcelain | sed -n ${arg}p | awk '{print $2}')); \
 done; \
 if [[ $1 == *'-'* ]]; then \
 IFS='-' read -ra RANGE <<< \"$1\"; \
 for i in $(seq ${RANGE[0]} ${RANGE[1]}); do \
 git add \"${files_to_add[$i-1]}\"; \
 done; \
 elif [[ $1 == *','* ]]; then \
 IFS=',' read -ra NUMS <<< \"$1\"; \
 for i in \"${NUMS[@]}\"; do \
 git add \"${files_to_add[$i-1]}\"; \
 done; \
 else \
 git add \"${files_to_add[$1-1]}\"; \
 fi; \
 fi; \
 }; f"

Understanding the command: #

In this day of chat-gpt you don’t need to understand the above command. The idea and how to leverage it, is far more important.

Other git commands? #

An earlier version of me would have put this in a tidy shell script, made it executable & repeatable; then called the script from my gitconfig alias.

A more experienced version of current me knows, I shouldn’t waste more time on prettifying this. It works, is zippy, and fits in my .gitconfig without adding any more dependencies. I’m probably not going to touch this for a long time.

# .gitconfig
[alias]
 a = "!f() { \
 if [[ $# -eq 0 || \"$1\" == \".\" ]]; then \
 git add .; \
 else \
 files_to_add=(); \
 for arg in $(seq $(git status --porcelain | wc -l)); do \
 files_to_add+=($(git status --porcelain | sed -n ${arg}p | awk '{print $2}')); \
 done; \
 if [[ $1 == *'-'* ]]; then \
 IFS='-' read -ra RANGE <<< \"$1\"; \
 for i in $(seq ${RANGE[0]} ${RANGE[1]}); do \
 git add \"${files_to_add[$i-1]}\"; \
 done; \
 elif [[ $1 == *','* ]]; then \
 IFS=',' read -ra NUMS <<< \"$1\"; \
 for i in \"${NUMS[@]}\"; do \
 git add \"${files_to_add[$i-1]}\"; \
 done; \
 else \
 git add \"${files_to_add[$1-1]}\"; \
 fi; \
 fi; \
 }; f"
 r = "!f() { \
 if [[ $# -eq 0 || \"$1\" == \".\" ]]; then \
 git reset .; \
 else \
 files_to_add=(); \
 for arg in $(seq $(git status --porcelain | wc -l)); do \
 files_to_add+=($(git status --porcelain | sed -n ${arg}p | awk '{print $2}')); \
 done; \
 if [[ $1 == *'-'* ]]; then \
 IFS='-' read -ra RANGE <<< \"$1\"; \
 for i in $(seq ${RANGE[0]} ${RANGE[1]}); do \
 git reset \"${files_to_add[$i-1]}\"; \
 done; \
 elif [[ $1 == *','* ]]; then \
 IFS=',' read -ra NUMS <<< \"$1\"; \
 for i in \"${NUMS[@]}\"; do \
 git reset \"${files_to_add[$i-1]}\"; \
 done; \
 else \
 git reset \"${files_to_add[$1-1]}\"; \
 fi; \
 fi; \
 }; f"
 ch = "!f() { \
 if [[ $# -eq 0 || \"$1\" == \".\" ]]; then \
 git checkout .; \
 else \
 files_to_add=(); \
 for arg in $(seq $(git status --porcelain | wc -l)); do \
 files_to_add+=($(git status --porcelain | sed -n ${arg}p | awk '{print $2}')); \
 done; \
 if [[ $1 == *'-'* ]]; then \
 IFS='-' read -ra RANGE <<< \"$1\"; \
 for i in $(seq ${RANGE[0]} ${RANGE[1]}); do \
 git checkout \"${files_to_add[$i-1]}\"; \
 done; \
 elif [[ $1 == *','* ]]; then \
 IFS=',' read -ra NUMS <<< \"$1\"; \
 for i in \"${NUMS[@]}\"; do \
 git checkout \"${files_to_add[$i-1]}\"; \
 done; \
 else \
 git checkout \"${files_to_add[$1-1]}\"; \
 fi; \
 fi; \
 }; f"
 # and so on ...

It took me 5 seconds to add the other commands. I’m not going to waste time tidying it up, cause it just works.

One less dependency in this journey.

Let me help you get to Inbox 0 with Gmail

Mon, 15 Jan 2024 20:00:00 GMT

As penance for that click baity title, I won’t bury the lede. These are the tools you need:

Gmail filters
Simpl.fyi plugin

Read on for specifics and examples.

I’ve tested several email apps — Mimestream, Superhuman, and Hey — but none quite stuck. They either pushed me too far from Gmail’s setup or simply didn’t resonate with me. The closest match was Inbox, until Google notoriously put the kibosh on that.

Imagine my surprise then, when I discovered Michael Legett, (Inbox co-founder) maintained a web extension that tries to emulate Inbox.

One of the obvious benefits of this extension is how clean and actionable Gmail looks now. But aesthetics alone won’t get you to inbox nirvana. It’s the killer feature “Bundles”¹ currently in beta that will.

Simpl.fyi consolidates related emails and organizes them in a collapsible format. For instance, my subscribed newsletter emails are grouped under “news,” while bank related emails are under “bank” and so on. This inline grouping allows me to go through my emails pretty swiftly. I can speed read GitHub/Jira/Calendar notifications and archive them all in one click.

But it gets better… Simpl.fyi Bundles are just Gmail labels and you have complete control of them with Gmail filters.

Simpl.fyi bundles are just Gmail labels

Gmail filters #

Gmail filters allow you to add certain rules and have your emails be tagged with a label.²

You can follow Gmail’s support doc to see how to create basic filters. But this is an advanced class, so let’s have more fun with it.

Gmail advanced filters #

Mix and match conditions #

Gmail filters treat curly braces { } as an OR condition & parenthesis ( ) as an AND condition.

Say I want any email that has the word “receipt” in the subject of the email to be labeled “receipts”, I create the gmail filter with the condition:

subject: "receipt"

Easy.³

But Lyft & Uber also send me receipts and don’t add “receipt” in the subject line. I’d like to include them with this same label. I know Lyft sends their emails from an address no-reply@lyftmail.com and Uber tags their emails as coming from “Uber Receipts”. This filter should catch it all:

{
 subject: "receipt",
 from: {
 "Uber Receipts",
 no-reply@lyftmail.com
 }
}

But say you don’t want to include the receipts from stripe (for some odd reason). I change the filter to add an AND and NOT condition:

(
 {
 subject: "receipt",
 from: {
 "Uber Receipts",
 no-reply@lyftmail.com
 }
 },
 -from:@stripe.com
)

This should allow you to target any email with a variety of conditions.

Use Gmail’s categories #

At some point in time, Gmail had its own “categories” like “Travel”, “Purchases” etc. They do a pretty good job filtering your incoming mail picking up on a lot of these filters. If you want to leverage those in your filters. For example here is my filter for all “travel”.

category:travel OR from:{aa.com, delta.com}

Couple of notes:

American & Delta weren’t caught by the category, so I used the previous tip and included them forcefully
Gmail filters are forgiving with the syntax, so I’m intentionally showing a less terse way to write this filter. But the good old brackets approach works reliably.
“Travel” is a reserved keyword for category and Gmail won’t allow you to use it as a label. Keen observers will therefore note my screenshot saying “travl”.

Simpl.fyi #

Simplify Gmail is a paid plugin and runs about $2 per month if you go with the annual plan like me. Before you’re scared away by that, I encourage you to give the free trial a shot.

Bundles is just one of many many features that come with it. That alone makes it personally worth every cent for me but there’s a bajillion other customizations that you might fancy.

You can find Michael’s in-depth video about this feature on YouTube. ↩︎
Gmail (in)famously doesn’t do folders, everything is just a label. ↩︎
I’ve found entering my entire criteria in “Has the words” is enough. ↩︎

letter.kau.sh – 2024 Jan

Wed, 03 Jan 2024 18:48:58 GMT

Why start a newsletter when I have a blog? I love writing and I want to write more. But I want a more casual format, where I can share without the burden of permanence or meticulousness that a “blog post” demands.

While I continue to use social media, like others I remain skeptical of its future as a reliable destination for this sort of writing.

What to expect #

Think of this truly, as letters from me to you. I intend to share quick tips and tricks; helpful software I’ve installed and am using; hardware that I’m trying out and recommend; books, blog posts or other newsletters that I’m reading; thoughts on what’s going on in my personal life; lessons and learnings.

I want to be brave with ideas and opinions that are still baking in my head… but could also turn out wrong.

What is the format #

I don’t know if I want to keep these posts short but I promise to keep them as easy reads. The newsletters I love, share this quality.

I’m aiming for a monthly cadence and will nest these under /letter but it should also show up in the general feed. You’re under no obligation to read these btw if all you want are the regular posts. Since I use my own theme for this site¹ there’s ∞ flexibility. You can choose a customized feed based on your liking:

/feed.xml — all the stuff I write
/blog/feed.xml - “blog posts” only
/letter/feed.xml - “newsletter” only

Slap /feed.xml (or /feed.json) at the end of most urls here, and you’ll get a feed for that topic (e.g. my posts on programming are at /tags/programming/feed.xml)

If you’re an email gal/guy on the other hand, open this page in a browser and all the way at the bottom is a way to add your email to a list. You’ll get these letters in your inbox, as soon as I post them.

Let’s kick this off! #

Happy 2024 🥳! If you haven’t noticed, I’m big on new-year posts and resolutions. Here are my resolutions for 2024:

Brevity in writing #

I want to get better and sharper with my writing.

Two books that are classics that I should dust off and read again: Elements of Style & On Writing Well. I follow the social media account tech emails. In addition to the 🍿 I’m impressed by the brevity with how the top executives correspond and write. No superfluous adverbs or flowery adjectives. I remember an online discussion² where people questioned, “Why do these leaders write like this? Feels bizarrely direct and grammatically lacking or incomplete”. An interesting response went something like this: “these people cannot afford to be misunderstood, so are as direct as possible. They dispense with flowery & verbose language, and even with grammar at times, if it gets the point across better”. Not saying I want to emulate this but I’d like to improve my own writing for clarity.

Tolerance in thinking #

I want to have healthy discussions with people having differing opinions.

We live in a polarized time where if someone holds a differing ideology, everything that comes out of their mouth must be wrong or opposed. Over the 2023 Xmas holidays, I was watching The West Wing since it’s one of those shows that’s recommended highly. It reminded me of Sorkin’s The Newsroom which came out later and is one of my favorites. I love how this idea is pushed in both shows. Why can friends not hold opposing ideologies today? How can we be more graceful in debate?

Focus on self care #

I will carve out time and be conscious about my self-care practice.

I was actually inspired by one of my colleagues on this one. Self care is about making sure you’re spending time to do things that inspire and invigorate you. Self care can be fitness, it can be watching that TV show that only you seem to like in your family, it can be eating healthier, it can be taking the time to talk to a therapist or a friend more equipped to listen. What it shouldn’t be… is an after thought.

New ventures in tech #

I have two new ideas³ in this space that I’d like to make a reality.

Fragmented — the podcast I started with Donn is on a hiatus⁴ of sorts. But I’ve been cooking something else in the background, so stay tuned. I’m not ready to share more just yet but I’ve been thinking about these for sometime now and am excited to see them materialize in 2024.

Thank you genuinely for subscribing or reading my newsletter. I’d love to hear more from you too. What are your resolutions for 2024?

that I’ve open sourced btw ↩︎
can’t to find it now. ↩︎
details to come in the future 😉 ↩︎
more on that soon too. ↩︎

Slashed 0 in IBM Plex - freeze alt. characters in otf fonts

Mon, 27 Nov 2023 01:41:42 GMT

OpenType fonts have font features or variants that you can use to represent certain characters differently.

For example, my beloved IBM Plex Mono¹ has quite a few alternative glyphs to pick from:

I prefer the single story “g” and slashed “0” characters for clarity. But you’ll find no obvious way to turn these version of the characters on permanently. After searching and trying quite a few ways to do this, I found an approach that works pretty well.

This blog post will explain how you can pick alternative characters that come with certain open type fonts like IBM Plex Mono and build a version of the font that will permanently switch these alternative character variants on.

Step 1: obtain the complete .otf font file #

It’s important to have your source .otf file have the complete list of characters. If your font doesn’t have these to begin with, this approach will not work. As an example, IBM Plex Mono’s full otf can be downloaded here.

Step 2: identify the alternative character sets you want #

Upload your font to wakamaifondue.com. You’ll get a neat summary of your font and all the available features variants.

Step 3: use pyftfeatfreeze #

pyftfeatfreeze is a fantastic open source tool that allows you to create a new version of your font with the specific set of alternative characters chosen.

Here’s the entire set of commands I used to generate my variant of IBM Plex Mono:

#!/bin/zsh

fontSuffix="KG"

# create a new directory for your font
mkdir -p "IBM-Plex-Mono-$fontSuffix"

# change to directory that has original otf font
cd IBM-Plex-Mono

# install the tool
pipx install opentype-feature-freezer

# Pick the right combination of stylistic characters


# By default IBM Plex Mono ships:
# Regular - styled g; styled a (with caps)
# Italic - plain g ; plain a (without cap)

# I prefer keeping it all consistent
# so I change my italic fonts to also have the styled versions of g/a


# In the non-italic versions of IBM Plex Mono, change
# ss03 - slashed 0
for f in $(fd -HI ibmplexmono -e otf -E '*Italic.otf'); do
 pyftfeatfreeze -f "ss03" -R "Mono/Mono $fontSuffix" -v $f "${f%.otf}.kg.otf"
done

# In the italicized versions of IBM Plex Mono, change
# ss01 - use stylistic variant of a (with the hat)
# ss02 - use g with a cap
# ss03 - slashed 0
for f in $(fd -HI Italic.otf -e otf); do
 pyftfeatfreeze -f "ss03,ss01,ss02" -R "Mono/Mono $fontSuffix" -v $f "${f%.otf}.kg.otf"
done

# cleanup, rename and open the directory
mv *.kg.otf ../"IBM-Plex-Mono-$fontSuffix"/
cd ../"IBM-Plex-Mono-$fontSuffix"/

for f in *.kg.otf; do
 mv $f "$(echo "$f" | sed s/"\.kg"/"-$fontSuffix"/)"
done

open .

I’ve created a repo

Double click the fonts and you have a customized version of IBM Plex Mono installed!

Bonus #

If you just want the same version of IBM Plex Mono that I use, install it from my homebrew tap directly:

brew tap kaushikgopal/tools
brew install --cask font-ibm-plex-mono-kg

which I continue to use as my preferred monospace font for programming. ↩︎

Toggle window snapping with Keyboard Maestro

Sun, 16 Jul 2023 19:22:07 GMT

Shopify CEO Tobi Lütke in a tweet last year mentioned why he uses the Rectangle app even through Raycast has some of these options already. Rectangle allows you to “toggle” the window to different positions.

I was inspired by this and wanted to be able to do the same. But in keeping with my theme to Simplify, I didn’t want to add a new tool to my arsenal.

Keyboard Maestro¹ to the rescue!

This set of macros allow you to toggle between a few states:

Toggle to the left ½ ¼ ⅔ of the screen (with the same shortcut)
Toggle to the right ½ ¼ ⅔ of the screen
Toggle full screen and back
Toggle to the center of the screen and back
Toggle vertically

Download the Keyboard Maestro Macro group here.

referral link ↩︎

Supercharge Kscript with Github Copilot

Sun, 07 May 2023 01:25:34 GMT

One of the gifts we got from Kotlin 1.3.70 was the ability to effortlessly run a kscript (Kotlin script) from the command line. All you need to do is add the suffix .main.kts.

Seriously, this is all you need to do:

brew install kotlin

echo '#!/usr/bin/env kotlin' > hello-world.main.kts

chmod +x hello.main.kts
./hello.main.kts

# 💥

With this 0 friction setup, there’s little reason for me to ever write a bash script again. I get to write my script in Kotlin — a modern & beautiful language. But slap on Github Copilot and I think we’ve unlocked the holy grail of quick scripting.

To prove my point, I recorded a video live coding a script tackling a moderately involved task. Here’s what I wanted to do:

Take a directory path as argument
Make sure it’s valid and has at least one .md (markdown) file in it
Search the front matter for the “categories” array
pluck all the categories from all the files
de-duplicate, sort and print them out

The entire thing took less than 4½ minutes. This is including me figuring out how to get autocomplete working in my IDE, restarting it etc.

Sure I could try to wield a one-line command and do the same thing for this use case but it’s so much nicer in Kotlin.

If you’re intrigued, feel free to checkout my github repo of kscripts. I try to tackle a variety of common use cases in there

P.S: The text snippet I use in there kscript;; basically gives me a starter hello world template. Not cheating, I promise.

The magic that is Zakir (👂🏽) and his Tabla

Sat, 06 May 2023 02:10:55 GMT

One of my resolutions this year was to start picking up the Tabla again¹ courtesy a not so gentle nudge from my supportive partner.

This has obviously led me to scouring Youtube for videos of the great maestros. Ustad Zakir Hussain is one of them.

Here’s a few videos from my collection with some context explaining why he’s a gift to the world of music.

What is the Tabla? #

If you want to get a quick peek at this supremely delicate Indian percussion instrument here’s a starter video.

Zakir (👂🏽) is worshipped like a rockstar in the Indian classical music scene. A video of literally the start of the concert where the audience goes nuts.

Zakir (👂🏽) helping the sound guy out #

After tapping the stage he says “Low-Mids Thoda Kam Karo” (reduce the low-mids a little). Just from hearing the acoustics of the stage he’s able to tell the sound guy to reduce the low-mids. You have to be a master of sound to be able to do that.

Zakir (👂🏽) messing with the sound guy #

Doesn’t get flustered or annoyed. His child like curiosity with the moment gets him to use it as a prop for his show.

Respect for other maestros #

He is without doubt considered one of the grand masters of the Tabla even by most of his peers. But he doesn’t let it get to his head. Here’s how he reacts when he meets some of his contemporaries.

Pandit Yogesh Samsi btw learned under the tutelage of Zakir’s(👂🏽) father — Ustad Allah Rakha Khan .² Bonus content: A touching moment between Pandit Yogesh Samsi and Ustad Allah Rakha.

Here’s one with another great Tablist of our time — Pandit³ Anindo Chatterjee.

Another one of those tender moments right at the start. Read the text after the video for context.

Singer Hariharan as a mark of respect says “Ijazat ?” (roughly translating to “permission” in Urdu). While the vocalist is usually the primary performer, the accompanying percussion artist here is one of the most knowledgeable souls in Indian classical music. Zakir (👂🏽) without missing a beat responds “Bismillah” which translates to “by the grace of God”, implying he has no permission to give.

Ok, so what’s with the 👂🏽? #

This comes from an age old practice in India. Addressing teachers, masters or mentors with their names is considered forward and disrespectful - especially true in Indian classical music. So every time the pupil mentions the teacher’s name or plays their composition, they instinctively touch their ear as a mark of respect and an ask of forgiveness if they don’t do the same levels of justice to the teacher’s composition.

While I don’t share much publicly about my classical music background, after coding it’s the activity I’ve spent most of my life pursuing. ↩︎
Yes they’re a family of percussion wizards and before Zakir, his father was considered one of the greatest Tabla players of our generation. ↩︎
Ustad is a title for musical maestros that practice Islam and Pandit for those Hinduism. Countries were divided on account of the differences between these two religions; but not in music ♥️. ↩︎

This year I shall Simplify

Sat, 22 Apr 2023 22:53:13 GMT

I’m always trying out new tools to make my life easier. In a cruel twist of irony however, I’ve found myself customizing and maintaining multiple tools leading to unnecessary complexity and a hit in productivity.

So this year, I’ve made a resolution to simplify and eliminate redundant tools. Nothing is safe from the chopping block!

Here are some of the major transitions I’ve made or plan to make, and I’ll be sharing more about each of them in upcoming posts.

Things 3 → Obsidian Notes #

This one surprised me the most. I switched from Things 3 as my Todo app and Obsidian for my notes to using Obsidian for both. While Things 3 has a beautiful UI, I discovered that I could use Obsidian as effectively (if not more) to get things done with the addition of one plugin. Stay tuned for a detail write up on this one.

iTerm → Terminal #

Next, I switched from iTerm to Terminal. This transition was easy since I wasn’t relying too heavily on iTerm customizations anyway. The big reason I used iTerm was mostly just for horizaontal split tabs. I dusted off my tmux skills and now am back to just using Terminal.app.

fish → zsh #

Moving from fish to zsh — on the other hand — was the most challenging transition since I had years of accumulated scripts and functions that I had to painstakingly port over to zsh. However, I’m happy I made the change since zsh is the default on a new Mac, making it easier to use across different devices.

Alfred + Keyboard Maestro (+ Pastebot) → Raycast #

As an avid user of Alfred and Keyboard Maestro, I was hesitant to switch to Raycast. But after watching a video on its capabilities, I realized that Raycast could replace several of the tools I was using. I was particularly impressed by how easy it was to expand its functionality and add new snippets or quick URL searches.

Keyboard Maestro is going to be around for those quick automation macros but I’m going to try and not have it running constantly. More for one-off automation jobs.

VSCode → (Neo)Vim (& Jetbrains) #

While I initially switched to VSCode because of its excellent plugins, I found myself using Jetbrains editors like Intellij and Android Studio more frequently. Additionally, I’m already super comfortable with Vim, so the few times I would use VSCode for text editing, there was no good reason not to just use Vim. With the introduction of Intellij “light mode”, I found myself just using Jetbrains editors more often. So, I’m slowly weaning myself off of VSCode.

Not just Software! #

I’m also applying the principle of simplification to my hardware and day-to-day physical setup. However, I don’t substitute a tool that performs well just because I have another that does something else. The key is to find a balance and ensure that using a tool brings joy and value.

Tootbot for Mastodon

Sat, 04 Feb 2023 03:00:00 GMT

Every time I create a new post in this blog I like to toot or tweet about it. Instead of manually doing this, I have my Mac Mini run a little shell script on a cron job, that does this automatically for me.

You can download the source for this script over at github. The way it works is pretty simple:

Download my latest blog feed as a json file.
Check for any new blog posts.
Compares with a local CSV file that records previous toots.
Posts new toots to Mastodon¹

Running the script is trivially easy (and it’s all in Kotlin) so it’s easy to follow the logic. All you need to do to run this script is:

brew install kotlin
kotlin tootbot.main.kts

That’s it! Just remember to update the variables at the top of the file.

Not doing Twitter for obvious reasons. ↩︎

Own your online presence - Step 1 ☝️

Fri, 03 Feb 2023 03:13:13 GMT

Owning your content and where you put it is crucial in the online world. The first step to establishing your corner on the internet is to choose a domain name.¹

After obtaining a domain name, many people only set up a website. However, I recommend taking the next step of creating subdomain redirects for your social media handles.

By Cloudinary, CC BY-SA 4.0

For example, when mastodon.social suffered a DDoS attack, I moved to hachyderm.io,² but the mastodon link I hand out to folks remained unchanged.

How you ask? It’s mastodon.kau.sh and I control the redirect. I just switched it intenally from mastodon.social/@kaushikgopal → hachyderm.io/@kaush.³

This is also why I am not terribly worried about changing my handles on Github, Twitter, LinkedIn, or YouTube, as I have redirects for all of these:

To take control of your online presence, buy your own domain, adjust your DNS settings,⁴ and start using your own URLs. It’s a simple first step with a big impact.

After many many attempts, I landed on one that I liked. I use namecheap (referral code) ↩︎
It was already on my mind to be honest and I guess this was the push I needed. ↩︎
The added benefit is that I don’t have to remember or type Mastodon’s unattractive URLs. ↩︎
Cloudflare makes these trivially easy. ↩︎

Share your macOS audio with multiple multiple bluetooth headphones or Airpods

Sun, 29 Jan 2023 05:27:58 GMT

When I travel on airplanes, I prefer to download content onto my 14" Macbook¹ so I can watch it offline during the flight. When my wife travels with me, we like catching up on some of the shows that we like to watch together.

But we both have our own pair of Airpods that we’d like to use to listen to the audio together. In the wired headphones days, I’d carry a headphone splitter that we’d plug both of our wired headphones into.

Courtesy: Wikimedia

This blog post provides instructions for the equivalent solution in our wireless/bluetooth headphones world.

Software #

I’m going to use Rogue Amoeba’s excellent solution Loopback in the below instructions. I’m pretty sure you can also use Soundflower, the native “Audio MIDI setup” app or other solutions. But Loopback makes this ludicrously easy.

Step 1: Pair headphones to the Mac #

Pair each of the headphones individually to the Mac (as you typically would).

After pairing the first set, you might have to disconnect them (temporarily) and proceed to pair the second set individually.

Step 2: Create a Virtual multi-output device #

Create a new virtual device in Loopback ²

Step 3: Add both headphones to the output channel #

Gen2-2023 is the bluetooth headphones I use in the below instructions. Add both headphones to the Output channels.

If you’re wondering how both headphones connect directly, chalk it to the wonders of the Mac. While the first headphones is connected, connect your second pair (without disconnecting the first) and they both should be connected.

You probably will still only hear the output from one of the headphones, but we’re almost there.

Step 4: Switch Mac audio to new virtual device #

If you’re all aboard the Rogue Amoeba wagon, Soundsource is another app they maintain, that makes it trivially easy to switch audio sources. For someone who keeps switching workstations, podcasts etc. this is delightful software.

Step 5: Play & Enjoy #

Loopback also allows you to control volumes separately which is a godsend when you have two picky people.

An iPad would probably be better but I remain a iPhone + Macboook only kind of guy. ↩︎
This would be a “Multi-Output device” in the Audio MIDI app but Loopback simplifies these distinctions. ↩︎

2022 Retro

Sun, 01 Jan 2023 07:00:00 GMT

Looking back at 2022 #

🎉 Bought a new home 🤯 2022-02-22
Joined Caper as Head of Android
🙈 Got Covid
Put productivity system in place
Setup Mac Mini server, Tailscale & Homebridge
Introduced Henry 2.0 & major updates to the blog
Moved domain name over to kau.sh

2022 Goals #

✅ Moved from goofy jkl.gg → kau.sh
Make home smarter
- ✅ Automated blind shades
- ✅ Clean network topology (LAN in all rooms)
- Smart Alarm
- Video Camera feed inside
- ✅ Unify all of existing systems with Homebridge
Resume Fragmented
Learn to play two songs on the Piano
Learning Kotlin Coroutines by example
Revive TrueTime from the dead (Kotlinify + new algorithm)
Health & Fitness
- get to 170lbs (started the year at 185lbs)
- go from 36inches → 32inches

2023 Goals #

(Hobby) Fix & start playing my Tabla
(Health) Play Tennis once a week
(Learning) Read 6 books this year
(Programming) Revive TrueTime from the dead (Kotlin-ify + new algorithm)
(Programming) Learning Kotlin Coroutines by example
(Programming) Henry 2.0 updates

A few Kotlin constructs

Sun, 27 Nov 2022 12:12:29 GMT

A few Kotlin constructs have been introduced into the language over time. I wrote this post as a personal/public service advisory to remind us of their significance.

Would love to credit img owner

1. fun interface (SAM) #

Many languages (like Java) did not initially treat functions as first-class citizens. They would emulate this functionality by using an interface with exactly one abstract method (a.k.a Single Abstract Method or SAM) interfaces.

fun interface OnClickListener {
 // single abstract function
 fun onClick(view: View)
}

fun Button.setOnClickListenerXXX(listener: OnClickListener) {
 // listener then invoked at some point
 listener.onClick(this)
}

When fun interface is used like the above, we typically must pass an instance of an object that implements this SAM interface.

val clickListener = object: OnClick {
 override fun onClick(view: Button) {
 Toast.makeText(context, "Button 1 Clicked", Toast.LENGTH_SHORT).show()
 }
}

// You can now "pass this function" around
myButton.setOnClickListenerXXX(clickListener)

In practice, modern JVMs allow a far less verbose version of the above via lambdas:

myButton.setOnClickListenerXXX { view ->
 Toast.makeText(view.context, "testing 1", Toast.LENGTH_SHORT).show()
}

introduced in Kotlin 1.4
official docs
purpose is to achieve first-class functions

1.1. (vs) function types #

Kotlin treats functions as first-class citizens and bakes the concept of “function types” right into the language.

Function types and interfaces are not the same thing but serve a similar purpose (treat functions as first-class citizens). The book Effective Kotlin does good justice in pointing out the nuance between these two concepts.

At a time when lambdas were not properly supported with most modern JVMs, function types were the elegant alternative. This makes it confusing today (the existence of two similar concepts) because they can appear very similar in usage. Let’s compare the two:

// -------------------------
// definition via fun interface
// -------------------------

fun interface OnClickListener {
 fun onClick(view: View)
}
fun Button.setOnClickListenerXXX(listener: OnClickListener) {
 listener.onClick(this)
}

// -------------------------
// definition via fun type
// -------------------------

fun Button.setOnClickListenerYYY(listener: (View) -> Unit) {
 listener.invoke(this)
}

The snippet (View): Unit is Kotlin allowing you to natively define a function as a type (function type? 🤯).

In practice, you’ll find no difference in how the above two snippets are used

myButton.setOnClickListenerXXX { view ->
 // do something with the view...
 Toast.makeText(view.context, "testing 1", Toast.LENGTH_SHORT).show()
}

myButton.setOnClickListenerYYY { view ->
 // do something with the view...
 Toast.makeText(view.context, "testing 2", Toast.LENGTH_SHORT).show()
}

My 2 cents: just use function types when possible.

2. type alias #

Type aliases provide alternative names for existing types. It’s conceptually straightforward and particularly useful when used with longer function type definitions.

typealias MyHandler = (Int, String) -> Unit

// now just use MyHandler as your type definition
// instead of tediously typing (Int, String) -> Unit every time

val myHandler: MyHandler = { intValue, stringValue ->
 // do something
}

introduced in Kotlin 1.1

3. import alias #

The interesting thing with type alias is that you aren’t limited to using it just for function types. You can use it to “redefine” any type (or even shorten awkward long class names):

typealias DropdownView = Spinner // 🙄
typealias AVD = AnimatedVectorDrawable

But this is not the way 🙅. Kotlin has a nicer way to do this called “import alias”:

import android.widget.Spinner as DropdownView
import android.graphics.drawable.AnimatedVectorDrawable as AVD

private lateinit var myDropDown: DropdownView
private lateinit var myAVD: AVD

Another important use of import alias is when you’re trying to disambiguate between multiple types with the same name. Say you have a type defined with a generic name but you also have a protobuf library autogenerating a different class with the exact same name. It’s possible to use both types within the same class by disambiguating them using import alias ¹:

import java.sql.Date as SqlDate
import java.util.Date as JavaDate

val date1: SqlDate = SqlDate(0)
val date2: JavaDate = JavaDate()

4. value class #

This article explains why we need value classes (and why we should stop using type alias or data class in these situations).

This is the gist:

fun auth1(userId: Int, pin: Int): Boolean

val u: Int = 909
val p: Int = 1234

auth1(u, p)
auth1(p, u) // ⚠️ no compilation error

See the problem here? Both userid and pin are of type Int but serve different intents. Wouldn’t it be nice if the compiler told us that we were passing the wrong fields? You can solve this with some good engineering and data class:

data class UserId(val field: Int)
data class Pincode(val field: Int)

fun auth2(userId: UserId, pin: Pincode): Boolean

val u = UserId(909)
val p = Pincode(1234)

auth2(u, p)
auth2(p, u) // 🛑 error (✅)

This “works” but has one big problem: data class allocations are expensive. With the Int primitive usage we’re dealing with the stack whereas with data class objects we enter heap territory.²

We could use type alias and avoid the allocation cost. But we run into the original issue viz. no compilation error:

typealias UserId = Int
typealias Pincode = Int

fun auth3(userId: Int, pin: Int): Boolean

val u = UserId(909)
val p = Pincode(1234)

auth3(u3, p3)
auth3(p3, u3) // ⚠️ no compilation error

To solve this issue, Kotlin introduced the concept of “value classes” in version 1.5:

@JvmInline
value class UserId(val field: Int)
@JvmInline
value class Pincode(val field: Int)

fun auth4(userId: UserId, pin: Pincode): Boolean

val u = UserId(909)
val p = Pincode(1234)

auth4(u, p)
auth4(p, u) // 🛑 error (✅)

This is similar to data class but the difference is that underneath the hood, there’s no allocation costs 💪. So why not just use value class always instead of data class? Not so fast Scott, value class can only take in a single primitive field so there’s very legitimate reasons when you should be using a data class instead.

introduced in Kotlin 1.5
previously called “inline class”
@JvmInline is temporary and will be removed with Project Valhalla (seriously)

5. data object #

Have you ever tried to print the singleton object during debugging?

object BruceLee
println("Object Bruce Lee is ${BruceLee}")
// Object Bruce Lee is BruceLee@37f8bb67

yuck!

Experimental since 1.7.20 and stable since 1.8.0 Kotlin introduces the concept of “data object”. Think of it as tacking on a nicer .toString() to your Singleton.

data object BruceLee
println("Object Bruce Lee is ${BruceLee}")
// Object Bruce Lee is BruceLee

For the gory details, you can read the KEEP or proposal discussion.

My thanks to Donn for reviewing this post.

Revisions #

/u/Boza_s6 pointed out an error in my implication that String would be allocated in the stack. Strings are not primitives so I switched the example to Int for accuracy.
/u/smieszne pointed out that my original example using ImprovedBruceLee as the data object would not output “BruceLee” but rather “ImprovedBruceLee”. As clever as my original example was 🙄, I resorted to just using the class name BruceLee for clarity.

without having to type the full package name over and over ↩︎
To learn more about stack vs heap memory allocation and why stack allocation is less expensive read https://www.baeldung.com/java-stack-heap ↩︎

What does $0=$2 in awk do? learn awk

Sat, 24 Sep 2022 07:22:16 GMT

The trick to understanding awk in all its terse glory is to understand its defaults. I made a screencast explaining how awk works by deconstructing a script I’d previously written for this blog .¹ In this post we’ll look at deconstructing awk’s defaults so we can understand all those one-liner scripts stack overflow solutions throw your way.

The example #

I have a file that contains the version info for my apps and I’d like to extract the first version number in there:

// appVersion.gradle

def baseCode = 30001

def appVersion = [
 product-1 : [
 name: "21.091.420",
 code: baseCode
 ],

 product-2: [
 name: "20.090.300",
 code: baseCode
 ],
//...

// I want to pluck 21.091.420 from this file

The first solution (meh) #

Some quick googling revealed this stack overflow solution which gets us close:

 gawk -F'"' '$0=$2' appVersion.gradle

# -- output --
# 21.091.420
# 20.090.300

I only require the first number though so a quick way² to do this would just be:

gawk -F'"' '$0=$2' appVersion.gradle | head -n 1

# -- output --
# 21.091.420

The problem with solution 1 #

awk is powerful and to reach out to head for that last teeny tiny mile seemed sacrilegious. I want this solution to be pure awk.
What the heck does that incantation gawk '$0=$2' do? ³

The basics #

Let’s try to take that script apart piece by piece:

default input field delimiter #

gawk -F'"' '$0=$2' appVersion.gradle
# ↑
# input field delimiter

If you don’t specify the input field delimiter, awk sensibly defaults to the space character. Let’s try some examples:

echo "Hello kind world" | gawk '{print $2}'
echo "Hello kind world" | gawk -F" " '{print $2}'

# -- output --
# kind

echo "Hello kind world" | gawk -F"," '{print $2}'
# -- no output --

Notice how the line is split into numbered “segments” where $1, $2, $3 hold the first three words in our example respectively. $0 represent the entire line.

default syntax #

If you watched my screencast you’ll remember that awk’s general syntax is as follows:

awk '
 BEGIN { a1; a2; a3; } # optional # runs once before input
 <pattern1> { a1; a2; a3; } # action block (mandatory) # run if pattern1 matches
 <pattern2> { a1; a2; a3; } # action block (optional) # run if pattern2 matches
 END { a4; a6; } # optional # run once after input
' <filename>

Most awk one-liners typically don’t use the begin & end blocks.

So looking back at my simple one-liner:

echo "Hello kind world" \
 | gawk ' { print $2 }'
# ↓
# action block ✅

🛑 ✋ but wait, what’s going on with the original one-liner 👇?

gawk -F'"' '$0=$2' appVersion.gradle
# ↑
# 🤔
# is this a <pattern>?
# is this an action block?

For this, we need to understand how the awk <pattern> recognition works:

# general syntax
gawk '<pattern> { a1; a2; a3; }'

echo "Hello kind world" \
 | gawk '0 { print $2 }'
# ↑
# forcing result of <pattern> match as 0 (false)

# -- output --
# no output

echo "Hello kind world" \
 | gawk '1 { print $2 }'
echo "Hello kind world" \
 | gawk '2 { print $2 }'
echo "Hello kind world" \
 | gawk '3 { print $2 }'
# ↑
# forcing result of <pattern> match as 3 / non-0 (true)

# -- output for all the above --
# kind

So the way that <pattern> condition matching works is if awk sees 0 ⁴ the pattern match condition is “false” and awk ignores the action block. Anything > 0 and awk treats the condition as “true” and executes the action block. Ok back to the one-liner:

gawk -F'"' '$0=$2' appVersion.gradle
# ↑
# is this a valid pattern?
# ✅ we're getting some non-0 value
# cause things are being printed
# is this an action block? 🤔

So $0=$2 is coming back with a result of > 0 and some invisible default is being executed. Progress… but still many questions.

default action #

Let’s try some commands. Notice the output for each of them:

echo "Hello kind world" | gawk '0 {print $0}'
echo "Hello kind world" | gawk '0 {print}'
echo "Hello kind world" | gawk '0'
echo "Hello kind world" | gawk ''

# -- output --
# no output


echo "Hello kind world" | gawk '1 {print $0}'
echo "Hello kind world" | gawk '1 {print}'
echo "Hello kind world" | gawk '1'

# -- output --
# Hello kind world

So when the <pattern> match is false (0) nothing is printed and when it is 1 then the default is to just print the entire line ($0). In fact you don’t have to specify anything and awk assumes you want to print $0 by default.

variable reassignment #

You know how we glorify immutability with most programming? awk ain’t having any of that.

You can mutate the heck out of anything. You can mutate the current line before you even run an action on it. Check this piece of code out:

echo "Hello kind world" | gawk '{print $0" <-> "$1" <-> "$2" <-> "$3}'

# -- output --
# Hello kind world <-> Hello <-> kind <-> world
# ↑ ↑ ↑ ↑
# $0 $1 $2 $3

echo "Hello kind world" | gawk '1 {$0="hijack"; print $0" <-> "$1" <-> "$2" <-> "$3}'
# -- output --
# hijack <-> hijack <-> <->
# ↑ ↑ ↑ ↑
# $0 $1 🙅 🙅

Even before the action block is executed you can reassign the entire line.

number of fields #

Here’s the last piece that should help bring this all together. Given this file again:

// appVersion.gradle

def baseCode = 30001

def appVersion = [
 product-1 : [
 name: "21.091.420",
 code: baseCode
 ],

 product-2: [
 name: "20.090.300",
 code: baseCode
 ],
//...

gawk '{print NF ": "$0}' appVersion.gradle

# -- output --
# 0:
# 4: def baseCode = 30001
# 0:
# 4: def appVersion = [
# 3: product-1 : [
# 2: name: "21.091.420",
# 2: code: baseCode
# 1: ],
# 0:
# 2: product-2: [
# 2: name: "20.090.300",
# 2: code: baseCode
# 1: ],

NF in awk stands for number of fields.
awk takes the input field separator and stores the “number of fields” discovered in that variable.
Notice above that when there’s an empty line NF is 0 since there’s no separator (or content) in that line.
On the second line there’s 4 tokens (each separated by space)

The first solution (again) #

All right, let’s do this one last time.

 gawk -F'"' '$0=$2' appVersion.gradle

# -- output --
# 21.091.420
# 20.090.300

What’s happening here is a beautiful symphony of awk defaults stacking on top of each other.

We first reassign the variable holding the entire line ($0) to $2. Remember that $2 holds the second word/token after splitting the original content in $0 with the input field separator ". This should help point out the resulting fields with the new field separator:

 gawk -F'"' '{print NF ": "$0}' appVersion.gradle
# 0:
# 1: def baseCode = 30001
# 0:
# 1: def appVersion = [
# 1: product-1 : [
# 3: name: "21.091.420",
# 1: code: baseCode
# 1: ],
# 0:
# 1: product-2: [
# 3: name: "20.090.300",
# 1: code: baseCode
# 1: ],

First line of this file is empty, so $2 is 0 and $0 is assigned to 0.
Second line of this file has only one segment (since there’s no ") and is stored in $1. $2 is again 0 and $0 is assigned to 0.
Sixth line has 3 tokens, $2 is 21.091.420 and is assigned to $0.

The original command should make sense now:

 gawk -F'"' '$0=$2' appVersion.gradle

# -- output --
# 21.091.420
# 20.090.300

The <pattern> match condition provided to awk is the output value of $0=$2
- From the previous command output we noticed that for the first, second lines up until the sixth line, was all 0.
- when awk sees 0 it ignores the action and there’s no print
The sixth line is the first time we encounter a non-0 value, so the action block is executed.
- what is the default action? print $0
- what is $0?
  - the second token or segment $2 (after field separator ") which is 21.091.420

💥

This is really such a gorgeous piece of code. Clever and poetic.

The final solution #

If you’re curious how I came up with my own solution, I made it a little less clever, more verbose and hopefully now simpler to understand:

gawk -F'"' 'NF==3 {print $2; exit}' appVersion.gradle

# -- output --
# 21.091.420

Go forth and awk.

If you want to understand the fundamentals of awk first, I recommend that screencast. ↩︎
a.k.a practical and the one I’d recommend to others on a time crunch. ↩︎
down the 🐰 hole we go ↩︎
In awk land 0 = false, anything > 0 is true ↩︎

Operating efficiently at scale

Tue, 23 Aug 2022 06:23:32 GMT

Great companies maintain their insurgent mindset, for fear of becoming complacent and irrelevant over time.

Push decision making down to single-threaded DRIs

Single-threaded is tech jargon that simply means solely focused on a single area. The single threaded DRI is the most senior person whose only job is to run a given product or initiative, this will typically be a product management or engineering leader.

Leverage shared services to minimize duplication

Done wrong, shared services can slow down and frustrate product teams. But when they work well, they can create amazing synergies between products, and deeper product integration. Product teams should not be required to use a half baked shared service. But once a shared service is mature, all products may be required to use it.

… When it becomes clear that we are duplicating effort or creating an inconsistent user experience across our products, services need to graduate into clearly decoupled services that any product can leverage.

Organize teams into small pods Small teams are more efficient. … We’re beginning to deploy a new concept that we call “pods” to create more structure around the appropriate size of a team.

Pods also need to have a focus, and a north star metric that ties into the overall company metrics.

Ship products not slide decks

Maintain an insurgent mindset

Ultimately, a lot of this comes down to retaining the founder mentality inside the company and acting like owners.

What a Mac mini & Tailscale enables

Sat, 20 Aug 2022 20:55:35 GMT

I’d like to show you how I use Tailscale and a Mac mini in my office to achieve some nifty things.

Tailscale is marketed as a zero-config VPN built on top of WireGuard that securely connects devices and manages firewall rules etc. While all of that might be true, think of it this way: Tailscale allows you to securely connect to a machine at home from anywhere on the internet. This includes your mobile phone, tablet, or laptop.

Tailscale allows you to connect to a machine at home from anywhere on the internet (securely) from your phone/tablet/laptop.

Basic idea #

For me, that “machine” is a souped-up Mac mini sitting on an office shelf at home that is never turned off. This Mac mini is the linchpin of my setup, really.

I install¹ Tailscale on this Mac mini and all the other devices I wish to connect from. With the magic of Tailscale ✨, all these devices are now connected like they were on the same network! If that hasn’t sunk in:

I could literally connect to the Homebridge server on my Mac mini in California from an Android phone while traveling in India.

Let’s talk about some services you could run leveraging this setup.

Private blog server #

I use the static website generator Hugo (& Henry) for this site.

Hugo has this nifty feature called live reload when you run it on a local machine. If I change any part of my website,² it instantly shows me an up-to-date preview. I typically edit my “draft” blog posts like this, so I can see the changes right away. But you don’t run your real website like this.³

Gosh, if only I had a private server that only I could connect to on the internet.

With Tailscale on my Mac mini, I now do.

For the technically curious: I edit files directly on a folder on the mini using VSCode.⁴ I then run a hugo server⁵ which watches for changes in this folder. Hugo picks it up and serves a live preview on a private port on the Mac mini. And because this is just a “local” address & port (courtesy Tailscale), I can connect to it from any of my devices.

I’m sipping coffee in hipster cafes editing my site, then clinging on to dear life in a Muni bus, reading that draft on a phone browser. Magical!

FreshRSS (RSS feed) server #

RSS is old but remarkable technology. I use it as my throttled way of consuming the internet (blog posts, youtube videos, podcasts, etc.).

I previously used Feedly but then switched to iCloud.⁶ But iCloud is dog slow for this. So I spent a few hours one weekend installing FreshRSS on my Mac mini. I now have an open source, super fast RSS service accessible (to me) from anywhere on the internet.

Homebridge #

After purchasing a home recently, I set out on a mission to smartify all the things. Lights, doorbells, smart locks, window shades, garages, security cameras, alarm systems, and even the washing machine!

I use a Homebridge server on the Mac mini to connect all these devices. One of the problems though is you can typically only access homebridge from within the same wifi network (which is usually a good thing). But occasionally, I’d love to turn off my light switches or lower the shades as I rush to the airport. Turn on Tailscale, and I can connect to the Homebridge server directly from my phone.

Plex media server #

Plex is a media server that allows you to “stream” content from a local disk or hard drive to any network. This includes (massive) family photo albums, high-quality Blu-ray rips⁷ of my favorite movies, audio music that isn’t on Spotify from artists I’ve worked with, etc.

Plex, in theory, allows you to expose this media server to the internet directly (and this is how most people use it). For obvious reasons, I prefer not exposing this server to the internet, even with authentication. Instead, I now connect to this Plex server via Tailscale. I can stream it on my phone and then just Airplay/Google Cast it to a hotel TV.

Tailscale is magical technology. It feels like the iPhone in a VPN world of flip-phones.

I’ll keep updating this post as I come up with more use cases.

The installation really is “zero-config”. I still don’t understand how easy it is to install it. I’m not even going to talk about it in this post cause you can just look at the official instructions. ↩︎
like css styles or markdown post content ↩︎
this would require a “server” that’s costly + requires more resources. The whole point of Hugo is to “statically” generate pages that are much lighter. ↩︎
via ssh ↩︎
that runs inside a docker container ↩︎
free & no ads ↩︎
that obviously fell out of a truck ↩︎

My new programming font - Recursive

Fri, 19 Aug 2022 07:00:00 GMT

I’m always looking for legible, high-quality monospaced fonts for programming. I started with IBM Plex Mono, dabbled with a few others like Input Mono, even built a few from source like Iosevka, fell in and out of love with various others.

In early 2020, the foundry ArrowType released Recursive which has now become my daily driver.

What really got me hooked with Recursive — besides it being a gorgeous typeface — was the fact that it was open source and you could build it from source yourself (like Iosevka).

Here are the customizations I’ve made for myself:

Download Recursive #

I could keep extolling the virtues of this font but if you’re curious to just download and try it, here’s a couple of ways:

Go to the main website and hit the big blue “Get” button.
If you prefer my variant and are on MacOS:

brew install --cask kaushikgopal/tools/font-recursive-kg

Or just download it here.

Yearn for the vast and endless sea

Sun, 14 Aug 2022 07:00:00 GMT

If you want to build a ship, don’t drum up the men to gather wood, divide the work, and give orders. Instead, teach them to yearn for the vast and endless sea.

Antoine de Saint-Exupéry

Lessons for Engineering Managers in Software.

High quality vector icons from Yoolk Ninja

Fri, 29 Jul 2022 02:56:42 GMT

Icons by Yoolk

Stumbled upon Yoolk’s website the other day. What a treasure trove of high quality icons. There’s even a github repo for some of these.

Keyboard Maestro as a Text Expander replacement

Wed, 27 Jul 2022 07:00:00 GMT

icon by Yoolk

If you’ve recently needed a text expander utility, might I suggest the trusty Keyboard Maestro.¹

I switched from TextExpander → Alfred quite some time back. Somewhat recently, I again switched from Alfred → KM for a couple of reasons:

1. One tool to rule them all #

Between work & home, I use multiple computers these days. Having to sync + maintain each of these different utilities across multiple computers is becoming tedious.

Keyboard Maestro is a mainstay in my productivity toolbelt and isn’t going anywhere. Might as well double down on it for the things it does well.

2. Fixing app quirks #

One of the big problems I found with utilities like Alfred is that the text expansion would activate too quickly. Consequently, the expansion wouldn’t work in certain apps (like VSCode).

With Keyboard Maestro though, you can add a micro delay,² ensuring the snippets work flawlessly everywhere.

You can also limit the scope to just a few apps if you’re worried this delay will slow you down in non-problematic apps.

3. Mix text expansion with other macros #

Building on that, with Keyboard Maestro, you’re not limited to just text replacement.

You can execute full-fledged macros with your text expansion. Here’s an example of how I add checklists in Google Docs.³

Keyboard Maestro remains one of the most powerful utilities for the Mac.

Referral link ↩︎
I use 0.5s ↩︎
It puzzles me that they haven’t assigned a default keyboard shortcut for this already. ↩︎

Magic enter command for (fish/zsh) shell

Sat, 23 Jul 2022 19:50:31 GMT

Two of the most common commands I run when I cd into a directory are:

git status (which i do through git-number)
ls -lh (aliased automatically as ll through fish)

If this directory is not a git repo, then I usually am thinking of command 2.
If however it is a git repository then
- I’d like to know if any files have been changed in this directory and
- which ones specifically (which is command 1).

Wouldn’t it be nice if I could just hit the ↩ (enter key) and have this automatically happen?

Solution for fish users #

If you’re using fish, I got you covered:

# filename: fish/conf.d/magic-enter.fish
function magic-enter-cmd --description "Issue git status or ls on hitting enter in a dir"
 set -l cmd ll
 set -l is_git_repository (fish -c "git rev-parse --is-inside-work-tree >&2" 2>| grep true) # Special variable indicating git.
 set -l in_root_folder (fish -c "git rev-parse --show-toplevel >&2" 2>| grep (pwd))
 set -l repo_has_changes (git status -s --ignore-submodules=dirty)

 if test -n "$is_git_repository"
 if test -n "$in_root_folder"
 if test -n "$repo_has_changes"
 set cmd git-number
 end
 end
 end

 echo $cmd
end

function magic-enter
 set -l cmd (commandline)
 if test -z "$cmd"
 commandline -r (magic-enter-cmd)
 commandline -f suppress-autosuggestion
 end
 commandline -f execute
end

bind \r magic-enter

Solution for zsh users #

If you’re using zsh, I adapted the native solution like so:

# filename: magic-enter.plugin.zsh
# Default commands
: ${MAGIC_ENTER_GIT_COMMAND:="git-number"} # run when in a git repository
: ${MAGIC_ENTER_OTHER_COMMAND:="ll"} # run anywhere else

magic-enter() {
 # Only run MAGIC_ENTER commands when in PS1 and command line is empty
 # http://zsh.sourceforge.net/Doc/Release/Zsh-Line-Editor.html#User_002dDefined-Widgets
 if [[ -n "$BUFFER" || "$CONTEXT" != start ]]; then
 return
 fi


 is_git_repository=$(git rev-parse --is-inside-work-tree)
 in_repo_root_folder=$(git rev-parse --show-toplevel)
 repo_has_changes=$(git status -s --ignore-submodules=dirty)

 if [ "$is_git_repository" = true ] && [ "$in_repo_root_folder" = $PWD ] && [ ! -z "$repo_has_changes" ]; then
 BUFFER="$MAGIC_ENTER_GIT_COMMAND"
 else
 BUFFER="$MAGIC_ENTER_OTHER_COMMAND"
 fi
}

# Wrapper for the accept-line zle widget (run when pressing Enter)

# If the wrapper already exists don't redefine it
(( ! ${+functions[_magic-enter_accept-line]} )) || return 0

case "$widgets[accept-line]" in
 # Override the current accept-line widget, calling the old one
 user:*) zle -N _magic-enter_orig_accept-line "${widgets[accept-line]#user:}"
 function _magic-enter_accept-line() {
 magic-enter
 zle _magic-enter_orig_accept-line -- "$@"
 } ;;
 # If no user widget defined, call the original accept-line widget
 builtin) function _magic-enter_accept-line() {
 magic-enter
 zle .accept-line
 } ;;
esac

zle -N accept-line _magic-enter_accept-line

Remember to source this in your .zshrc:

source magic-enter.plugin.zsh

Revisions #

Make a change to only check git status in a root folder.
Reddit /u/colemaker360 reminded me that the ^/dev/null redirect strategy is now deprecated with fish 3.
Redditor /u/jblondreddit pointed out that porcelain can be a slow.
Add solution for zsh users

Manipulating images & PDFs using CLI commands

Fri, 22 Jul 2022 03:40:45 GMT

Whenever I need to convert, merge, or combine images or PDF files, I pull out my Terminal and attempt doing it first with CLI (command line interface) commands. Over time I’ve built an arsenal of CLI commands that 9/10 times does the trick faster than any other program.

Prerequisites #

Most of the image manipulation commands require imagemagick and the PDF ones require poppler. Both of which are just a homebrew install away for macOS:

# image utilities
brew install "imagemagick"

# pdf utilities
brew install "poppler"

Merging #

Merge images horizontally/vertically #

# convert ships with imagemagick

## horizontal
convert +append image_1.png image_2.png merged
## vertical
convert -append image_1.png image_2.png merged // vertical

# using montage
# slightly better as it maintains transparency within images

## horizontal
montage 0_index.png 1_post.png -background none -tile 2x1 -geometry +0+0 PNG32:out.png
## vertical
montage 0_index.png 1_post.png -background none -tile 1x2 -geometry +0+0 PNG32:out.png

Merge images and PDFs #

# convert ships with imagemagick
convert 1.png 2.pdf merged.pdf

Merge PDFs #

# pdfunite ships with poppler
pdfunite output-1.pdf output-2.pdf output-3.pdf merged-1-3.pdf
pdfunite output-4.pdf output-5.pdf merged-4-5.pdf

# using native tools that comes with the macOS
"/System/Library/Automator/Combine PDF Pages.action/Contents/Resources/join.py" -o merged.pdf source1.pdf source2.pdf

# using ghostscript [also works with encrypted PDFs]
gs -q -dNOPAUSE -dBATCH -sDEVICE=pdfwrite -sOutputFile=merged.pdf source1.pdf source2.pdf source3.pdf

Splitting #

Split multi-page PDF into single page PDFs #

# pdfseparate & pdfunite ship with poppler

# split input.pdf into output-1.pdf output-2.pdf ... etc.
pdfseparate input.pdf output-%d.pdf
# split input.pdf from page 2 till the end
pdfseparate -f 2 input.pdf output-%d.pdf

Replacing single pages in PDF #

A common usecase is to swap out a single page in a pdf. poppler doesn’t have a readymade command for this, instead i just use pdfseparate + pdfunite for this:

# input has 10 pages; special has 3 pages
# replace pages 5,6,7 in input with special pages

pdfseparate input.pdf input-%d.pdf
pdfseparate special.pdf special-%d.pdf

# using fish shell
for i in (seq 1 4)
 pdfunite input-$i
end

Resizing/Compression #

By % or boundary #

# convert ships with imagemagick
convert -resize 60% src_img.png src_img_reduced.png
convert -resize 128x128 src_img.gif src_img_reduced.gif

Doesn’t overwrite
60% is good for documents
75% is acceptable image quality (though you probably want higher)

By keeping aspect ratio & max dimension #

sips -Z 800 input.png --out output.png

# Z maintain aspect ratio
# 800 max height and width to be used

In directory #

# resize all images in directory
for f in *.jpeg
do
 convert -resize 60% "$f" dest/src_img_reduced.png
done

Converting #

DNG → JPG #

# sips ships natively with macOS
sips -Z 3072 -s format jpeg input.dng --out output.jpg

# Z maintain aspect ratio
# -s format jpeg

Overwrites
Aggressively reduces

PNG → JPG #

# sips ships natively with macOS
sips -s format png input.jpg --out output.jpeg

HEIC → JPG #

# sips ships natively with macOS
sips -s format jpeg input.heic --out output.jpeg

PDF → JPG #

# convert ships with imagemagick
convert -density 150 -quality 100 -flatten -sharpen 0x1.0 -trim input.pdf output.jpg
# 3rd page of pdf
convert input.pdf[2] output.jpg
# convert all pages (2 means 2 digits will show on page count)
convert input.pdf output-%02d.jpg

# pdftoppm ships with poppler
# output is a prefix
# 150 is DPI
pdftoppm -jpeg -r 150 input.pdf output

JPG → PDF #

# convert ships with imagemagick
convert 1.jpg 2.jpg merged.pdf

JPG → (A4 paper size) PDF #

convert -density 80 input.jpeg -background white \
 -page a4 # -page Letter
 output.pdf

JPG → PNG #

# sips ships natively with macOS
sips -s format png input.jpg --out output.png

PNG → WEBP #

# install webp utility
brew install webp

cwebp input.png -o output.webp
cwebp -q 75 input.png -o output.webp
# -q 75 refers to the compression rate.

SVG → WEBP #

# convert ships with imagemagick
convert -background none -density 200 input.svg output.webp

SVG → PNG #

# convert ships with imagemagick
convert -background none -density 1000 -resize 48x is_logo_location.svg is_logo_location.png

PNG → GIF #

# convert ships with imagemagick
convert -delay 5 -loop 0 *.png output.gif

MOV/MP4 → GIF #

# convert ships with imagemagick
mkdir frames
# mov or m4v
# ffmpeg -i input.mov -vf scale=320:-1,format=rgb8,format=rgb24 -r 10 frames/ffout%3d.png
ffmpeg -i input.mov -vf scale=320:-1 -r 10 frames/ffout%3d.png
convert -delay 8 -loop 0 frames/ffout*.png frames/output.gif

# scale [width in px]:-1
# r framerate

Manipulating #

Remove transparency #

# flattens png to a solid color
# mogrify ships with imagemagick
mogrify -background white -flatten input*.png

Get information from image #

Is image transparent? #

# identify ships with imagemagick
identify -format '%[channels]' foo.png

List image dimensions #

identify -format '"%w %h' foo.png

I’ll keep adding more as I discover new use cases.

Saving the world from code

Sat, 18 Jun 2022 07:00:00 GMT

A good friend of mine who’s worked on some pretty pivotal hardware/software integrations for our time told me: “it feels like a miracle when I see the code I wrote drive physical bits. I almost can’t believe it. No seriously… how does this even work?”.

If this sentiment resonates with you to some level, you will love reading this article:

The coming software apocalypse #

This entire article is fascinating. It took a lot of restraint not to just pull-quote every paragraph from this article.

The software did exactly what it was told to do. In fact it did it perfectly. The reason it failed is that it was told to do the wrong thing. Software failures are failures of understanding, and of imagination.

This is the trouble with making things out of code, as opposed to something physical. “The complexity,” as Leveson puts it, “is invisible to the eye.” …“Computing is fundamentally invisible,” Gerard Berry said in his talk. “When your tires are flat, you look at your tires, they are flat. When your software is broken, you look at your software, you see nothing.”

The National Highway Traffic Safety Administration enlisted software experts from NASA to perform an intensive review of Toyota’s code. After nearly 10 months, the NASA team hadn’t found evidence that software was the cause — but said they couldn’t prove it wasn’t. … They showed that as little as a single bit flip — a one in the computer’s memory becoming a zero or vice versa — could make a car run out of control.”

“Visual Studio is one of the single largest pieces of software in the world,” he said. “It’s over 55 million lines of code. And one of the things that I found out in this study is more than 98 percent of it is completely irrelevant. All this work had been put into this thing, but it missed the fundamental problems that people faced. And the biggest one that I took away from it was that basically people are playing computer inside their head. … So the students who did well — in fact the only ones who survived at all — were those who could step through that text one instruction at a time in their head, thinking the way a computer would, trying to keep track of every intermediate calculation”

The programmer, staring at a page of text, was abstracted from whatever it was they were actually making. … “Our current conception of what a computer program is,” he said, is “derived straight from Fortran and ALGOL in the late ’50s. Those languages were designed for punch cards. That code now takes the form of letters on a screen in a language like C or Java (derivatives of Fortran and ALGOL), instead of a stack of cards with holes in it, doesn’t make it any less dead, any less indirect. … the idea that people were doing important work, like designing adaptive cruise-control systems or trying to understand cancer, by staring at a text editor, was appalling

An alternative way of writing code:

This article has forced me to revisit my disdain for WYSIWYG like editors¹

One programmer who saw the talk wrote later: “Suddenly all of my tools feel obsolete.”

When John Resig saw the “Inventing on Principle” talk, he scrapped his plans for the Khan Academy programming curriculum. He wanted the site’s programming exercises to work just like Victor’s demos.

“I’m not sure that programming has to exist at all,” he told me. “Or at least software developers.” In his mind, a software developer’s proper role was to create tools that removed the need for software developers.

Programmers, as a species, are relentlessly pragmatic. Tools like TLA+ reek of the ivory tower. When programmers encounter “formal methods” (so called because they involve mathematical, “formally” precise descriptions of programs), their deep-seated instinct is to recoil.

hello layout inspector ↩︎

My productivity system

Tue, 31 May 2022 07:00:00 GMT

Recently, I killed an entire week moving from Things (3) → Asana → Todoist → Things. I won’t go into the details but I had a realization: I need to jot down how I think about my current system of productivity.

Having this clearly laid out will convince future me that moving to another tool is unnecessary if I follow the existing one I have diligently. I also think it necessary to lay down tactical instructions, so that in my moments of weakness I have something easy to follow and prevent me from going on a futile productivity sojourn.

Challenges #

This system works for me because it addresses specific challenges that I face in getting things done. It’s worth pointing out what my challenges are:

Trapped in burndown continuum #

There are days I’m able to knock out tasks one after the other. I go weeks like a programmed robot knocking out tasks one after another as they percolate into my “Today” list. But I quickly burn out and am unable to go any further in this mode because I feel trapped in a continuum.

I need to see the bird’s eye-view. I need to know why I’m doing what I’m doing. What are the daily tasks in service of? Am I reaching the goals I set out for myself this month or year?

Single task hang up #

There are days I start with 3 tasks to get done. I start working on one of the tasks but get absorbed into it that I forget about the other ones due for the same day. I barely finish the first task; and the others get pushed to tomorrow. Tomorrow comes and the story repeats.

Work expands to fill the time allotted for its completion.

- Cyril Northcote Parkinson

A sense of urgency and being conscious of time spent on a task is important.

Overwhelmed with tasks #

There are days I open up my Today view and find 20 tasks to do – all moderately important and valuable to get done. I didn’t choose to do these tasks. The tasks chose me, engulfed me, invaded my Today view! So I abandon it all and do none of it 🙈.

I didn’t choose to do these tasks. The tasks chose me, engulfed me…

There are other days when I wake up and see the same set of tasks over and over again. Monday, Tuesday, Wednesday … Thursday rolls over, still 20 tasks left. Little progress made and it knocks the wind out of me.

What should I do next? #

There are days I open up my todo app and I just don’t know what to do next. I had ideas for getting things done this year, this month, this week… but where do i start? Have I progressed on my goals at all or am I taking on tasks as they come rushing towards me again?

Strategy #

We always overestimate the change that will occur in the next two years and underestimate the change that will occur in the next ten. Don’t let yourself be lulled into inaction.

- Bill Gates

This quote summarizes well the challenge I face with my productivity system and why it doesn’t work for me consistently: I focus on optimizing the daily/weekly but lose sight of the monthly/yearly.

Judicious use of due-dates #

You should pick your tasks for the day. They should not come for you.

To achieve this, I need to be judicious when picking a due-date/deadline for a task. Picking a date in the future means my todo app will automatically throw that task into my “Today” list in the future. I tend to get zealous and pick dates for when I think I can get the task done but when that ordained day comes around, I’m usually not ready to take on that task.

Few tasks are so important so as to take up valuable future calendar real estate. Here’s a helpful heuristic:

Will you lose money if this task isn’t done?
Will it affect your health?
Will you be backing out of a commitment?
Will it affect somebody else’s health?

Unless the answer to any of the above is a yes, remove that due date. Tuck it gently back into the backlog. If it’s important enough, it’ll crop back up again.

Monthly logs #

Things captures my daily and weekly views. This works.

I track yearly progress with my #new-year posts. This doesn’t work too well. The format itself is ok but compiling it all at the end of the year means I miss a whole bunch of intermediate progress.

The missing piece was tracking monthly progress. Having the monthly check ins along with the daily + yearly ones will help me get a better view into the bigger picture with the visibility to course correct when needed.

I’m planning to use my blog here to track my monthly progress. I even tweaked my theme to accommodate these special kind of posts.¹

Tactical Instructions #

What does this system look like:

#new-year retrospective posts #

At the start of the year:

Track my progress against previous year’s goals.
- Go through my monthly logs and track the highlights.
- Evaluate the lowlights and what I can do better.
List my goals for the next year.
- Create projects (or tasks) in Things for each of these.
- I should see these on my sidebar every time I open Things.
- It is ok to not achieve all of them.

#monthly retrospective posts #

At the end of every month:

Jot down thoughts on how the month went.
- Especially the unplanned highlights/lowlights.
✅ monthly goals that got done.
🙅 monthly goals that couldn’t get done.
Pick goals for the next month.
- Carry over previous month’s goals?
  - It’s ok to throw them into a “someday” bucket.
  - Carrying over a goal or task for a few months now? Think harder about throwing it to the “someday" list.
- Need to make more progress on the yearly goals?

Things #

It’s a gorgeous app with top shelf UX. Stick with it. Sure Todoist has better integrations, Asana allows multiple sub-projects but not valuable enough to shift tools.

If you think of an idea, put all the context in the task and toss it into the Inbox view immediately. Don’t waste time categorizing the task in the right project list or worrying how it fits in your monthly/yearly goals. Mind dump and move on.

The most effective todo system:

Every morning, write a list of the things that need to be done that day.

Do them.

At the start of the day:

Clean your inbox
- If you need to clarify, add more context and details to the task.
- Don’t be tempted to get them done Today.
- Find a proper home in a corresponding project.
Pick the 3 things you need to get done today.
- Why couldn’t you finish yesterday’s tasks?
- Do they need to go to the Someday list?
- Don’t add more tasks if you can’t finish the day with Today 0.
- Are any tasks coming up that are due?

25mt timers #

I wear an Apple watch and every time I embark on a task, I start a 25mt timer. This helps me timebox things. More importantly it gives me a sense of the time I’ve spent on a task. If i’ve completed four 25mt cycles, I need to start thinking about the other tasks.

I’ll let you know how this all turns out.

I’ll update this post with screenshots once I have this system up and going for a few months.

They’re private for now. I might make these public in the future 🤷‍♂️. ↩︎

Remove Terminal.app from Alfred & Spotlight

Sun, 29 May 2022 07:00:00 GMT

I use iTerm as my terminal of choice.¹ It constantly annoys me when I use Alfred or Spotlight that the Terminal.app (native macOS) app also shows up in the search results.

This is especially annoying on new computers when Alfred hasn’t learnt my preferences as Terminal.app would show up first in the results.

Options #

Quick googling shows two options:

Add a Spotlight comment alfred:ignore
Add the app to your Spotlight “privacy”

Option 1 is made a little complicated owing to the fact that you can’t add spotlight comments to native “Utilities” app on the Mac. I managed to do this but this option doesn’t work.

At first, Option 2 might also seem tricky since the file picker doesn’t allow you to pick Utilities apps again. But there’s an easy workaround:

Open Spotlight Preferences > Privacy Tab
Open new Finder window & search for “Terminal.app”
Drag Terminal.app search result to Privacy Tab on Spotlight preferences
type “Reload” in Alfred

Now, whenever I search for “Term”, I only see “iTerm” show up in my search results.

Video #

Why I use iTerm is for another blog post. ↩︎

Introducing Henry for Hugo

Sun, 17 Oct 2021 21:14:04 GMT

Henry is a theme I first open-sourced for Jekyll. You can read all about it here. I’ve now recreated Henry for Hugo.

Why Hugo? #

Over the last year, I’ve been learning Go and my interest in Hugo piqued. Hugo — much like Jekyll — is a static blog engine written in Go. But it’s got more features, a more active community and is blazingly fast.

Features #

Many of the features I wrote as custom features for Jekyll, come built-in with Hugo. But I took the opportunity to tweak these a little further.

Here’s how they’re implemented in Hugo:

Customizability #

A blog theme is only useful if it is versatile enough to reflect your unique character and touch. Henry is extremely customizable. With simple scss override files you can customize the entire look of your blog.

If you look at the main style.scss file in Henry, here’s how we import the different styles:

// themes/henry/assets/scss/style.scss

@import "theme";
@import "mixins", "code", "base";
@import "main";

You can override any of the above files and customize your blog’s look. For example, to change the background color you can override the theme.scss file like so:

// my-blog/assets/scss/theme.scss
@import '../../themes/henry/assets/scss/theme';

// Hook to override predefined variables.
$color-background: #3E4244;
$color-header-index: lighten($color-background, 10%);
$color-header: lighten($color-background, 60%);

To see a demo of the difference compare this blog with my brother’s. Both use Henry but look pretty different.

FootSidenotes #

I picked this feature up from Tufte CSS¹ - inspired by the legendary Edward Tufte.

If you’re reading this post on a wide screen you should notice the tips to the side of this post. Go ahead and hover your cursor over to see the sidenote highlighted. On narrower screens (like phones) the sidenotes show up as traditional footnotes. You can use the quick jump links to navigate back and forth.

You can read more about this feature and its implementation in this separate blog post.

Image display #

Henry comes with all kinds of powerful and convenient image display options. We leverage Hugo shortcodes for this.

These are all the options that Henry’s img shortcode has:

<!--
 Other than src everything is optional
 VSCode users - look for a handy snippet later in this post
-->

{{< img src="/assets/img/henry.jpg"
 class="full-bleed"
 align="center"
 alt="Henry for Hugo"

 caption="caption for image w/o link"

 attrlink="https://wiki/images"
 attr="Courtesy: Wikipedia"
>}}

Here is the simplest way to embed an image in your blog post:

{{< img src="./henry_image_lawsofux.webp" >}}

# or using the native markdown syntax

![](/assets/img/lawsofux.webp)

If you want to align your image to the center, just use the “align” option:

{{< img src="./henry_image_lawsofux.webp" align="center" >}}

{{< img src="./henry_image_lawsofux.webp" align="left" >}}

{{< img src="./henry_image_lawsofux.webp" align="right" >}}

Henry allows you to attribute your images to the right source:

{{< img src="./henry_image_lawsofux.webp"
 attrlink="https://lawsofux.com/von-restorff-effect/"
 attr="Courtesy: lawsofux"
>}}

Courtesy: lawsofux

You can also caption your images:

{{< img src="./henry_image_lawsofux.webp"
 caption="Von Restroff Effect" >}}

Von Restroff Effect

If you want to add custom classes you can pass them through the shortcode. For example, Henry defines a “callout” style class. Let’s add that to our image like so:

// my-blog/assets/scss/main_override.scss
// ...
.callout {
 border: 2px solid gray;
 padding: 1em;
 margin-bottom: 30px;
}

{{< img src="./henry_image_lawsofux.webp" class="callout" >}}

I also added a special “full-bleed” class that displays your images beautifully with some css-trickery:

{{< img src="https://assets.atlasobscura.com/image.jpg"
 class="full-bleed"
 attrlink="https://www.atlasobscura.com/articles/manhole"
 attr="Atlas Obscura"
>}}

Atlas Obscura

VSCode Snippet #

If you are a VSCode user and would like a snippet to autocomplete the img shortcode, here you go:

All the way at the bottom of this post, you’ll notice a “related posts” section. In there, I’d like to show you more blog posts on the same topic that you might find interesting.

Hugo has related posts built in as a feature. It’s also far more customizable than the one I built with the Jekyll version of Henry. Hugo’s documentation on configuring this feature can be a little tricky though, so here’s how you configure it the “Henry” way:

[related]
 includeNewer = true
 threshold = 80
 toLower = true

 [[related.indices]]
 name = "tags"
 weight = 80

 [[related.indices]]
 name = "categories"
 weight = 20

 [[related.indices]]
 name = "title"
 weight = 10

Say your blog yaml header looks like this:

---
layout: post
title: "Introducing Henry - a Jekyll theme"
tags: [jekyll, blogging]
---

Henry will search for similar posts that have the tag “jekyll” or “blogging” and show them in the related section at the bottom of every post. It’s that simple.

External URLs (Daring Fireball style) #

John Gruber of Daring Fireball fame pioneered a style of blogging where you share a link to another website but supplement it with commentary of your own.

The » points you directly to the external website while clicking the title directly takes you to your internal version of the post containing the commentary.

All you need is an externalLink at the top of your post and Henry takes care of the rest:

---
layout: post
title: "Fragmented Podcast - Episode #2 : Android Studio"
externalLink: http://fragmentedpodcast.com/episodes/2/
---

Canonical URLs #

Sometimes I write blog posts for my company’s tech blog or a Medium account. If I want to give the post additional lift and surface it to my own followers, I like to additionally post the content to my own blog here. It’s a good idea to also host content at a place that you own and control.²

But you have to be a little careful about copy pasting content in more than one place on the internet. Google might ding your search engine ranking for duplicating content. The kosher way to do this is using “canonical urls”.

With Henry, I can now copy paste the content from elsewhere, add the canonical url in my post and have it attributed correctly.

---
layout: post
title: Hackathon vote tabulation using Google Forms & Kotlin
canonicalUrl : https://tech.instacart.com/free-hackathon...
---

Should my company or Medium ever decide to bring my content down, I can remove the canonical_url reference from the top of my post and rest peacefully knowing that my content will always be available here.

Alternate URLs (aliases) #

Wouldn’t it be nice if I could link to the same blog post with easier slugs or URLs? I find the slug or title of a blog post limiting at times. Here’s an example:

https://kau.sh/blog/jekyll-footnote-tufte-sidenote/

This works if you’re pasting a hyper link. But when i’m talking to folks, I’d like to be able to say “hey! go to my blog and add /sidenotes to check that feature out”. Now try these URLs out:

I had to build this feature custom with Jekyll but Hugo again has it built in as “aliases”:

---
title: Jekyll footnotes as Edward Tufte inspired sidenotes
layout: post
aliases:
 - /sn/
 - /sidenotes/
---

Think of this feature as a bitly or link shortener for your blog!

Draft badges #

Hugo natively supports the draft feature pretty well.

---
title: Jekyll footnotes as Edward Tufte inspired sidenotes
layout: post
draft: true
---

This draft post will only show up when you run the local server.

This is great but my brother mentioned that when you start to accumulate a lot of drafts locally, it becomes confusing to differentiate between the published posts and local drafts. Wouldn’t it be nice if you had a “draft” badge of sorts to make the drafts jump out?

Henry at your service:

RSS feeds #

This is one of the places where I feel Jekyll had an edge over Hugo. Jekyll generated well strucured atom feeds by default. Hugo’s RSS 2.0 feed was a tad bit limiting.

I spent a lot of time tweaking the RSS feeds to play nice so you should be covered with Henry in Hugo as well.

Resources #

Installation instructions #

You can find installation instructions on Github.

Reporting bugs/Feature requests/questions #

If you have noticed something off, want to ask questions or have bugs to file, please file them over in the Github issues. I try to stay on top of that list.

If you’re not comfortable with Github you can hit me up on twitter @kaushikgopal.

Supporting Henry #

I’m fortunate to have a job that pays me to do work that I love. I’m not in need of the financial assistance right now.

But If you’re feeling generous please donate to a charity you believe in and send me a link. That’ll inspire me more than anything else to keep working on Henry.

Do you use Henry? #

Feel free to update this README.md if you use Henry. It’ll mean a lot to see Henry being used by creators in the wild.

A set of tips and suggestions that help style web articles more legibly. ↩︎
I learnt this the hard way when the startup I worked for (Wedding Party) shuttered down. It had a burgeoning tech blog with a lot of my earliest Android content. We were acquihired and the domain had to be given away. Alas! My posts were gone. Never again, I thought to myself. ↩︎

Introducing Henry for Jekyll

Sat, 20 Mar 2021 07:00:00 GMT

Henry is a theme I first open-sourced for Jekyll. I’ve now recreated Henry for Hugo after migrated this blog to Hugo. You can read about it here.

I’ve used Jekyll as my blog engine here and meticulously tweaked it over the years to support a bunch of features. Many folks have asked me if I would ever put my theme up for sale or distribute it more widely.

I’m happy to announce that it’s now available for free and open source.

Introducing Henry - a Jekyll theme with a gorgeous reading experience, chock-full of features.

Features #

Customizability #

A blog theme is only useful if it is versatile enough to reflect your unique character and touch. Henry is extremely customizable.

With simple scss override files you can customize the entire look of your blog. I’ve made sure the overrides get layered in, on top of Henry’s base CSS making it easy to quickly add your own customizations. Take a look:

To see a demo of the difference, compare this blog (what you’re currently reading) with my brother’s. Both use Henry.

You can push the boundaries by adding independent pages and nifty scripting. Take a look at this sample portfolio page I’ve started building for my brother’s blog.¹

FootSidenotes #

I picked this feature up from Tufte CSS² - inspired by the legendary Edward Tufte.

If you’re reading this post on a wide screen you should notice the sidenote tips above. Go ahead and hover your cursor over it to see the sidenote highlighted. If you’re on a narrower screen (or phone) the sidenote morphs into a traditional footnote with quick jump links.

You can read more about this feature and its implementation in this blog post.

Image display #

With Henry, you can display images in a variety of ways.

![](/assets/img/lawsofux.webp)

Or use HTML directly with customized css tags:

<img class="tac" src="/assets/img/lawsofux.webp" />

// Added this to my main_override.scss file
.tac { margin: 0 auto }

Courtesy: lawsofux

Henry comes with a beautiful “full-bleed” class:

<img class="full-bleed" src="https://xxxx/63698/image.jpg" />

Atlas Obscura

All the way at the bottom of this post, you’ll notice a “related posts” section. In there, I’d like to show you more blog posts on the same topic that you might find interesting. Other blog engines have plugins that run inscrutable algorithms to come up with such a list. Sometimes it works, while other times it’s embarrassingly wrong.

I wanted to make the linking and relevance logic simpler. With Henry you simply add relevant tags for a blog post in its header:

---
layout: post
title: "Introducing Henry - a Jekyll theme"
tags: [jekyll, blogging]
---

Now Henry will search for similar blog posts that have the tag “jekyll” or “blogging” and show them in the related section. It’s that simple.

External URLs (Daring Fireball style) #

John Gruber of Daring Fireball fame pioneered a style of blogging where you share an interesting link to another website but add commentary to the post giving it more context.

The » points you directly to the external website while clicking the primary title takes you to your own post containing the commentary.

Add an external_url to the top of your post and Henry takes care of everything.

---
layout: post
title: "Fragmented Podcast - Episode #2 : Android Studio"
externalLink: http://fragmentedpodcast.com/episodes/2/
---

Canonical URLs #

Sometimes I write blog posts for my company’s tech blog or a Medium account. If I want to give the post additional lift and surface it to my own followers, I like to additionally post the content to my own blog here. It’s good idea to always have your content hosted at a place that you own and control.³

But you have to be a little careful about copy pasting content in more than one place on the internet, cause Google might ding your search engine ranking for duplicating content. The kosher way to do this is using “canonical urls”.

With Henry, I can now copy paste the content from elsewhere, add the canonical url in my post and have it attributed correctly.

---
layout: post
title: Hackathon vote tabulation using Google Forms & Kotlin
canonical_url: https://tech.instacart.com/free-hackathon...
---

Should the other place decide to bring my content down, I can remove the canonical_url reference and rest peacefully knowing that my content will always be available here.

Alternate URLs #

Wouldn’t it be nice if I could link to the same blog post with easier slugs or URLs? I find the slug or title of a blog post limiting at times. Here’s an example:

https://kau.sh/blog/jekyll-footnote-tufte-sidenote/

https://kau.sh/blog/sidenotes/
https://kau.sh/blog/sn/

They all redirect to my original post. This is how I get that done with Henry:

---
title: Jekyll footnotes as Edward Tufte inspired sidenotes
layout: post
aliases:
 - /sn/
 - /sidenotes/
---

Think of this feature as a bitly or link shortener for your blog!

Draft badges #

Jekyll natively supports “drafts” - posts that are work in progress or still in the ideas phase.

You put them in a special _drafts folder and those draft posts only show up when you launch your server locally. But they will never get published to “production” or your public website.

Henry at your service:

Quick setup #

A common complaint against Jekyll is that it can take time to get up and running with the right set of gems and ruby installations.

I’ve created Docker containers for Henry that allow you to get up and running pretty quickly on any machine.⁴

You also get a bunch of other quality of life (blogging) improvements like live reload and browser refresh, single command to launch locally or deploy to your server.

Detailed instructions are in the Github README.

RSS feeds #

Tack on /feed.xml to the end of your blog url and you have an atom feed generated.

Henry comes configured with the jekyll-feed plugin for easy use. It allows a plethora of customizations like custom feeds for categories, post limits and many others.

Resources #

Reporting bugs #

If you have noticed something off or have bugs to file, please file them as Github issues. I try to stay on top of that list.

Feature requests or questions #

Want to know if Henry can support a feature, or will support one? Please use the Github discussions page.

If you’re not comfortable with Github you can hit me up @kaushikgopal.

Supporting Henry #

I’m fortunate to have a job that pays me to do work that I love. I’m not in need of the financial assistance right now.

But If you’re feeling generous please donate to a charity you believe in and send me a link. That’ll inspire me more than anything else to keep working on Henry.

Do you use Henry? #

Feel free to update this README.md if you use Henry. It’ll mean a lot to see Henry being used by creators in the wild.

He’s one of the sharpest product people I know and is currently on the market. Hit him up if you’re interested. ↩︎
A set of tips and suggestions that help style web articles more legibly. ↩︎
I learnt this the hard way when the startup I worked for (Wedding Party) shuttered down. It had a burgeoning tech blog with a lot of my earliest Android content. We were acquihired and the domain had to be given away. Alas! My posts were gone. Never again, I thought to myself. ↩︎
No more worrying about installing the right version of Ruby or Jekyll or a specific gem. ↩︎

How to rate a movie

Sun, 17 Jan 2021 07:00:00 GMT

Given how many movies and TV shows we’ve been watching these days, it’s useful to have a personal rating system. I’ve used and tweaked this scale over time and it’s worked pretty well for me.

How to use this system #

The scale ranges from 0-5¹ but coming up with a specific number off the top of your head is tricky. That’s where the associated descriptions comes in handy.

Consider a movie and see if how you feel about the movie, matches with the associated descriptions. I’ve found that by asking these same set of questions it’s easier to rate movies more consistently.

The idea here is to bring consistency in the way you rate movies. Different folks have different tastes so don’t expect a 4 on your scale to match with a 4 on somebody else’s.

But if more folks start to get consistent with their rating, it’s easier to identify those with similar tastes and ask them for their recommendations.²

Rating system #

0.5 #

This movie doesn’t exist to me. It’s so bad that I will not even mention its existence to other people.

1 (bad) #

I watched this movie and I regret it.
I feel like I’ve been robbed off my time.
I don’t recommend anyone watch it.

2 (meh) #

I watched this movie.
I don’t regret it per say.
But I wouldn’t recommend to anyone else.

3 (like) #

This movie was decent and I’m glad I watched it.
It deserves to be watched at least once, so I would recommend this to others.
But I personally wouldn’t watch this movie all over again.

4 (really like) #

This movie was really good.
This would go in my list of recommended movies for the year.
Heck, I’d like to watch this movie again sometime.

4.5 (amazing) #

This move was so good that I want to buy a copy of it.
I would sit my friends down and watch this movie again with them.

5 (flawless) #

This movie is a work of art and essential watching for our age.
I want to see the director’s cut so I can enjoy it more.
Every one should watch this movie at least once in their lifetime.

Let’s try this on a couple of movies: #

Wonder Woman 1984 : 2 #

I watched the highly anticipated Wonder Woman as it debuted on HBO Max. I don’t regret watching it but I wouldn’t recommend it to anyone. You could spend that time watching a much better movie instead.

The Midnight Sky : 2.5 #

I watched this movie cause Netflix pushed it as one of their most watched movie for 2020.³ I wasn’t terribly impressed.

My first response to the movie was a resounding meh! I wouldn’t go around recommending this movie to my friends but I don’t regret watching it. So we’re off to a solid 2 again.

I will say though if you have absolutely nothing else to watch and time on your hands then I wouldn’t not recommend it. Since I’m feeling generous I’d bump this movie to a 2.5.

Golden Eye : 3 #

This was my first Bond movie on the big screen so there’s definitely a strong sense of nostalgia here. Compared to the other Brosnan Bond movies, I’d say this stands out as one of the better ones.

I don’t know if I’d go back and watch this whole movie again but I’m glad I saw it and wouldn’t mind recommending this to folks trying to catch up on their Bond history.

Ocean’s 11 : 4 #

I love a good heist movie and Ocean’s 11 definitely redefined the genre. If this movie is running on cable or TV, I’d probably just land up watching it again. This is the kind of movie I’d catch myself YouTubing for clips now and then but I don’t think I would go so far as to buy myself a copy.⁴ It’s exactly what I would deem a 4 in my books.

Spider Man : Into the Spider Verse : 4.5 #

As soon as I watched this movie in the theater, I came back and pre-ordered a digital copy. So I knew we’re off to a strong 4.5.⁵

If my friends haven’t watched this movie already (owing to preconceptions about it being a movie just for kids - superhero cartoons and all) this is the first movie I make them watch. Maps to how I feel about 4.5 movies.

Whiplash : 5 #

I get goosebumps every time I watch this movie. I love music so I might be a little biased but that’s how it works on my scale. The acting, the editing, the cinematography, the color grading. The editing is so tight in this movie that it makes you feel like you’re watching a boxing match. One for the ages!

thoughts?

Try this scale out the next time you watch a movie and let me know what you think!

mostly because Netflix (in the early days) and some other popular recommendation systems like MovieLens use this range. Multiply by 2 if you need a scale of 10. ↩︎
I generally recommend movies >= 3 to my friends and it’s worked out pretty well. ↩︎
and of course it had George Clooney. ↩︎
… in theory. I bought the entire Ocean’s set when it was sale on a Cyber Monday deal. ↩︎
I want to point out - there exists 4.5 movies that I haven’t bought a copy of. So don’t take this as a rule but more a strong indicator. ↩︎

2021

Fri, 01 Jan 2021 07:00:00 GMT

From my 2020 post:

2019 has been the year that’s primed me the most for life changes. I imagine 2020 will the be the one where a lot of these changes materialize.

… that’s cute.

If you’re reading this in the future and suprised why, I suggest this Netflix mockumentary. Contagion style blazing dumpster fire year aside, it’s been hard to find the motivation to write this post. But reading my previous years’ posts, I’m usually grateful past me took the time to capture my thinking, priorities and general frame of reference.

So power on, I shall.

2020 Recap: #

Fragmented #

Fragmented remains my proudest labor of love but I’m not kidding about the labor part of this statement. We’re taking it much slower on Fragmented releasing as and when, our lives allow us. But with 2021 rolling around, the hope is that we can kick things back up atleast from the current dormancy. Stay tuned.

jkl.gg #

Lot of changes here. I moved my primary domain and assets from kaush.co¹ to jkl.gg.

This blog saw a lot of tweaks and customizations. The joke goes: most people with custom blog setups spend more time customizing their blog than writing posts. This was true for me but I actually enjoy the process of customizing my blog. In addition to (pleasantly) reminding me of my WebDev days, it also helps me learn and understand my UX skills better.

Posts like the one I wrote on sidenotes² come from this process. Another change that was probably not evident was the entire CSS refactor of this blog. A lot of display:grid is now being used. No post on this but in the process of this refactor, I’ve actually started work on a minimal jekyll theme for podcasts .³

Mechanical keyboards and hacking #

Productivity has always been a theme for this blog. This year I played (and spent) a lot with Mechanical Keyboards. It was a fun experiment, learning to flash and customize keyboards. Eventually settled with tricking out existing apple keyboards with karabiner and goku.

Lot of TV #

I watched a lot of TV. This is more than my usual self, which is to say a heck of a lot more TV. As someone who’s known in friend circles as the guy who watches a lot of TV, obviously I’m asked for recommendations all the time.

I’ve spent a lot of time in the process looking at Movie recommendation services and just rating systems in general. I plan to write a lot about that this year.

Random learnings from 2020 #

Blog post on the Dangers of shipping software at the last minute

Heroes don’t fall from the sky. They’re just ordinary people who step forward

Episode of The Daily

Katz: …and one thing that always stuck with me is how persuadable @dhh was when presented with actual solutions that people created to solve actual problems they encountered in real apps.

DHH: SHOW ME THE BEFORE/AFTER CODE! It reduces all these abstract debates to the realm of the concrete. 80% of disagreements disappear when you look at real code vs make-believe arguments

Yehuda Katz

“They made their own clouds, brings to mind the people who built the great Gothic cathedrals. Knowing they’d be long dead before their work was finished, trusting their great-grandchildren would lay the final stones. We’ve lost that kind of generational thinking on Earth. Here, you see it in everything they do.”

The Expanse Season 4 Episode 2

We operate at the whim of this world

Joe MacNally

Adapt what is useful, reject what is useless, and add what is specifically your own.

Bruce Lee courtesy this tweet

Even, when I’m disappointing you, I will tell you honestly why

Brent Simmons

Parting thoughts #

Recuperate, Regroup and Resume. Let that be the chanting slogan.

kaush.co still redirects here. ↩︎
read this post on a browser if you’re on RSS. ↩︎
Fragmented probably won’t use this but a newer podcast I’m helping get started, might 🤫. ↩︎

iPhones, Pixels and lazy Android developers

Sun, 06 Sep 2020 07:00:00 GMT

The Bentwits #

So Ben Thompson¹ recently tweeted:

I’ve been using Android for the last couple of weeks, and honestly, the core OS is pretty good!

The big problem is that Android apps are garbage relative to iOS apps. If developers actually care about pushing back against Apple they should give a damn. They don’t.

He then went on to attribute the garbage quality of Android apps to developer laziness. This understandably infuriated some of us #AndroidDev unleashing the droid rage. To Ben’s credit, he has since deleted the specific tweet calling out developer laziness.

I’m not going to spend time dissecting his tweets.² We are all human and occasionally tweet dumb things. But there’s a shred of truth nestled in that starting tweet that just got me thinking.

iPhone vs Pixel #

Serendipitously, I’ve been thinking and tweeting about similar things .³

I’ll summarize the obvious points so we can get those out of the way:

iOS does better with privacy overall. It’s not always a slam dunk but all things considered the Android experience is worse on this front.
iPhone hardware is better than Pixel hardware especially when it comes to integration with bluetooth accessories like the Apple Watch, AirPods, CarPlay etc.
Camera is dicey. I think the Pixel shoots better still photos than the iPhone. The computational photography voodoo that Google does on pictures after the fact makes the photos more appealing to my eyes. iPhones still have the better Camera (hardware) though which is abundantly clear when you try to shoot videos.
Siri is a steaming pile of garbage. It’s a crying shame how bad it is given the better hardware. Google Assistant alone makes me switch back to my Pixel time and again.⁴

But there’s one important point that came up from this imbroglio that has been hard to shake off …and wherein lies the more interesting argument:

Which phone has the better apps? #

In my original tweet I was careful to say the iPhone has better “3rd party” apps.

Here’s a fair question to ask retorting that position: Give me examples of apps that exist on both Android and iOS where the iOS experience is better?

Sure, I can give examples⁵ where it’s true most of the time but my point is subtly different. If I rephrase that question however, it helps make my point better:

Give me the best “insert category” app on the iPhone and on the Pixel. Which one do you think works better?

Let’s try that for a few categories:

Give me the best Todo list app on the iPhone and Pixel. Which one do you think works better? (See Things)
Give me the best RSS feed reader app on the iPhone and Pixel. Which one do you think works better? (See Reeder)
Give me the best music making app on the iPhone and Pixel. Which one do you think works better? (See GarageBand)

Some will immediately jump in defense saying this is subjective.

Sure… Maybe? I’m open to being challenged here. But I build Android apps for a living and I mostly use an iPhone today as my daily driver, so take it for what that’s worth. Also chatting with other (dev) friends, I’ve heard I’m not alone.

So why are iPhone apps better? #

Android Tools are worse? #

Actually it’s the opposite! After dabbling with some iOS development, I can confidently say Android Studio is ~~like a glass of ice water~~ much better than Xcode.⁶ I also think Google as a company listens more closely and cares about improving the developer experience. Many of their recent changes have been in direct response to developer outcries.

How many iOS developers can say the same of Apple?

Android devs are lazy? #

Abso-fucking-lutely not.

I’d even go so far as to argue that Android developers care way more about clean architecture and good engineering practices than iOS developers. I mean I’m biased here but consider the fact that Android devs are typically early adopters of industry best practices like Rx, MVI/Unidirectional State Flow, Reactive UIs etc. You’ll find chatter, curiosity and first implementations about these topics much earlier in the Android development community. But here’s the rub:

iOS devs didn’t have to care about these things.

iOS devs didn’t have to care #

You want to know why Android devs jumped on Rx? Because every time you hang for a few extra seconds on the main thread you would get hit with a gnarly ANR. iPhones were built to make single threaded processing blazingly fast. You can execute database calls on the main thread and not worry for the most part. Try that on an Android phone.

You want to know why Android devs have heated week long discussions about Dependency Injection and Dagger? Because we can’t use constructors in our classes! iOS devs think we’re crazy cause our ViewControllers don’t just take in our dependencies.

You want to know why Android devs experiment and come up with all kinds of different architectures to build apps? Because Google for the longest time intentionally chose not to have an opinion. This changed in 2017. You know how long Android has been around? since 2005. 12 years, if you’re doing the math.

I also don’t need to reiterate the trope around Android being fragmented.⁷ While we would spend nights battling platform specific bugs, our iOS counterparts could spend their time focusing on silky smooth UIs. They had the luxury of perfecting and polishing (and good on them for doing that). minSdk 14 was never a thing for iOS devs.

So yes, we might have better tools courtesy Android Studio but make no mistake it is easier to build higher quality apps on iOS than it is on Android.

One more thing #

There’s also this other big factor that accounts for better third party apps: iOS users are more willing to spend money through the app ecosystem. Android may have the bigger market share today but more money is spent through iPhones.

If iPhone users are willing to spend more money, companies and indie developers are going to spend more time and resources building iOS apps instead of Android apps. When more time and resources are spent instead on iOS apps it follows that iOS is likely to have the better apps.

It’s harder technically to build a better Android app but Google is doing its part to close that gap quickly. But unless Android users actually start spending more money through apps, iOS is going to have the lead.

A journalist who is otherwise a very thoughtful and astute tech reporter. ↩︎
This was a fleeting -i can’t sleep during corona so imma just tweet- oopsie. Definitely not one the finer Stratechery moments we’ve come to expect. ↩︎
The Pixel experience is the best experience for Android. Yes, I know Samsung hardware can be pretty good. When a non-bastardized Android experience comes to Samsung, I’ll switch in a heartbeat. ↩︎
and this is to a 3 year old Pixel 2. My Pixel 4A is coming end of this month. ↩︎
and burn bridges with my good Android dev friends who work at these companies. ↩︎
Both Kotlin and Swift are amazing. So they have a negligible impact in this discussion. ↩︎
Heck, I started a podcast with the same name. ↩︎

Technical leadership and glue work

Fri, 28 Aug 2020 07:00:00 GMT

If you’re in tech and have been thinking about your work and role in your company, I highly encourage you to watch this talk by Tanya Reilly ¹

Setting myself a reminder to rewatch this again 6 months from now.

Such a phenomenal speaker and powerful story telling! Follow her @whereistanya ↩︎

Jekyll footnotes as Edward Tufte inspired sidenotes

Tue, 21 Jul 2020 07:00:00 GMT

I’ve been looking into Tufte CSS recently. Tufte CSS -inspired by the teachings of the legendary Edward Tufte¹- provides suggestions and tools to style web articles for improved legibility.

I’ve started to incorporate some of those principles here while still trying to keep the authenticity of my original design. Most of these changes have been in the realm of CSS however the sidenotes feature was a slightly trickier beast.

I’ve implemented this feature in my blog theme “Henry” for both Hugo & Jekyll.

Jekyll kramdown comes built in with a footnotes feature that I’ve used here for some time. It works pretty well for the most part. The only problem though is -as the names suggests- it displays the notes all the way at the bottom of the articles near the footer.

Edward Tufte instead suggests the use of “sidenotes”:

Sidenotes are like footnotes, except they don’t force the reader to jump their eye to the bottom of the page, but instead display off to the side in the margin.

So my objective was to use the existing kramdown pipes and generate the footnotes, but display them off to the side in the margin instead of at the bottom.

Pulling this off is tricky with pure CSS but is baby talk for javascript. So I pulled out my trusty old jQuery² chops and got this fun side project done.

source

You can find the js source code here.

As is the case with these things though, the devil is in the details. I got the basic functionality down in about an hour but adding the finishing touches took more testing and improving. Here’s some of the ones I had to tackle:

Image loading throws the position off: #

Since jQuery loads eagerly, it typically wouldn’t wait for the images to load before calculating the position. This would cause the position to be off sometimes.

This is a one-line fix in jQuery:

$(window).on("load", function() {
 // executes after everything in the DOM loads
}

Resizing the browser throws position off: #

Since most folks read blog posts on their phones and tablets these days, there’s a much smaller chance they’re resizing their browser. But if you’re on a laptop (as I am most of the time) then resizing your browser will completely throw the positioning off again.

While there might exist more optimum solutions to fix this, I went with the simpler approach of just detecting window resize changes and just reading the sidenotes again:

$(window).resize(function() {
 loadSidenotes(ww, $fnli, fncount, $fn);
});

I try to optimize this a little by “caching” the previous size and only reloading the notes again if I detect a difference.

$(window).resize(function() {
 const new_ww = $(".wrapper").outerWidth();
 if (new_ww === ww) return;

 // console.log(" XXX -- RESIZE -- XXX ");

 ww = new_ww;
 $(".sidenote").remove();
 loadSidenotes(ww, $fnli, fncount, $fn);
});

Again, this is probably not the most optimum solution but

I don’t imagine people resizing their browser window that often
there aren’t that many footnotes per post

So I opted for a simpler more understandable solution (than a performant one) - an important software engineering learning that hasn’t failed me so far.

I also realized that my responsive CSS needed some tweaks, so had to tighten that up too.

Remove footnotes from the bottom #

If the sidenotes land up displaying successfully, then I actually go the extra mile and remove the footnotes from the bottom of the post. While I don’t have to do this, I think removing cruft and keeping it clean with just the essential content helps the reader know when they’re done.

On hover highlight the sidenote #

By default I didn’t want the sidenote to really jump out and distract from the post content. So by default they show up in a slightly muted color. But if you highlight the super script link ,³ it should brighten the sidenote.

Optimize for mobile sizes #

Now this is great for larger displays like tablets and laptops, but for smaller displays like most mobile phones, the whole sidenote thing doesn’t work as well. So in these cases, I only show the border marker indicating that a sidenote exists. I also don’t mute the color as the border is less distracting.

In addition, I keep the original treatment and clicking the link takes you to the bottom (as before). A future optimization would be to go all Tufte on this and displaying the sidenote on clicking. This should be easy enough to implement with jQuery.

This was a fun side project but sweating the details takes more time than you would otherwise assume. What do you think? Would love to hear your thoughts or suggestions on making this better.

noted for his writings on information design and as a pioneer in the field of data visualization ↩︎
Yes, I know jQuery is old school and the youngins probably use fancier alternatives today but I love me some jQuery and it gets the job done. ↩︎
If you’re still reading this, thank you. As a sign of gratitude this is a dummy sidenote to make it easier for you to test my sidenote display. ↩︎

Am I Yak-Shaving or Bikeshedding?

Wed, 15 Jul 2020 07:00:00 GMT

If you’re a software engineer trying to be snarky, it’s important to get these terms right for maximum effect.

What is Yak-Shaving? #

“Shaving a Yak” means performing a seemingly endless series of small tasks that must be completed before the next step in the project can move forward.

Is this a good thing or a bad thing? #

It depends. Yak Shaving is sometimes very much necessary. It’s “bad” only when done unnecessarily. It’s unfortunate when necessary but might not be a bad thing at all under certain circumstances.

Seth Godin’s blog post on the subject was the first time I ran across this way back when and does a good job of explaining this concept in great detail.

What is Bikeshedding? #

“Bike shedding” means spending most of your time discussing the simple but trivial issues rather than focusing your time on discussions around the bigger but harder tasks at hand.

The parable goes: a committee of members started working on the design of a nuclear power plant. Designing a new nuclear plant is probably no joke. Given how daunting and overwhelming this task was, the committee instead landed up spending most of that time designing just the bike-shed outside of the plant.

Is this a good thing or a bad thing? #

This is most definitely a bad thing. It’s also referred to sometimes as “Parkinson’s law of triviality”.

I will add this caveat though: many software engineers rush discussions around topics like “naming” to be bike shedding. I vehemently defy such attempts. Naming is an important part of maintaining any code base. It’s one of those deceptively simple tasks that if done wrong will bite you in the behind for years to come.

My new programming font - Iosevka

Tue, 14 Apr 2020 07:00:00 GMT

If you’re looking to just copy-paste instructions, jump to the section below.

For the longest time, I’ve been rocking IBM Plex Mono as my programming font.

While it has served me well, I started to experiment with some newer monospaced typefaces to see if I could find one that was even more legible.¹ That experiment quickly devolved into a rabbit-hole evaluation of a bunch of new programming fonts.

Hello Iosevka #

Eventually, I landed up with the font Iosevka:

It’s far more legible (courtesy the extra long glyphs)
It’s set pretty narrow which makes it pretty space efficient ²
It’s 100% open-source
You can build the font from source and customize it pretty extensively
There’s ligatures (…or not …or dig this- for specific languages!)

Now at the outset, I actually didn’t like Iosevka at all. It was unbearably narrow for my taste but thankfully it also comes with an “Extended” variant. The extended variant adds a little more breathing room between characters making it less condensed.

After I fiddled with it more and chose specific glyphs that are easier on my eyes, I think I landed up with a version that I absolutely love:

It’s more legible and dare I say a little more appealing than the trusty IBM Plex Mono .³ It almost hearkens back to my Inconsolata days (inspired by Gary Bernhardt’s DAS screen casts).

Customizing Iosevka #

Iosevka allows you to pick specific glyphs for certain characters.

If you notice the cherry-picking section in the above image, I’ve chosen slightly different variants of g, l, y, G, Q, *, $ and %. If you head on over to the main website, you can even live preview and test a bunch of combinations.

Build Iosevka from source (on macOS) #

Once you’ve indulged your stylistic tendencies and honed in on the style you prefer, you can build the font right from the source. I didn’t find too many instructions online on how to do this with a Mac, so if you’re looking to do the same, this should save you some trouble:

Install necessary dependencies #

You need to have homebrew, pip and npm already installed.

git clone git@github.com:be5invis/Iosevka.git
# it's big, so it'll take sometime
cd Iosevka

brew install ttfautohint
brew tap caryll/tap
brew install otfcc-mac64
pip3 install afdko # has otf2otc
npm install

Build the font #

Make a copy of the sample build plan first and then edit it with your customizations. If you take a look at my sample build plan, it should become obvious how to do that.

cp private-build-plans.sample.toml private-build-plans.toml
vi private-build-plans.toml
# make your customizations

npm run build -- ttf::iosevka-kg
# fonts should be in dist/

# if you want to generate woff, eot etc.
# npm run build -- contents::iosevka-kg

That’s it! Open the dist directory and you should find your very own version of Iosevka.

You can download the variant I’m currently using here.

While aesthetics played heavily into my choice before, nowadays my eyes are fierce about keeping legibility as the number one priority (a LASIK will do that to you). ↩︎
Truth be told, I’m actually not a fan of ultra-narrow fonts (looking at you Pragmata) and Iosevka is pretty darn narrow for my taste. But more on this later. ↩︎
Either that or I’m just bored 😋. ↩︎

My 1st screen cast: awk program from scratch

Tue, 10 Mar 2020 07:00:00 GMT

Two big announcements:

I made my first screen cast ¹
I’ve updated the permalink title for all the blog posts here ²

I wanted to make sure that external blogs linking to previous post links wouldn’t break. So in order to do this, I had to edit all of my previous blog posts and add a redirect_from tag.

Life is too short to be doing this manually so I whipped up an awk program to do it for me in about 20 minutes. It was so much fun building the program that I figured I should screen cast the process.

Recording the screen cast and exporting a decent version of it took a lot more than 20 minutes but I thoroughly enjoyed the process. You can watch the screen cast in its entirety on Youtube:

If you enjoyed it, please do let me know on twitter or in the comments over at YouTube.

Notes about the screen cast #

I use the GNU variant of awk (gawk)
ripgrep is what I use to search
My shell is fish
Terminal theme is Dracula Pro
The font I use of course is the venerable IBM Plex Mono

Meta notes on screen cast #

It took 5 takes to get the final one right
I used an iPhone to record my keyboard & QuickTime Player to record the screen
Adobe Premier Pro was my video editor of choice (I’m an Audition devotee)
I don’t typically use an Apple keyboard ³ but my darn Kinesis wouldn’t fit comfortably in the iPhone screen (without propping the phone too high).
I had both a mic and the iPhone on stands, both of which were obstructing my view to the keyboard. This would explain why I’m kind of sloppy at times with the keyboard navigation.

One of my goals for 2020 ↩︎
This might have messed with your RSS unread feed count. Sorry 😬 ↩︎
Kinesis Advantage Pro in case you were wondering ↩︎

git-number to the command line rescue

Wed, 19 Feb 2020 07:00:00 GMT

If you’re a programmer these days, you probably spend a large part of your day in git. If you’re a command line zealot like me, you realize the holy ways of using your Terminal app for everything and aren’t seduced by fancy GUIs that only stand to dissuade you from pure unbridled productivity.

With that in mind, one typically finds themselves in a position where they have a few files that have changed liked so:

If I had to add 2 out of those 3 files,¹ typing the commands start to get a little tedious:

:> git add images/content/git-0.png
:> git add images/content/git-1.png

Sure, if you happen to use fish (one of the nicest shells out there) the autocompletion helps reduce the tediousness. But it still doesn’t beat being able to add files just by a number! What if you were presented with a git status like this:

and then simply added the files by their reference number, like so:

:> g add 4
:> g add 5

Wouldn’t that be better? I’ve been doing this for years and trust me, it is! You probably won’t see the difference with just a few files, but if you had 10 images being commited, then being able to simply type a range makes it a breeze to commit a bunch of files!

:> g add 4-10

Installation #

So, how do you achieve something similar? Install git-number and 💥:

:> brew install git-number
:> git-number -s

For years, I used a bunch of hand wrangled ruby files, that would help me achieve something similar but I discovered @holygeek already went through the trouble of building a much more mature version of this in Perl. Now I’m just using that version (and have gladly deleted all those scripts I had to grudgingly maintain).

Notes #

Remember to git-number first #

It’s important to make sure you run git-number first before running your git add <numeral> commands. I’ve noticed that git-number gets a little confused and tends to try issue commands on the wrong files from previous runs, if you don’t (yikes).

You probably want to run git-number anyway to see the status of changed files. This replaces git status which you probably would have otherwise run to see what’s changed.

Works for most git commands #

I demostrated the ease of using numbers with git add but git-number isn’t limited to just add. It also works for most other git commands where you have to reference a filename like checkout, reset etc.

Aliases and conveniences #

The keenly observant would notice in the examples above that I use g add <number> instead of git-number add <number>. This is because I almost always want to use git-number instead of git. So I have an alias for conveniences:

alias g = git-number

The good thing with git-number is that it works even if i’m not referencing a file number, so this will technically also work:

:> git-number commit -m "This is a diligently formed commit 😇"

But what about my auto-completions? #

The only trouble with replacing git with git-number altogether, is you might lose your auto-completions:

:> git-number checkout kg/feat/myBr<Tab>

Typically when you hit the tab key (where it says <Tab> above) you would expect the different branch names to be autocompleted but since most shells are configured to autocomplete only if when they see a “git” command being used, this can pose a problem.

If you’re using fish ² though, this is easily possible if you use a function³ :

function g \
 --description "abbreviation for git-number w/auto completion" \
 --wraps git
 switch $argv[1]
 case "reb*"
 git $argv
 case "*"
 git number $argv
 end
end

Now you can go about your merry way, using g as your git command alias, have autocompletion and use git-number to boot.

Give git-number a try. You won’t regret it.

be a good git citizen and make meaningful commits ↩︎
and really why aren’t you? it’s the best shell out there ↩︎
git-number isn’t happy playing with commands like rebase though, so best to avoid them ↩︎

2020

Tue, 04 Feb 2020 07:00:00 GMT

2019 has been the year that’s primed me the most for life changes. I imagine 2020 will the be the one where a lot of these changes materialize.

2019 Recap #

Practice Vim for 30 days #

Not only did I successfully try it for 30 days, I now use vim as my primary text editor of choice and absolutley love it. It deserves a separate post though.

Blogging + screencasting? #

I wrote 12 posts last year so I’m pretty happy with the 1-post-per-month average.I’m definitely looking to ramp up this number in 2020.

I didn’t do any screencasting though. I purchased a screaming hot license for ScreenFlow but left it unopened for the rest of the whole year 👎. ¹

Care about your privacy #

I definitely have been more acutely aware of privacy and how my data is being collected by different services and platforms out there. The biggest change I’ve made is the iPhone X for all personal use .² This was an incredibly tough pill to swallow for me. I don’t intend to write about this cause it always feels like a moving target but I do have copious notes on the matter. Let me know if you’re interested and I might just convert those notes into a blog post.

I’ve also switched to Firefox for my browsing. If you’re considering the switch for privacy reasons, make sure you’re also using the Multi-Account Containers add-on. That coupled with the Temporary Containers add-on is what makes it a truly private browsing experience. This definitely warrants a post or screencast so look for that in the future.

Miscellaneous #

I try to speak at one international conference every year (always a new talk, in a city/country I’ve never been to before). This year I had the opportunity to give a talk in Poland. This trip was the highlight of the year.

I am terribly disappointed that I didn’t make my annual trip to Disneyland ³ but I shall make amends.

On completing 185 episodes of Fragmented -the podcast I co-created with my buddy Donn- we decided to change things up a little. That was a big decision for us. If you’re curious you can listen to the changes here:

2020 Goals #

In past years I’ve kept my resolutions and goals pretty generic (do more X, get more fit, sleep more etc.). I want to try and make them more specific for 2020:

1. Write 24 blog posts #

raising it from 1-month-a-post to 2. There’s something about jotting words down that forces a kind of mental clarity. I’m excited about this and already have a bunch of ideas for posts lined up.

2. Make 5 screencasts #

and finally whip out that copy of ScreenFlow. I love watching other folks screencast. I especially like seeing how other developers use vim, Terminal shortcuts, keyboard hacks, different setups etc. I’d like to join the party. This one is going to be slightly challenging though given my utter newbness in the area.

3. Give one conference talk #

(preferably) in a country I’ve never been to before and on a new topic. I’ve consistently been good at this for the last 5 years so want to keep it going.

4. Hit the gym atleast 3 times a week #

starting Week 7 of this year 👯‍♂️. I think my body is starting to feel like it’s catching up with my age. I’ve been decently fit for the last 2 years but I want to improve on the consistency, so putting this down here as a commitment.

5. Watch 52 movies #

and put out some recommendations .⁴ Watching movies is how I decompress. If I don’t prioritize taking care of my mental health and appropriately decompress, I burn out pretty fast. So this is almost a counter-goal to make sure I’m making the time for things that give me happiness.

Random learnings from 2019 #

This section is just a random assortment of quotes, links, articles and other things I picked up along the year that I think is worth sharing:

Martin Fowler quote: #

Any fool can write code that a computer can understand. Good programmers write code that humans can understand.

Martin Fowler, 2008

Markdown comments: #

Apparently Markdown has comments.

[//]: # 👏 if you got here. Shoot me an email citing you saw this comment, and i’ll send you movie recommendations!

Anonymous quote: #

“Beware the quiet man. For while others speak, he watched. And while others act, he plans. And when they finally rest… he strikes.”

from the movie Vice

Ending conference talks: #

Asking “What questions do you have for me?” can be dramatically more effective than “Any questions?” at the end of a talk. ⁵

Optimize for trust: #

Don’t optimize for likability, optimize for trust!

🏁 🏁 🏁 Bring it on 2020! 🏁 🏁 🏁

In all fairness I did add a wavering question mark indicating this was a stretch goal. ↩︎
iOS is far from perfect but I think they fair much better than Android as it stands now. I’ve been keeping an eye out on the various breaches and instances of privacy violations and it’s become evident that iOS is the better choice when it comes to privacy today. Also, the Pixel 4 didn’t exactly leave me pining for a new Android phone, so that decision became very easy. ↩︎
especially since Star Wars: Galaxy’s Edge is now finally open. ↩︎
Have you furiously searched Netflix on a Friday night as your significant other patiently waits? I have a lot of friends who do that would like to benefit from my special movie recommending powers. My contribution to this universe, if you will. I even have a specific rating system that’s not snooty or artsy-fartsy and is geared towards picking a movie to watch quickly. Coming soon in 2020. ↩︎
From a Planey Money episode #959 ↩︎

You should CD your blog (Firebase Hosting + Circle CI + Docker)

Wed, 29 Jan 2020 07:00:00 GMT

This blog now ¹ uses Jekyll - a static blog generator that takes markdown as an input and pumps html as output. I then copy it over to my hosting server - Firebase, which then happily serves it to the interwebs.

This setup has worked out swimmingly well thus far and has been rock solid. Even when my last post got high up the ranks of HN, my blog held steady. Not even the slightest of fears or signs of being fireballed or slashdotted. This is the beauty of HTML.

To achieve the above, these are the actual steps:

write my blog post in markdown
git commit and push blog post to git(hub) (this entire blog is version controlled)
run command “bundle exec jekyll build” (use jekyll to generate the html)
run command “bundle exec htmlproofer ./site –check-favicon –check-html” (on generated html from step 3 to make sure I don’t have broken links etc.)
run command “firebase deploy –only hosting”

That’s 3 steps more than my lazy self is willing to do every single time.

In software land, we’ve solved this problem with CD (Continuous Delivery). You have a server somewhere on the internet, that keeps checking your github repo every time you’ve made a change, then runs a sequence of commands for you.

That’s exactly what I did for this blog. I now use Circle CI ² to ping github and run through steps 3-5. If all’s well my blog is updated with my new post. If something didn’t go well, I get an email notifying me about it which I can then promptly fix.

Even when I’m just tweaking the appearance of this blog, I tend to make a lot of changes ³ to my css (it’s like my happy place). Setting up CD has saved me huge amounts of time! If you’re a developer, or savvy enough to dabble with some code, I highly recommend it!

Here’s what my circle ci config looks like:


version: 2
jobs:
 build:

 working_directory: ~/repo

 # docker hub images https://hub.docker.com/
 docker:
 - image: kaushikgopal/ruby-node:2.6.5_12.14.0

 steps:
 - checkout

 # Download and cache dependencies
 - restore_cache:
 keys:
 # Find a cache corresponding to this specific file's checksum
 # when any of these files are changed, this key will fail
 - v00-deps
 # Find the most recently generated cache used from any branch
 - v00-deps-

 - run:
 name: Ruby dependencies
 command: bundle install --path vendor/bundle --verbose

 - run:
 name: Node dependencies
 command: npm install firebase-tools@7.10.0 --unsafe-perm --verbose

 - save_cache:
 # path for directories is relative
 # to the working_directory of your job
 paths:
 - vendor/bundle
 - node_modules
 key: v00-deps

 - run:
 name: Build
 command: bundle exec jekyll build --verbose

 - run:
 name: HTMLProofer tests
 command: bundle exec htmlproofer $HOME/repo/_site \
 --allow-hash-href \
 --check-favicon \
 --check-html

 - run:
 name: Deploy
 command: $HOME/repo/node_modules/firebase-tools/lib/bin/firebase.js\
 deploy \
 --token=$FIREBASE_TOKEN \
 --non-interactive \
 --only hosting

To get the right version of ruby and node playing well together on the Circle CI server, I even had to create my custom docker container. I chatted in great detail about this on Fragmented episode 188.

Curious to know more about this setup? hit me up on Twitter and I’ll gladly try to help.

I started out with Blogger, moved to Wordpress.com, then Wordpress.org, then Octopress which i deeply loved, and finally now to Jekyll. ↩︎
They have a generous free tier. ↩︎
Did you notice the recent switch to FF Tisa and Jetbrains Mono 😍 ? ↩︎

Hacking your keyboard with karabiner

Wed, 25 Dec 2019 07:00:00 GMT

Update

I’ve since come up with an easier way to maintain my rules. This post talks of some of the cool things you can do with Karabiner. But if you want a more maintainable way of customizing all this, read my other post instead.

tl;dr:

brew install yqrashawn/goku/goku
mkdir -p ~/.config && cd ~/.config
touch karabiner/karabiner.json
touch karabiner.edn
# update your edn file with a sample from here https://github.com/yqrashawn/GokuRakuJoudo/blob/master/tutorial.md
# or mine: https://gist.github.com/kaushikgopal/ff7a92bbc887e59699c804b59074a126
goku

Background #

I’ve been messing with mechanical keyboards recently.¹ There was one in particular which is a 60% layout that I fell in love with.

The trouble with 60% keyboards though is that they can be pretty constraining for some basic operations (like navigation). Notice there aren’t dedicated keys for the up/left/down/arrows.

Courtesy: Wikipedia

Given these constraints, you have to get a little creative with how you use a keyboard. I added a bunch of mods for the keyboard using the mechanical keyboard’s included software configurator. I liked these mods so much that I wanted to find a way to use these mods with any keyboard I use.

The easiest way I’ve found on the Mac to do this is using Karabiner. Karabiner intercepts every keystroke and allows you to send alternative signals.

For example, a common mod that a lot of programmers like to do is remap their Caps Lock key -> Escape. So if I tap the Caps Lock key, it instead emulates hitting the Escape key. You can do this pretty easily with Karabiner but it barely scratches the surface of Karabiner’s true power.

Complex modifications: #

Where Karabiner will truly shine is when you want to do slightly more complex things: for example, take the case of navigation with 60% keyboards. While they don’t come with dedicated arrow keys you can emulate navigation in a pretty slick way (especiallly for us vim users).

Instead of moving my fingers all the way to the bottom right of my keyboard and aiming for the arrow keys what if I could just keep my fingers on my home row and navigate like so:

tap caps lock once -> Escape key
hold caps lock -> left_control
hold caps lock and press h -> left arrow
hold caps lock and press j -> down arrow
hold caps lock and press k -> up arrow
hold caps lock and press l -> right arrow

You can of course choose to map any key combo (for example right shift key + W/A/S/D). I chose H/J/K/L cause I’m a vim user and I love just using h/j/k/l to navigate anywhere on my Mac!

More Complex modifications: #

Even that, just scratches the surface of what you can do with Karabiner. Another quick hack I use and love (as a programmer):

tap [ once -> type "["
hold [ and tap ] key once -> type "{"
tap ] once -> type "]"
hold ] and tap [ key once -> type "}"

If you’re a programmer this makes it easier to type curly braces without contorting your fingers and flaring up that RSI. For typing paranthesis there’s an even better one:

left_shift once -> type "("
hold left_shift -> use as a regular shift key modifier
right_shift once -> type ")"
hold right_shift -> used as a regular shift key modifier

But there’s more! #

Apart from just modifying your key strokes, you can do advanced stuff like launching programs too. For example I typically switch between 3 applications pretty often: iTerm, Firefox, Things. With Karabiner, I use the same technique but switch programs pretty quickly:

hold o (for "open") + tap i -> launch "iTerm"
hold o + tap f -> launch "Firefox"
hold o + tap t -> launch "Things"
tap o once -> type "o"

This makes switching between apps almost instant. I don’t have to carefully Cmd + Tab, visually recognize each icon (adding one extra cognitive step 😁) and then launch it. This might seem frivolous at first but once you start using this quick open mode like functionality, it’s hard to go back to Cmd Tabbing.

Turbocharge mode (Karabiner + Keyboard Maestro) #

I swear by Keyboard Maestro and use a lot of my macros pretty often. With Karabiner, I can map certain keyboard strokes to instead launch macros. For example, if I want to quickly Google something, I hold “o” then tap “g” -> this shows an input dialog to take in my text, then launches a new tab in firefox with a url to google prepoulated with my query.

hold "s" + tap g -> google for something on the web

This kind of usage in conjunction with Keyboard Maestro basically unleashes the power of your Mac.

How do I do this? #

Before you head to the races and start using Karabiner though there’s one caveat:

Use Goku to organize your Karabiner

See the problem with Karabiner is that if you want to start doing the tricks I mention above, you pretty much have to start meddling directly with this file called karabiner.json. Let’s just say json is not the most maintainable format for this kind of stuff.

After meddling with Karabiner for a few days, it was clearly getting unwieldy to maintain the json file. So on an exaseperated whim, I went searching for a way to make it easier to deal with Karabiner and found the wonderful Goku.

Enter Goku #

Goku basically is a DSL where you can write a nice and condensed form of the same code you would otherwise wrangle up in your karabiner.json. You write the code in this special format called “extensible data notation” (edn). Goku then reads that edn format and generates the karabiner.json file for you.

For context:

my karabiner.json file currently has about 920 lines
my karabiner.edn file on the other hand has 140 lines (and most of it is liberal commenting and whitespace to combat edn’s terseness)

{:des "o-mode: quick open"
 :rules [:o-mode
 [:f [:open "/Applications/Firefox.app"] ]
 [:g [:km "0) Search Google"] ]
 [:i [:open "/Applications/iTerm.app"] ]
 [:q [:km "open: Quip"] ]
 [:t [:open "/Applications/Things3.app"] ]
]}

{:des "right cmd -> right ctrl"
 :rules [
 [:##right_command :right_control [:apl-usb-int :apl-bt :ap2] ]
 ]}

{:des "left shift once -> ("
 :rules [
 [:##left_shift :left_shift nil {:alone :!S9} ]
 ]}

{:des "right shift once -> )"
 :rules [
 [:##right_shift :right_shift nil {:alone :!S0} ]
 ]}

Speaking as a programmer the edn format is quite possibly the most terse, terrible format I’ve encountered. I gave a quick look at some of the examples and almost abandoned my Goku effort half way.

But after spending an 11 hour flight back home fiddling and learning how to use Goku, I’ve gotten a decent hang of the format and I admit it’s super mantainable.

How to read and use Goku #

I’m not going to explain how to use Goku, but I’ll tell you what helped me pick it up:

Read this fantastic blog post by Nikita Voloboev once
Follow along then with the official tutorial as they explain the basics
Read the blog post from step 1 again, given you’re a little more familiar with the format
Read my karabiner.edn file

I spent a lot of time commenting my edn file with the hope of making it more readable, so hope that helps. I plan on making a youtube video at some point demoing all this but until that happens, hope this blog post is helpful.

Hit me up on Twitter for queries or comments. Super curious to see other creative hacks people can come up with this technique.

Example edns #

Mechanical keyboards are a costly unhealthy obsession. I switch between an Anne Pro 2 and a TADA68 these days. ↩︎

Architecting Android and iOS app features for 2020

Sat, 26 Oct 2019 00:00:00 GMT

Inspired by some well known architecture patterns like MVVM/MVI, I set out to come up with an agnostic set of principles that would help developers build features in their app in a robust, safe and (importantly) “testable” way. At Instacart, we’ve started to use these principles to build features on both iOS and Android.

In this talk, we’ll examine these principles, discuss the merits (+ disadvantages!) and see how these can be implemented with precise code examples. Having implemented this pattern for sometime now at Instacart, I’ll also share some of our learnings along the way for both platforms.

Slides #

Bob Iger remembers Steve Jobs

Mon, 23 Sep 2019 07:00:00 GMT

This whole piece is such a biograpy treasure trove and one I’m filing under the “come back and read in a year” category.

I’m highlighting some of the snippets in particular that really resonated with me:

“This is going to allow people to watch video on our iPods, not just listen to music,” he said. “If we bring this product to market, will you put your television shows on it?” I said yes right away.

I love how Steve was testing Bob with this decision. Could this still work? Can this eager hungry new CEO walk the talk, with said bold decisions. The part that might not be immediately obvious here is that in this test, Steve too is opening up the kimono about the video iPods here.

The ease and the speed with which we got the deal done, combined with the fact that it showed an admiration for Apple and its products, blew Steve’s mind. He told me he’d never met anyone in the entertainment business who was willing to try something that might disrupt his own company’s business model. Steve responded to boldness. Among his many frustrations was a feeling that it was often too difficult to get anything done with Disney. Every agreement needed to be vetted and analyzed to within an inch of its life, and that’s not how he worked. I wanted him to understand that I didn’t work that way, either, that I was empowered to make a call, and that I was eager to figure out this future together, and to do so quickly.

A lesson to always remember for any successfull company. The irony here is that Steve functioned this way. A company the size of Apple (i presume) can’t. Yet Steve pulled it off with Apple. An individual can bring in change.

“Okay,” he said. “Well, I’ve got some cons.” He wrote the first with gusto: “Disney’s culture will destroy Pixar!” I couldn’t blame him for that. His experience with Disney so far hadn’t provided any evidence to the contrary. He went on, writing his cons in full sentences across the board. “Fixing Disney Animation will take too long and will burn John and Ed out in the process.” “There’s too much ill will and the healing will take years.” “Wall Street will hate it.” “Your board will never let you do it.” There were many more, but one in all cap letters, “DISTRACTION WILL KILL PIXAR’S CREATIVITY.”

Culture, individual contributor burnout, killing Creativity. I love how these were so important to Steve, more so than any other factor. Most companies like to talk about these things and mostly cause it worked for Apple. But such massive positive change can be brought about in a company when leaders a) understand these qualities and b) hold them up high.

Several members of the board were still opposed, but the moment the Pixar team started talking, everyone in the room was transfixed. They had no notes, no decks, no visual aids. They just talked

I’ve been interested in public speaking for quite sometime, and I’ve always believed this to be a mark of a truly engaging speaker. Another example of this is Ken Robinson’s talk on schools killing creativity.

Sadly this isn’t easy for technical talks but i’d love to see more keynote speakers at technical conferences adopte this style of just telling a genuine, honest, engaging story without needing slides to keep listener attention.

He spent about 10 seconds looking at it, then pushed it aside and said, “Is this one important to you? Do you really want it? Is it another Pixar?”

I love the trust here. This is an incredibly crazy reality shifting deal here that was made in the end by one genius trusting the instinct of another. This is especially noteworth given Steve hated comics.

He claimed to have never read a comic book in his life (“I hate them more than I hate video games,” he told me)

Sorry Steve, you missed out on a lot here.

Parting thoughts:

It’s so important to have mentors and to constantly be learning from others. Seniority has nothing to do with it. Craftsmen are available everywhere.

I’ve been learning iOS development lately and i’m a newb. I’ve got some experience in the Android development side now and can hold my own. But it’s just so refreshing to go into something that you know very little but can learn. I understand mobile development so i have an advantage, but i have to be so careful to not think i know how stuff works already.

I’m willing to look foolish if it means, i’ll learn something. The best piece of advise i’ve picked up on.

Learning is the most important thing. Learning happens at different levels. Conviction is important

Thanks to the brother who shared this on his tweet stream.

Speed up your Android Studio

Mon, 19 Aug 2019 07:00:00 GMT

I use a 13" MacBook Pro at work these days. Android Studio frequently sent my machine into a tailspin.

Over time, I’ve had to tweak and update my AS settings to make AS work well on the 13". I figured I should post them here for posterity and the benefit of other AndroidDevs battling with deathly slow AS experiences.

I’m posting the abridged instructions and linking to the blog posts that led me to these settings, if you care for the details.

Switch to a local gradle distribution #

curl -s "https://get.sdkman.io" | bash # install sdkman

# install your preferred version of gradle

sdk install gradle 5.4.1
sdk default gradle 5.4.1

gradle --status

Once you have a local distribution of gradle installed, switch the “Gradle home:” setting in your Android Studio project to point to your local gradle distribution. You’ll have to do these for all your projects individually.

With this setup, when you run gradle on the command line or Android Studio, they’ll share the same gradle daemon instances.

☝️ also make sure the daemons from AS and your command line are compatible #

Well almost. You also have to make sure you’re using the same JDK otherwise the gradle daemons will be incompatible.

# you have sdkman installed already
sdk install java 8.0.202-zulu # use java 8 preferably
sdk default java 8.0.202-zulu

sdk install kotlin # cause why not

Now point Android Studio to use this jdk like so:

💥 now we’re in business.

Disable any useless plugins or add-ons that you don’t need #

Don’t get carried away and disable everything here. It will hose your Android Studio. I know this cause I sure as hell tried.

The only plugins I have enabled are:

(Downloaded) IdeaVim
Android APK Suport
Android NDK Support
Git Integration (cause i like Intellij’s Differ)
Gradle
Groovy
Il8n for Java
Intellij Configuration Script
IntelliLang
Java Bytecode Decompiler
JUnit
Kotlin
Properties Support
Smali Support
YAML

Everything else is disabled. This crony from Bob’s Discount Action Bars apparently knows a thing or two about Android.

Tweak your `studio.vmoptions` file #

The official developer docs talk about configuring this properly.

tl;dr: in Android Studio head to “Help > Edit Custom VM Options…” and change it to the below:

#-Xms256m
#-Xmx2048m
-XX:ReservedCodeCacheSize=240m
-XX:+UseCompressedOops
-Dfile.encoding=UTF-8
-XX:+UseConcMarkSweepGC
-XX:SoftRefLRUPolicyMSPerMB=50
-Dsun.io.useCanonCaches=false
-Djava.net.preferIPv4Stack=true
-Djdk.http.auth.tunneling.disabledSchemes=""
-Djna.nosys=true
-Djna.boot.library.path=

-da
-Xverify:none

-XX:ErrorFile=$USER_HOME/java_error_in_studio_%p.log
-XX:HeapDumpPath=$USER_HOME/java_error_in_studio.hprof

# ###############################################
# custom settings from https://github.com/artem-zinnatullin/AndroidStudio-VM-Options/blob/master/studio.vmoptions
# ###############################################

# Runs JVM in Server mode with more optimizations and resources usage
# It may slow down the startup, but if you usually keep IDE running for few hours/days
# JVM may profile and optimize IDE better. Feel free to remove this flag.
-server

# Sets the initial size of the heap, default value is 256m
-Xms1G

# Max size of the memory allocation pool, default value is 1280m
-Xmx2G

# Sets the size of the allocated class metadata space that will trigger a GC the first time it is exceeded, default max value is 350m
-XX:MetaspaceSize=512m

Anything else you’ve come across that’s helped a lot? Hit me up on Twitter.

Updates since my post was originally published: #

@TheSNAKY pointed me to an easier way to get to the Edit VM options.
@matthewcmckenna reminded me that using sdk man, using the /current path is better as you upgrade versions. I’ve changed the commands here to mark the default installation and then just point to that within the Android Studio screenshots

Useful resources and reference links: #

assertLastValue for RxJava TestObservers

Sun, 18 Aug 2019 07:00:00 GMT

The TestObserver is an RxJava staple for testing.

It allows you to assert values in a stream, in the specific order they were emitted. Here’s a quick code snippet from the movies-usf repository ¹:

@Test
fun onSearchingForMovieBladeRunner_shouldSeeSearchResult() {
 viewModel = MSMainVm(mockApp, mockMovieRepo)
 val viewStateTester = viewModel.viewState.test()

 viewModel.processInput(SearchMovieEvent("blade runner 2049"))

 viewStateTester.assertValueAt(1) {
 assertThat(it.searchedMovieTitle).isEqualTo("Searching Movie...")
 true
 }

 viewStateTester.assertValueAt(2) {
 assertThat(it.searchedMovieTitle).isEqualTo("Blade Runner 2049")
 // ...
 true
 }
}

If you look at the source for the base TestObserver, there are a bunch of these useful methods:

assertValue(Predicate valuePredicate): Asserts that this TestObserver/TestSubscriber received exactly one onNext value for which the provided predicate returns true.

assertValue(T value): Assert that this TestObserver/TestSubscriber received exactly one onNext value which is equal to the given value with respect to Objects.equals.

assertValueAt(int index, Predicate valuePredicate): Asserts that this TestObserver/TestSubscriber received an onNext value at the given index for the provided predicate returns true.

assertValueAt(int index, T value) Asserts that this TestObserver/TestSubscriber received an onNext value at the given index which is equal to the given value with respect to null-safe Object.equals.

assertValues(T… values) Assert that the TestObserver/TestSubscriber received only the specified values in the specified order.

assertValuesOnly(T… values) Assert that the TestObserver/TestSubscriber received only the specified values in the specified order without terminating.

While all these operators are useful, most of them require you to know the precise index of the value you’re testing. Typically though when i’m testing a feature built with a USF architecture, I really only care about the last value emitted in my test case.

When working with a more recent example in my demo app: I had a checklist that I would toggle multiple times in different permutations and combinations. Depending on the final state of the checklist, a save button would be enabled/disabled. So my test really cares only about the very last value viz. the state of the save button. Knowing the precise index value of the final result started to get tiring.

An argument could also be made that for this test, testing with the precise index value actually makes it a little brittle. Say I introduced an additional loading state (for some reason), I would have to go back and change all my tests to update the precise index number. I fully understand this is tricky territory cause some would argue you would also want to test the intermediate loading states. All I’m saying is that for these specific tests, I didn’t care about the intermediate loading state, just the final output.

So if we ran with that idea, how do you make the test less brittle?

vsTester.assertValueAt(vsTester.valueCount() - 1) {
 // predicate condition tested
 true
}

As simple as that, just test the last value using valueCount. But if you’re in Kotlin land, you’re spoilt with all those tasty elegant apis, so you definitely want to make this easier by adding an extension function like so:

fun <T> TestObserver<T>.assertLastValue(predicate: (T) -> Boolean) {
 assertValueAt(valueCount() - 1) { predicate.invoke(it) }
}

💥

Now these tests read much more fluidly:

vsTester.assertLastValue {
 // predicate condition tested
 true
}

Take a look at the DemoGenreVmTest class if you’re interested to see a bunch of these in full action.

Remember the ABC of programming - Always Be CTesting…

movies-usf is a simple open source Android demo app where I demonstrate how one can build features using a Unidirectional State Flow (MVI) pattern ↩︎

Is iOS starting to get fragmented?

Thu, 13 Jun 2019 07:00:00 GMT

I’ve been dipping my toes into some iOS development recently. Nothing too crazy, just pairing with some colleagues and trying to see how we can jointly improve the technical design on both platforms .¹

It so happens that Apple just finished it’s annual conference WWDC, so I’ve been following the announcements closer this timer around. In that process, I ran across a tweet (from Jeff Nadeau who’s a developer working at Apple):

Sort of blown away by the take that a min OS target is harmful to a new framework. It’s absurdly small-minded; one or two years of adoption lag is nothing when the arc of such a system is measured in decades.

To set a little more context: the system Jeff talks about here is SwiftUi, a new framework library that will truly change the way iOS developers write their UI code. The niggle here is that SwiftUI is limited to just adopters of iOS 13.

This basically means:

Since the adoption rate for new OS updates is about 2 years for iOS, iOS 13 (newest version) will take 2 years to roll out to most iPhones
iPhones 6 and below will never be able to run apps built with SwiftUi (as iOS 13 will run on iPhone 6S and later only)

I found this bizarrely familiar since this was the exact same problem Google had with Android² for the longest time. It was frustrating for Android developers because we would come back all excited from Google I/O, only to have the winds promptly taken out of our sails after we reviewed the horrendous state of OS adoption.

It would be pretty irresponsible to start using SwiftUi right now for app developers building apps today.

I do want to make it clear: this is not what Jeff is saying. He’s not suggesting everyone start using SwiftUi right now. The latter part of the tweet clarifies this:

… when the arc of such a system is measured in decades

2 years might just be the cost to pay for iOS developers to have an amazing framework like SwiftUi that will eventually make development cycles 4x better. Especially since a sea of change is measured in longer cycles (10 years?).

That being said, this is painful to hear for app developers today. 2 years is excruciatingly painful. Trust me, us Android developers have been there multiple times.

But this fragmentation problem is something that the Android team has experienced and countered. From the Android Jetpack docs:

Jetpack comprises the androidx.* package libraries, unbundled from the platform APIs. This means that it offers backward compatibility and is updated more frequently than the Android platform, making sure you always have access to the latest and greatest versions of the Jetpack components.

This means that when Jetpack Compose (Android’s SwiftUi) comes out, developers can start using it right away. They won’t have to wait for their users to adopt the newest OS update.

I’m curious if the existing iOS infrastructure didn’t allow such a mechanism or it was just a conscious decision to take SwiftUi forward faster, without being held back by the burdern of backwards compatibility.

Closing remarks:

Even though Jetpack Compose was announced earlier, SwiftUi looks to be in far better shape as of today. Just look at the examples and documentation (also @RunChristinaRun says so)
SwiftUi will works on iOS, MacOS, iPadOS, watchOS and tvOS. That’s incredible. Google hasn’t confirmed yet if JetPack Compose will work on more platforms, but the way it’s being built, it sounds like it might be possible
If you know me, you’ll know why this title is kind of funny
See supporting the iPhone SE resolution

I also diligently throw shade every time I see them struggle with Xcode trying to autocomplete something. It’s almost laughable how far ahead Android studio is. ↩︎
Granted the case of OS fragmentation on Android is exacerbated by the fact that OEMs control when the device gets an OS update (if at all). ↩︎

Processing a sorted array is faster than an unsorted one?

Sat, 08 Jun 2019 07:00:00 GMT

This super intesting stack overflow answer explains why -in programming- if you have a sorted array, somehow magically it can seem like it’s easier to process each element vs processing the same array if it were unsorted.

tl;dr - branch prediction

With a sorted array, the condition data[c] >= 128 is first false for a streak of values, then becomes true for all later values. That’s easy to predict. With an unsorted array, you pay for the branching cost.

Space Shuttle style programming

Wed, 05 Jun 2019 07:00:00 GMT

Sometime back I ran across a thread where folks talked about this programming style called “Space Shuttle style” that the Kubernetes codebase followed.

// ==================================================================
// PLEASE DO NOT ATTEMPT TO SIMPLIFY THIS CODE.
// KEEP THE SPACE SHUTTLE FLYING.
// ==================================================================
//
// This controller is intentionally written in a very verbose style. You will
// notice:
//
// 1. Every 'if' statement has a matching 'else' (exception: simple error
// checks for a client API call)
// 2. Things that may seem obvious are commented explicitly
//
// We call this style 'space shuttle style'. Space shuttle style is meant to
// ensure that every branch and condition is considered and accounted for -
// the same way code is written at NASA for applications like the space
// shuttle.
//
// Originally, the work of this controller was split amongst three
// controllers. This controller is the result a large effort to simplify the
// PV subsystem. During that effort, it became clear that we needed to ensure
// that every single condition was handled and accounted for in the code, even
// if it resulted in no-op code branches.
//
// As a result, the controller code may seem overly verbose, commented, and
// 'branchy'. However, a large amount of business knowledge and context is
// recorded here in order to ensure that future maintainers can correctly
// reason through the complexities of the binding behavior. For that reason,
// changes to this file should preserve and add to the space shuttle style.
//
// ==================================================================
// PLEASE DO NOT ATTEMPT TO SIMPLIFY THIS CODE.
// KEEP THE SPACE SHUTTLE FLYING.
// ==================================================================

To be clear: I don’t follow the Space Shuttle style programming with my own code. However, I’ve noticed now that when I do comment my code, I’m a little more liberal with my explanations. It’s made me realize that commenting your code doesn’t necessarily always mean bastardizing it.

Originally, the work of this controller was split amongst three controllers. This controller is the result a large effort to simplify the PV subsystem.

However, a large amount of business knowledge and context is recorded here in order to ensure that future maintainers can correctly reason through the complexities of the binding behavior.

This is how I feel sometimes when people abuse abstraction. Yes, composition is important but long files are sometimes ok if it makes the code easier to comprehend by preventing that extra cognitive jump (required to first understand the name of the newly abstracted component).

From the Kubernetes source code.

IO vs CPU operations

Mon, 03 Jun 2019 07:00:00 GMT

This is a fantastic post by Erik where he explains the nuance between IO-bound and CPU-bound operations in programming.

… libraries have dedicated APIs for I/O scheduling work, separate from other types of operations

…. but why is this the case? Why don’t we use a single thread pool for all background operations? The operating system will handle the scheduling of these threads the same

I love how this specific question is framed (a good interview question for advanced mobile developers):

Why can’t we just split work into:

main (or UI) thread and
“all other background work” thread pool?

This way the UI shouldn’t stutter and if you have a pool of threads running in the background, all that background work will conveniently be executed, no problem. Right?

Even though both I/O-bound and CPU-bound work need to be executed in the background for mobile development, they have different demands and stress the operating system (OS) differently. Hence the need for different thread pool types to handle this kind of work differently.

CPU operations (like number crunching, computation etc.) run incredibly fast
I/O operations on the other hand (reading from a database, network etc.) take longer as the OS has to wait for underlying hardware to retrieve and deliver the data
Typically the underlying hardware sends out a signal IOWait to the OS while the underlying hardware is out and about doing the IO work
Instead of sitting and twiddling its thumbs, the OS should be finishing other tasks in the meantime (especially ones that are not waiting on underlying hardware) through other threads

When the operating system encounters an IOwait, it pauses the execution of that thread and is free to pick up another thread that is ready to run. Theoretically, an operating system can have an unlimited number of threads that are sleeping due to IOwait, without the user noticing any difference

That last point is subtle: this is why you don’t want to mix CPU and I/O threads in the same pool. You could potentially have a whole bunch of them IOWaiting and precious CPU work that could otherwise be done in the meantime, will also hang in the process waiting for that I/O work. Armed with this knowledge, if you’re into Rx you might ask:

How many maximum threads can the IO Scheduler have?

Unbounded! This should also makes sense now since we don’t want one I/O thread ever waiting on another since IOWaiting can take quite some time. Note that this is still a “pool” so threads are recycled but if all them are currently doing some work, Rx will spawn a new one everytime.

How many maximum threads can the Computation Scheduler spawn?

Basically, the number of processors your CPU has. My Pixel for example has a quad core processor, so that’s 4. This should also make sense now because CPU work should run blazingly fast, you probably don’t want an unbounded pool but some kind of optimum upper limit. That upper limit is the number of cores you have handy.

Erik’s a really smart guy. You should follow him on Twitter.

.hide() your Subjects - RxJava tip

Sat, 30 Mar 2019 07:00:00 GMT

A not so well known api in RxJava is the .hide() operator.

When does one use the hide operator in Rx? #

From the docs:

Hides the identity of this Observable and its Disposable.

Allows hiding extra features such as Subject’s Observer methods or preventing certain identity-based optimizations (fusion). there are a lot of complex operations that take place internally in RxJava (like internal queue creation, worker instantiation + release, numerous atomic variables being created and modified.)

If this doesn’t make too much sense, let’s look at examples to make this clear. Consider a typical MVVM usecase:

class MyAndroidVm : ViewModel() {

 private val outputSubject = BehaviorSubject.createOnDefault(initialViewState())

 init {
 Observable.just(service.pollModelData())
 .map {
 // ... do something with the Event that pipes a result
 // or view state eventually
 }
 .subscribe { viewState ->
 outputSubject.onNext(viewState)
 }
 }

 fun listenToViewState(): BehaviorSubject<ViewState> {
 return outputSubject
 }

 // ...
}

In this sample code, the ViewState is basically what the Activity would consume. So within the ViewModel, we pipe the data into a Subject, which is then exposed to the Activity like so:

class MyAndroidActivity: Activity {
 // ...

 override fun onResume() {
 viewModel.listenToViewState()
 .observeOn(AndroidSchedulers.mainThread())
 .subscribe { viewState ->
 // bind Android Views and ViewState object
 }
 }
 }

This is all great, however the trouble with exposing a Subject is that it allows the activity to modify the internal state of the Behavior Subject from the outside. This is non-ideal as we only want the ViewModel controlling this.

class MyAndroidActivity: Activity {
 // ...

 override fun onResume() {
 viewModel.listenToViewState()
 .onNext(badViewState()) // we want to avoid this
 .observeOn(AndroidSchedulers.mainThread())
 .subscribe { viewState ->
 // bind Android Views and ViewState object
 }
 }
}

So we don’t want to expose the Subject directly. It would make more sense instead to just expose an Observable.

This is where the .hide() operator comes in handy. It basically converts a Subject into an Observable.

// inside the ViewModel

fun listenToViewState(): Observable<ViewState> {
 outputSubject.hide()
 // this returns an Observable (instead of a Subject)
}

But there’s actually more to the hide operator. It’s not as simple as merely converting a Subject -> Observable. If i merely wanted to just convert the Subject to an Observable, I could have just used the cast operator:

outputSubject.cast(ViewState::class.java) // this returns an Observable

So you may ask when should one use .hide vs just a .cast

Operator fusion and performance #

Let’s revisit the documentation for .hide:

Allows hiding extra features such as Subject’s Observer methods or preventing certain identity-based optimizations (fusion).

This is where things get interesting. We’ve already seen the “hiding extra features such as Subject’s Observer methods” bit through our example.

But apparently, there are also some identity-based optimizations that are avoided. I wasn’t aware of what these optimizations were but RxJava savante and maintainer David Karnok has written a couple of great posts on operator fusion.

I’m not going to regurgitate his content here but the tl;dr version is - for all the thread hopping and asynchronous magic that RxJava enables, there are some internal costs to pay (obviously). When you combine a sequence of operators (which you’re bound to do for any Rx call), there are times where we incur an overhead.

Operator fusion is the idea that we can fuse or combine some of the internal operations to help reduce some of that overhead. If you want a more detailed (and accurate) description of the details, head on over to David’s blog for some of those details.

So if you don’t need some of these additional optimizations, use the .hide() operator.

I also love looking at the source code, so i did just that for .hide and noticed it simply wraps and sends the observable with ObservableHide. This proces of re-creating a wrapped version of the ObservableHide pares down a lot of the operator functionality. Reading the source also made me realize that this would work:

outputSubject.hide().hide().hide().hide().hide()

But I wouldn’t be worrying about performance and functionality at that point.

Japanese Manhole art

Mon, 18 Mar 2019 07:00:00 GMT

The Japanese can chalk this up to their creative laurels along with:

Kotlin 1.3.20 released

Sun, 27 Jan 2019 07:00:00 GMT

This feature is beneficial for projects defining custom source sets, since the compilation of independent source sets can be parallelized. In the case of multiplatform projects, targets for different platforms can also be built in parallel. For Android, the debug and release build types can be compiled in parallel.

This sounds pretty cool, however I paused to think how often would i need the debug and release build types to be compiled in parallel? Probably CI like environment? oooo but with androidTest and test ? that might help.

Brings improvements for inline classes

inline classes imho, is one of those things developers should jump on to right away. It can have a significant impact on the way you do development especially as it relates to Type driven design. I did a fragmented episode on the subject recently.

All improvements to inline classes, highly welcome 🙏.

Since Kotlin 1.3, you can use the main function without parameters.

For the kscripters, this is actually pretty nifty. I missed the introduction of this feature in 1.3.

A new intention allows to convert constructs using lambdas with SAM to anonymous objects.

If you understand this well, you’ll realize this almost seems backwards. Why would i ever want SAM -> anonymous you ask? Hello dear RxJava Kotlin users, read this blog post on Kotlin’s SAM problem to understand the specifics better.

In addition, we’ve added support for Compile Avoidance for kaptKotlin tasks in Gradle, improving build performance times.

I hate on kapt a lot for affecting my build times. Any improvement here is always welcome.

In closing, how cool is it, my chosen programming language gets an update, and i can start using it almost right away? (let the Java-writing-old-timers from the early Android world envy).

New Year - 2019

Tue, 22 Jan 2019 07:00:00 GMT

So i’ve been doing these kinds of posts for sometime now.

Truth is i’ve been inconsistent with the format. Sometimes these are reflection posts (what happened last year) and other times they are resolutions posts (what i’m looking forward to in the next year). Usually it lands up being an amalgam of both, and I kind of like that personally. So i’m going to stick to keeping it a mishmash of thoughts as i begin the new year.

2018 in review: #

So the brother was married end of 2017 and while things got busy (Indian weddings and all), it was a blast.
I helped organize Instacart’s annual hackathon for the first time and it was way more fun than i anticipated :).
I spoke at a conference in Russia. Moscow was one of the most beautiful cities i’ve visited and i was surprised by how friendly the folks were. Easily one of the best trips last year. Definitely going to be visiting them again (don’t let the current political climate fool you, it’s refreshing how much the locals don’t care about that stuff).
We created our 100th episode on Fragmented (it was in 2018, but i didn’t write one of these posts for that year so i’m allowed to cheat). It remains one of the most fulfilling projects i’ve started in my life. The listeners remain the #1 reason Donn and I continue push episodes every week.
I watched a tonne of movies in the theaters. Sadly, i didn’t keep a track of them but intend to for 2020 (already counting 5 movies watched this year).

2019 todos: #

While i think it’s important to live life as the universe serves it to you, i typically like to have a few goals or things in my bucket list that i like to kick the year off with. These are the ones i’m thinking/starting with for 2019:

Practice Vim for 30 days #

I love tinkering with my tools and i genuinely think that responsible “good” programmers spend at least 20-30% of their time tweaking their tooling. I’ve also noticed over the years, that the mentors i look up to, who use vim, friggin fly with it. It’s mesmerizing to simply watch them fiddle with text! Check Gary from DAS.

So this year, i decided i’m going to only use vim, for 30 days straight. I’m not saying i’ll switch to vim 100% yet (thought it’s looking very likely) but i want to genuinely give it a fair shot and see if sticks (this is day 22 of only using vim and this post was written entirely in vim. Look out for a follow up post with my feelings and findings).

Care about your privacy #

The Facebook debacle shook me a lot this year. We live in a world where democratic presidential races were influenced by Facebook. Your data is valuable. Yes, you who thinks you have nothing to hide, your data is equally valuable. Wake up already.

I’ve already switched completely to Firefox (follow up post on this as well coming). The biggest change will be my phone. I also use an iPhone now along with the Pixel 2 i use and i’m starting to not like the fact that Google tracks everything I do and doesn’t allow me to use half their services without sharing uncomfortable amounts of my data. This one is going to be hard.

Blogging + screencasting? #

I moved this blog to Jekyll (after it became clear that Octopress was probably not going to be actively maintained anymore). My hello 2020 post will bear evidence to how active i’ve been here but i’m going to try and post more here.

The other thing i’m also really curious about doing more is screencasting. I don’t want to limit it to just Andorid, if anything i want to do more non-Androidy stuff like my tips, hacks, productivity scripts etc. Let’s see if i can bring myself to doing more of that.

I remain grateful for my friendships and the new friends i’ve made this year, that have truly made me a better person.

Let’s kick 2019’s butt!

Unidirectional State Flow patterns – a refactoring story

Fri, 28 Sep 2018 00:00:00 GMT

Learn how to go to your existing old mobile app and refactor it into one with a powerful architecture.

Gave the presentation at MBLT Dev 2018

Slides #

Free hackathon vote tabulation using Google Forms & Kotlin

Sun, 09 Sep 2018 07:00:00 GMT

We recently held our semi-annual hackathon at Instacart - the Carrot Wars 2018!

In putting this hackathon together, I noticed a pretty blaring gap - there wasn’t a simple (and free) online service that would quickly tabulate the results for a hackathon event. We looked around and found some nifty options, but most of them were a tad bit too expensive for our liking. They also were not setup for a single event use or required a monthly subscription. There other usage restrictions, too - max vote count, concurrent user count, etc.

You’d think there would be at least some option out there, given how popular hackathons are these days. We did some cursory searching but couldn’t find something that would work for us.

My co-organizer , admittedly wiser about such things, made it super clear to me, “No KG, we ARE NOT building our own hackathon voting website 2 days before the event! You have more important things to do!”. So I set out to do exactly (½ of) just that.

If you’re on a time crunch and just want to use this post for a hackathon you’re about to run, jump to the “How to use this form for your hackathon” section below.

For the juicy details, please continue reading!

Solution choice #

Google Forms #

I wasn’t too thrilled about building an online voting form website (hi 2018!) so instead I chose to just leverage Google Forms. Google Forms is pretty easy to use, can handle a bunch of users slamming your form at the same time, provides a decent enough UI and is ridiculously easy to create and get going.

Kotlin script #

The part I found more interesting about this process was the result tabulation. I could have probably gotten Google Forms to dump the results in a Google Sheet. But my excel/sheets expression fu was not strong enough to conconct the required mathematical expression to get the results I wanted.

So instead of a seizure inducing mathematical sheet expression, I did what came more naturally to me and wrote a script in Kotlin to tabulate the votes and println the results nice and cleanly 😎.

I chose Kotlin cause I’m an Android developer and we love Kotlin here at Instacart. Interestingly the hackathon also coincided with the release of Kotlin 1.2.50 where the Kotlin scripting support was supposed to have been improved.

There’s something very satisfying about running a script in a terminal prompt like you would with bash, but without all the unpleasantness of the bash syntax and all the pleasantness of the Kotlin language.

Voting process: #

The hackathon had 5 categories (based on our core company values) that folks could participate in
On presentation day, we sent out a google form to all hackathon attendees with the list of final projects. They would pick the 1st, 2nd and 3rd places for each category
Google Forms allows a pretty convenient way to export these results as a CSV file
This Kotlin script ingests the CSV, tabulate the results, does some weighting math and prints the results for each category

How to use this form for your hackathon #

1. Building the Google Form #

I can’t recommend enough this Google Forms add-on called formRanger. formRanger allows you to populate your form from a simple google sheet.

This was particularly useful for us because we had folks signing up right at the very last moment, wanting to pitch their hackathon project. So up until the very last presentation, the project list was in flux and so the form needed to constantly be modified (we had 5 categories and about 30 pitches. That’s 150 entrees that we would have had to keep consistent - no bueno). With formRanger setup this was a single list in a simple google sheet.

You want your questions to be of type multiple choice grid. This way you can link a project (rows) to a position i.e. 1st, 2nd and 3rd place (columns).

There’s another important option you want set for each question - “Limit to one response per column”. This will make sure you don’t have more than one 1st, 2nd or 3rd place.

2. Installing kotlin script #

You can find most of the instructions for setting up the Kotlin script in the github project. tl;dr:

# install sdkman (if you haven't already)
curl -s "https://get.sdkman.io" | bash
sdk install maven
sdk install kotlin
sdk install kscript

# alternatively with homebrew
brew install maven
brew install holgerbrandl/tap/kscript

3. Generate the CSV results file #

In your google form, you should see a tab called “Reponses”. From there you should be able to “download responses (.csv)”.

Google Forms has a pretty decent visualization, which might just work for you, but I wanted to add some more sophistication in the tabulation of the results like weighting and maybe filtering based on categories. Basically, moving this to an actual program opens up a whole bunch of possibilities.

4. Running the command #

From a terminal prompt run the command like so:

kscript kscript carrot-wars-tabulate.kts ~/Downloads/star-wars-demo-results.csv

The very first time you run the script, it’ll take sometime as it pulls the necessary dependencies via maven. Give it some time; subsequent runs should be pretty snappy.

Here’s what it should look like:

$ kscript carrot-wars-tabulate.kts ~/Downloads/star-wars-demo-results.csv
******* PROGRAM START *****************
1 folk(s) voted!
-----------------------
Category: "Which is your favorite star wars movie overall?
----
STAR WARS: EPISODE IV A NEW HOPE ----> 6 <- [1]
STAR WARS: EPISODE VII THE FORCE AWAKENS ----> 3 <- [2]
ROGUE ONE: A STAR WARS STORY ----> 2 <- [3]
-----------------------
Category: "Which was your favorite SW movie from the original episodes?
----
STAR WARS: EPISODE IV A NEW HOPE ----> 6 <- [1]
STAR WARS: EPISODE VII THE FORCE AWAKENS ----> 3 <- [2]
STAR WARS: EPISODE V THE EMPIRE STRIKES BACK ----> 2 <- [3]
-----------------------
Category: "Which was your favorite standalone SW movie?
----
ROGUE ONE: A STAR WARS STORY ----> 6 <- [1]
SOLO: A STAR WARS STORY ----> 3 <- [2]
******* PROGRAM END *****************

Haters hate all you want, but those are my movie choices!.

4. Resources #

Demo Google voting form (go ahead and vote for your choice!)
Sample CSV responses file
Google sheet used to populate above form
Source repo for Kotlin script that tabulates and prints out the results

Originally posted this article on the Instacart tech blog. Reproduced here for posterity.

Supercharging your workflow with App Center and Azure

Mon, 07 May 2018 00:00:00 GMT

Discover how to break down the barrier between your hopes for a mobile CI/CD system and what’s available today using the powerful Azure toolset and App Center API’s. Go from an idea to a multi-platform React Native app powered by CI/CD in just a few steps. We’ll continue from there to learn how Logic Apps and Azure Functions helped power Instacart’s mobile development workflow from commit to a release to the store.

Squircle and sweating the design details

Thu, 15 Mar 2018 07:00:00 GMT

This is such a fantastic post on how Apple sweats certain almost unnoticeable design details.

I picked up a whole bunch of nuggets reading this article:

…iPhone X rounded screen corners don’t use the classic rounding method where you move in a straight line and then arc using a single quadrant of a circle. Instead, the math is a bit more complicated. Commonly called a squircle, the slope starts sooner, but is more gentle.

Here’ the wikipedia link to the mathematical shape Squircle.

The aforementioned article follows another link which has more gems:

Apple doesn’t have the patent on this. Any company can bring their surfaces to this degree of quality. So why don’t they? Companies used to have more excuses. It used to be that engineering CAD tools weren’t as concerned about this sort of thing. Or engineers might not have been expert in that module of their CAD tools. Or surface design tools and engineering tools didn’t play well together. Or its importance to the bottom line wasn’t recognized.

I got to admit, once I learnt of this shape — and how beautiful it looks when applied to hardware — I can’t stop seeing the absence of this shape in competing products.

Keep your friends close ;)

Smarter ToDos with Kotlin

Wed, 14 Mar 2018 07:00:00 GMT

Checkout this quick blog post I wrote for my company, tweaking the existing Kotlin TODO to work towards our requirements.

While I don’t think this solution is a panacea for all your missing code snippets, I have found some luck with this method, in adding accountability for those PR review feedback comments you say you’ll get to, but conveniently forget :)

Here’s a bonus if you’re reading this article from here:

/**
 * @param month - regular month (so 3 = March)
 */
@JvmOverloads
fun ISDate(
 day: Int? = null,
 month: Int? = null,
 year: Int? = null,
 hour: Int? = null,
 minute: Int? = null,
 second: Int? = null,
 date: Date? = null
): Date = Date().apply {

 val cal = Calendar.getInstance()

 date?.let { cal.time = it }
 day?.let { cal.set(Calendar.DAY_OF_MONTH, it) }
 month?.let { cal.set(Calendar.MONTH, it - 1) }
 year?.let { cal.set(Calendar.YEAR, it) }
 hour?.let { cal.set(Calendar.HOUR_OF_DAY, it) }
 minute?.let { cal.set(Calendar.MINUTE, it) }
 second?.let { cal.set(Calendar.SECOND, it) }

 return cal.time
}

It’s a pretty straightforward date builder with minor tweaks (for e.g. 3 = March cause what are we, Monsters ?).

My new programming font - IBM Plex Mono

Fri, 02 Mar 2018 07:00:00 GMT

I’m obsessed with typefaces and fonts .¹

My programming productivity is irrationally dependent on the font I pick for my IDE. I have spent unhealthy amounts of time experimenting and trying different fonts for programming.

I usually prefer a monospaced font and I’ve bounced between Inconsolata and Consolas in the past – both truly beautiful typefaces.

Recently though, a design director at Instacart shared this link on the laws of UX (a fantastic read btw).

But — hot damn — I was smitten after looking at that website. The font used there was GORGEOUS! I knew it was monospaced just from looking at it. I didn’t get past the first law, without first finding out which font was being used.

[Image: lawsofux.com]

Thus I stumbled upon my new programming font – IBM Plex Mono. I don’t make a font change in my IDE that casually, without first putting it through the paces.

I give it a glowing recommendation for your IDE. There’s an interesting back story behind the making of the font on Medium too.

Btw, just changing the font is not enough – you have to pick the right size and line spacing (I’ve found a size of 15 and line-spacing of 1.15 works best for me).

Download IBM Plex Mono absolutely for free.

Did you know – fonts and typefaces aren’t necessarily interchangeable. You use “typeface” when you’d use “song” (e.g. “I love that song/typeface …”), and “font” when you’d use “track” ("… so I’m going to buy the track/font for it"). ↩︎

Kindness and Positivity

Tue, 08 Aug 2017 07:00:00 GMT

We need more kindness and positivity in our online lives today. There is no side, that cannot benefit from that.

Being rational or correct is futile without empathy.

You can have opposing (or even incorrect) views but you have to find a kind and positive way to express that.

You either learn you’re wrong or convince the other of your point of view. But everyone is more willing to have the conversation, if approached with kindness and positivity.

A good first step for me is surrounding myself with kinder and positive people.

Rx by example – Volume 3 (the multicast edition)

Fri, 14 Jul 2017 00:00:00 GMT

The Android development community today has embraced Rx(Java) in all it’s glory. But as developer’s understanding of RxJava has matured, they’ve started to peel back the layers and unleash its true power and potential.

One such power is “Multicasting” where you get to share work across your app and reuse a whole bunch of stuff. This is really hard to do in general but Rx makes it really really easy.

Rx itself though has a steep learning curve. But the easiest way to grasp the concepts and features of Rx, is through examples. I’ve given talks in the past explaining Rx usage purely through examples and folks have found this to be the easiest way to warm up to Rx.

So that is what we’ll do today, learn by examples! In this talk, we look at fresh set of examples, all demonstrating the powerful concept of multicasting, but in the comfortable playground of simple and practical examples.

Slides #

RxJava 1 -> RxJava 2 (Disposing Subscriptions)

Wed, 21 Jun 2017 07:00:00 GMT

2 part series

This is a continuation post in a 2 part series:

Disposing Subscriptions #

This was the part that I initially found most tricky to grasp but also most important to know as an AndroidDev (memory leak and all).

Jedi master Karnok explains this best in the wiki:

In RxJava 1.x, the interface rx.Subscription was responsible for stream and resource lifecycle management, namely unsubscribing a sequence and releasing general resources such as scheduled tasks. The Reactive-Streams specification took this name for specifying an interaction point between a source and a consumer: org.reactivestreams.Subscription allows requesting a positive amount from the upstream and allows cancelling the sequence.

From that definition alone, it would appear like nothing’s changed but that is definitely not the case. In my first post, I pointed out:

Publisher.subscribe(Subscriber) => Subscription

The use of => vs = was intentional. If you look at the source code for Publisher’s subscribe method again, you’ll notice a return type of void viz. it doesn’t return a Subscription for you to tack on to a CompositeSubscription (which you can then conveniently dispose of onStop/onDestroy).

interface Publisher<T> {
 // return type void (not Subscription like before)
 void subscribe(Subscriber<? super T> s);
}

Karnok again:

Because Reactive-Streams base interface, org.reactivestreams.Publisher defines the subscribe() method as void, Flowable.subscribe(Subscriber) no longer returns any Subscription (or Disposable). The other base reactive types also follow this signature with their respective subscriber types.

So if you look at the declarations again

// RxJava specific constructs

// Observable implements "ObservableSource"
interface ObservableSource<T> {
 void subscribe(Observer<? super T> observer);
}

// Single implements SingleSource
interface SingleSource<T> {
 void subscribe(SingleObserver<? super T> observer);
}

interface CompletableSource {
 void subscribe(CompletableObserver observer);
}

interface MaybeSource<T> {
 void subscribe(MaybeObserver<? super T> observer);
}

Notice the return type void in all of them.

Getting hold of Subscriptions #

So you may ask how do I get a hold off that Subscription then (so that you might rightly cancel or dispose it off like a responsible citizen)?

Let’s take a look at the the Subscriber’s onSubscribe method:

public interface Subscriber<T> {

 public void onSubscribe(Subscription s);

 // Subscriptions are additionally cool cause they have:
 // s.request(n) -> request data
 // s.cancel() -> cancel this connection

 public void onNext(T t);
 public void onError(Throwable t);
 public void onComplete();
}

You are now given the Subscription class as a parameter in your onSubscribe callback. So within the OnSubscribe method, you have a hold of the subscription and can then conveniently dispose of the Subscription inside the onSubscribe callback.

This was actually a pretty well thought off change because this really makes the interface for a Subscriber lightweight. In RxJava 1 land, Subscribers were more “heavy” cause they had to deal with a lot of the internal state handling.

… but who are we kidding: that is not convenient at all (atleast for those of us who need the subscriber to depend on our lifecycle). I’d rather just shove everything into a CompositeSubscription like before and be on my merry way. But such are the rulings of the Reactive Streams spec.

Thankfully the maintainers of RxJava in all their benevolence realized this trade-off and have remedied this with convenient helpers.

But first, some more definitions:

`Disposable` is the new `Subscripton` #

What we called Subscription in RxJava 1 is now called Disposable.

Why couldn’t we just keep the name Subscription? (per my understanding):

You have to remember the Reactive Streams spec already has this name reserved and the maintainers of RxJava 2 are serious about the spec adherence. We don’t want confusion about there being more functionality with an Rx Subscription vs other Reactive Stream spec adhering libraries
We still want some of the behaviors and conveniences of RxJava 1 like CompositeSubscriptions.

So if Disposables is what we’re using now, by that token we have a CompositeDisposable which is the object you want to be using and tacking all your Disposables onto. It functions pretty similarly to how we used CompositeSubscription before.

Ok, back to the original question: how do I get a hold of the Disposable?

Getting hold of Disposables #

Now before we go any further, if you’re adding your callbacks directly in the form of lambdas, this is not a problem as most observable sources return a Disposable with their subscribe method call when not provided with a subscriber object:

Flowable.subscribe(Subscriber)
// void return type

Flowable.subscribe(nextEvent -> {}, error -> {}, () -> {})
// return Disposable so we're good

So if you look at some sample code, the below works fine no problem:

disposable =
 myAwesomeFlowable
 .observeOn(AndroidSchedulers.mainThread())
 .subscribe(event -> {
 // onNext
 }, throwable -> {
 // onError
 }, () -> {
 // onComplete
 });

compositeDisposable.add(disposable);

However if I rewrote that code just a little differently:

disposable =
 myAwesomeFlowable
 .observeOn(AndroidSchedulers.mainThread())
 .subscribe(new FlowableSubscriber<TextViewTextChangeEvent>() {
 @Override
 public void onSubscribe(Subscription subscription) {
 }

 @Override
 public void onNext(TextViewTextChangeEvent textViewTextChangeEvent) {
 }

 @Override
 public void onError(Throwable t) {
 }

 @Override
 public void onComplete() {
 }
 });
// ^ THIS IS WRONG. Won't work
// compositeDisposable.add(disposable);

The above code won’t compile. If you want to pass a Subscriber object (like the above FlowableSubscriber, ObservableSource or an Observer) then this strategy won’t work.

A lot of existing RxJava 1 code uses this strategy a lot, so the RxJava maintainers very kindly added a handy method on most Publishers called subscribeWith. From the wiki:

Due to the Reactive-Streams specification, Publisher.subscribe returns void and the pattern by itself no longer works in 2.0. To remedy this, the method E subscribeWith(E subscriber) has been added to each base reactive class which returns its input subscriber/observer as is.

E subscribeWith(E subscriber)

If you’re still following closely, you’d ask… wait! that doesn’t return a Disposable! why the hell is this even remotely more convenient?

Well… it says that the Subscriber you pass is sent back to you with subscribeWith. But what if your Subscriber itself “implemented” the Disposable interface? If you had a DisposableSubscriber, you could for all practical purposes treat it as a disposable and tack it on to a CompositeDisposable, while still using it as a Subscriber. That’s typically the pattern you want to adopt. Here’s some code that should make these techniques clear:

disposable =
 myAwesomeFlowable
 .observeOn(AndroidSchedulers.mainThread())
 .subscribeWith(new getDisposableSubscriber<TextViewTextChangeEvent>() {
 @Override
 public void onNext(TextViewTextChangeEvent event) {}

 @Override
 public void onError(Throwable e) {}

 @Override
 public void onComplete() { }
 });

compositeDisposable.add(disposable);

Apart from DisposableSubscriber, there’s also a ResourceSubscriber which implements Disposable. There’s also a DefaultSubscriber which doesn’t implement the Disposable interface, so you can’t use it with subscribeWith (you could use it but you wouldn’t get anything “disposable” out of it).

It seems like both DisposableSubscriber and ResourceSubscriber do the same thing. Why do both of these exist you ask?

The original 1.x Subscriber had the ability to take Subscriptions which allowed “disposing” the additional resources that particular Subscriber needed when the lifecycle ended or the Subscriber got unsubscribed. Since 2.x Subscriber is an interface declared externally, the old functionality had to be implemented via a separate abstract class: “ResourceSubscriber”. A key difference is you can create and associate Disposable resources with it and dispose them together from within the onError() and onComplete() methods you implement. Have a look at the example from within the docs

to .clear or to .dispose #

There’s no longer an unsubscribe call on CompositeDisposable. It’s been renamed to dispose ☝️️ but you don’t want to be using either of those anyway. The clear method remains, and is most likely the method you want to use.

What’s the difference? #

unsubscribe/dispose terminates even future subscriptions while clear doesn’t allow you to reuse the CompositeDisposable.

In the next and final part, we’ll look at some of the miscellaneous changes.

My thanks to Donn Felker & David Karnok for reviewing this post. Special thanks to David for correcting some of my misconceptions.

RxJava 1 -> RxJava 2 (Understanding the changes)

Wed, 21 Jun 2017 07:00:00 GMT

In case you haven’t heard: RxJava2 was released sometime back. RxJava 2 was a massive rewrite with breaking apis (but for good reasons). Most dependent libraries have upgraded by now though, so you’re safe to pull that migration trigger with your codebases.

Folks starting out directly with Rx2 might enjoy this guide but it’s the ones that started with Rx 1 that will probably appreciate it the most.

2 part series

This is a continuation post in a 2 part series:

Let’s get started.

In this first part, I want to dive into making sense of the Rx2 changes from the point of view of an Rx1 user.

Why things changed with RxJava2 #

tl;dr- Reactive Streams spec #

Reactive Streams is a standard for doing “reactive” programming and RxJava now implements the Reactive Streams specs with version 2.x. RxJava was sort of a trailblazer in reactive programming land but it wasn’t the only library around. There were others that also dealt with reactive paradigms. But with all the libraries adhering to the Reactive Streams spec now, interop between the libraries is a tad bit easier.

The spec per say is pretty straightforward with just 4 interfaces:

Publisher (anything that publishes events, so Observable,Flowable etc. - more on this later)
Subscriber (anything that listens to a Publisher)
Subscription (Publisher.subscribe(Subscriber) => Subscription when you join a Publisher and a Subscriber, you are given a connection also called a Subscription)
Processor (a Publisher + a Subscriber, sound familiar? yep Subjects for us RxJava 1 luddites)

If you’re slightly more curious about the design goals, I also suggest the following resources:

What’s different in 2.0 wiki page - this is really the place I kept coming back to and referencing when I needed to understand the details
Fragmented Ep #53 with JakeWharton (forgive the shameless promotion) - ultimate lazy person’s guide to understand why/what things changed with RxJava2, as explained by an actual demigod. This was the one that really made it first click for me.
Thought process behind the 2.0 design for the truly loyal
Ep 11 of The Context — by my friends Hannes and Artem :)

We should probably get one important change out of the way:

Dependency change #

Search:

compile "io.reactivex:rxjava:${rxJavaVersion}"
compile "io.reactivex:rxandroid:${rxAndroidVersion}"

compile "com.jakewharton.rxbinding:rxbinding:${rxBindingsVersion}"
compile "com.squareup.retrofit2:adapter-rxjava:${retrofit2Version}"

Replace:

compile "io.reactivex.rxjava2:rxjava:${rxJavaVersion}"
compile "io.reactivex.rxjava2:rxandroid:${rxAndroidVersion}"

compile "com.jakewharton.rxbinding2:rxbinding:${rxBindingsVersion}"
compile "com.squareup.retrofit2:adapter-rxjava2:${retrofit2Version}"

A minor change in your gradle dependency pull (“2” suffix).

The actual classes though have been moved to a new package internally io.reactivex (vs rx). So you’ll have to change those import statements.

Also you “could” theoretically have both Rx1 and Rx2 running simultaneously but this is a bad idea because certain primary constructs like Observables have a very different notion of handling streams (backpressure). It can be a nightmare during that interim period where you have to remember the behavior differences. Also if you happen to use both Rx1 and Rx2 Observables you have to be careful about qualifying them explicitly with the right package name (rx.Observable or io.reactivex.Observable). This is very easy to mix up and get wrong.

Bite the bullet and migrate it all in one shot.

Another super important change:

Observable -> Flowable #

Search : `import rx.Observable;`
Replace: `import io.reactivex.Flowable;`

Flowable is the new Observable. Succinctly - it’s a backpressure-enabled base reactive class.
You want to be using Flowable everywhere now, not Observable. Use this as your default.
Observables are still available for use, but unless you really understand backpressure, you probably don’t want to be using them anymore.

Flowable = Observable + backpressure handling

Note on “Publisher"s: #

Remember Publisher? it’s basically the Reactive Streams interface for anything that produces events (Reread the Reactive Streams spec section above if this is not making sense).

Flowable implements Publisher. This is our new base default reactive class and implements the Reactive Streams spec 1 <-> 1. Think of of Flowable as primero uno “Publisher” (this is also partly the reason I recommend Flowable as the new default, in the previous section).

The other base reactive classes that are Publishers include Observable, Single, Completable and Maybe. But they don’t implement the Publisher interface directly.

Why you ask?

Well the other base classes are now considered “Rx” specific constructs with specialized behavior pertaining to Rx. These are not necessarily notions you would find in the Reactive Streams specs.

We can look at the actual interface declarations and it’ll be clear.

Note on “Subscriber"s: #

So if Publisher is the Reactive Streams event producer, Subscriber is the Reactive Streams event “listener” (it’s extremely helpful to keep these terms firmly grounded in our heads, hence the incessant repetition).

Looking at the actual interface code declaration should offer more clarity to the above two sections.

// Reactive Streams spec

// Flowable implements Publisher

interface Publisher<T> {
 void subscribe(Subscriber<? super T> s);
}

As noted before, Publisher and Subscriber are part of the Reactive Streams spec. Flowable -which is now numero uno base reactive class of choice- implements Publisher. All good so far.

But what about the other base reactive classes like Observable and Single that we’ve come to love and use?

On the publishing side, instead of implementing the standard Publisher interface the other event producers implement a “similar” interface.

// RxJava specific constructs

// Observable implements "ObservableSource"
interface ObservableSource<T> {
 void subscribe(Observer<? super T> observer);
 // notice "Observer" here vs the standard "Subscriber"
}

// Single implements SingleSource
interface SingleSource<T> {
 void subscribe(SingleObserver<? super T> observer);
}

interface CompletableSource {
 void subscribe(CompletableObserver observer);
}

interface MaybeSource<T> {
 void subscribe(MaybeObserver<? super T> observer);
}

Notice: instead of having the standard Subscriber (Reactive Streams standard) the other base reactive classes (Observable, Single etc.) now have corresponding “special” Rx specific Subscriber or event listeners called “Observer"s.

That’s it for Part 1. In the next part, we’ll look at disposing subscriptions.

My thanks to David Karnok & Donn Felker for reviewing this post.

That Time I Met Andy Rubin

Wed, 31 May 2017 07:00:00 GMT

One of the advantages of working in the Bay area is you tend to run in to tech celebrities every so often.

I was working in Palo Alto (late 2015) on a previous startup (Wedding Party). My colleagues and I decided to get coffee at the nearby cafe. I saw Andy Rubin sitting outside casually talking to two other folks. I was certain it was him and told my buddies, “Hey, I think that’s Andy Rubin”. My colleagues (the lovable jerks that they were) said: “that’s the Android fanboy in you seeing things”. I obviously protested (with some casual bashing of their own phone choices).

As we grabbed our lattes and headed out, one of my buddies told me, “if you’re so sure, why don’t you just go up to him and ask?”. To which I replied: “you know what? I bloody well will! just to prove you jerks wrong”. They thought I was being my kooky self and went back to the office.

After making sure I wasn’t intruding his conversation, I walked up to him and said, “I hate to bother you but would you by any chance be Andy Rubin?”. Seeing the giant Android developer tee I was wearing, he let out a small smile and said, “that would be me! I’m Andy. How are you doing?”.

I was so elated and star struck that speech began to fail me. I don’t recall exactly what I said but it was along the lines of “thank you so much for Android! Your work has made such a difference, more so than you can imagine, you’re awesome, i’ve seen some of the code you wrote, it’s also awesome…etc etc (facepalm)”.

He was incredibly humble and asked me to sit down and join him while we talked. He asked where I worked and what our startup was doing. You could tell the dude was incredibly smart; 5 minutes into the conversation, he had some really great questions, thoughts and insights. I was truly amazed how someone so incredibly intelligent and smart, could also be so humble and hold a conversation with a joe like me. It definitely left a mark.

I walked back to the office and triumphantly told my colleagues they were dum-dums and I was totally right and I had the most awesomest conversation with Andy Rubin. They were pretty excited too and one of my pals, H asked:

H: “Oh cool! so did you tell him you just started an Android developer podcast?”

me: “arr… no, that… oddly… didn’t come up”

H: “did you tell him that our last office was the one where he started Android?” (this was true and probably a fantastic conversation starter)

me: “no… but i told him where our current office is and what we did” (sheepish smile)

H: “jeez KG! did you atleast tell him you were an Android developer?”

me: “i think he might have figured that out from our conversation… or my tshirt”

My colleagues were facepalming and laughing so hard that my announcement didn’t seem so triumphant after all. Sigh… to be star struck.

I still fondly remember the memory and am now fully armed with conversation points, for that next time I run into Andy.

Andy Rubin just announced Essential and I’m super excited to see where this goes.

New Year - 2017

Tue, 31 Jan 2017 07:00:00 GMT

I know it’s almost the end of January but I like to take my time with these posts. You can take a look at my previous year-end posts here.

In addition to just jotting things I was most proud/happy about this year, I also want to note down some of my learnings. There were many overwhelming moments that led to much introspection. I want to try and document some of those moments here (atleast the less embarrassing ones). So here goes:

Stuff I did: #

Fun stuff: #

met John Paul White : if you haven’t heard of the band Civil Wars, I plead you take a listen
learnt how to make my own latte (like an actual barista would). Given how big a coffee addict I am, this was bound to happen. Also landed up buying a Keurig machine for my new place >< (don’t judge me, it’s been the best investment ever)
cleaned up the blog design yet again (did it in a Singapore lounge on an 8 hour layover)

Travels: #

made the pilgrimage to Disneyland again this year (twice). The night parade blew my socks away (twice!)
hiked Grand Canyon with some buddies. Grand doesn’t even close to describing this place
Went camping at Yellow Stone National Park. It was crazy fun and cold! (we didn’t anticipate the temperature drop and woke up one morning in our tent to subzero temperatures.. that part was not so fun)
travelled to Sweden for the first time (my first time to Europe). I went to speak at a conference and the overall experience was simply amazing

Android stuff: #

Fragmented hit ep.70: this may not seem like a big deal by regular podcasting standards but Donn and I try very hard to keep Fragmented rich with content. Coming up with new interesting content every week is not as easy as you would think. But it’s been a crazy and extremely rewarding journey so far
Fragmented joins the Spec network. It’s an amazing team and the collaboration really helps us move faster
became a GDE. I’m honored and extremely grateful to have been recognized by Google for this
open sourced TrueTime: as part of a really interesting and challenging project at Instacart, we landed up open sourcing this library for Android. Read more about it here

Life learnings #

Buffet’s 2 list strategy #

I found myself constantly interested in a gazillion projects but struggled for time. I achieved a lot but just found myself more depressed cause I couldn’t finish everyting on my admittedly unrealistic list. I then came across this fantastic post by James Clear on Warren Buffett’s “2 list” strategy that explained how Warrent Buffett tackled this problem. It was eye opening and I now follow a similar routine to really whittle down my wishlist of projects.

Highly polarized decisions #

I knew we were on to something because it was so polarizing

Picked this up in the Presentable podcast. To paraphrase what’s said: You know you’re treading the right path if the decisions you take are highly polarized. If everyone is meh, that’s the most dangerous thing for your product. But if you have two groups both feeling very strongly about something, then you know you’re getting somewhere.

On changing your mind #

Anybody who doesn’t change their mind a lot is dramatically underestimating the complexity of the world we live in

Jeff Bezos

by way of this tweet.

Mindfulness and observation #

Mindfulness and keen observation just makes you a smarter person. One of my buddies is a top notch designer and all around super smart person. I noticed this quality about her and i’m convinced there’s a strong correlation between smarts and a good power of observation. If anything, being more aware just gives you the ammo to have smarter conversations.

Here’s an interesting exercise for you folks: if I asked you to draw the super ubiquitous USB symbol, how accurately would you be able to draw it? You’ve seen it countless times but have you stopped to observe that there’s actually a triangle, square and circle on each of the spokes of the trident? do you know what it signifies?

Being happy and enjoying your life #

I need to keep reminding myself of this more:

In the end, only three things matter:

how much you loved,

how gently you lived and

how gracefully you let go of things not meant for you

Buddha

I draw my learning not just from scriptures but also the sanctimonious art form of TV: while watching a rerun of Boston Legal (James Spader at his best btw) I noticed this phrase, which just made me happy:

wake up every morning, with all the promise that morning conveys

By way of an anecdote that Matt Damon mentioned, in an interview:

It’s easy to be younger, just make time.

Stephen Hawking

Software Engineering learnings #

These are more pertinent to software engineers and developers

Yishan tenets of growing a great engineering organization #

I came across this article by Yishan (an ex Engineering Manager at Facebook). If you’re looking for advice and tips on being a better software leader, definitely read this article. Key takeaways:

Hiring is number one
Let process be implemented by those who practice it
Promote from within
Tools are top priority (devs should really read this one)

10 modern software engineering mistakes #

This was a great read and honestly more a reaffirmation of some core technical beliefs. Keep learning and adapting.

Importance of vacation #

Most of my career has been in startup land and I enjoy every moment of it. But make no mistake, it takes a toll. You’re driven by the energy around you and if you happen to have great colleagues, the excitement is compounded. I hadn’t taken a proper vacation in almost 2 and half years. I totally could have, but just never felt it was the right time. But I decided to take a good 3 weeks off for the holidays this time, and it was absolutely fabulous. I met up with old friends and made so many new ones.

Most importantly, I came back fresh and my productivity was 2x what it was. Definitely going to be slotting in proper vacation time moving forward.

I was reminded of this story about Pixar:

The most powerful example dates back to the making of Toy Story 2 in 1999. With only seven months to go before its scheduled release date, Pixar’s creative leadership felt that Toy Story 2 was not working creatively. Disney, Pixar’s distribution partner, knew that it took 3-4 years to make an animated film. They argued that it was too late to start over and that Pixar should release the film as is. But Pixar refused, deciding instead to tear up the story and re-write it from scratch. The studio pushed itself to the brink of collapse to complete the new version of Toy Story 2 on time, and the film was a huge commercial and critical success. And, when it was completed, the executive team took the extraordinary step of closing the studio for two entire months to let everyone recuperate.

2016 was by far my most action packed year. 2017 has started with much trepidation and fear. But if there’s one thing these years have taught me, it’s never to lose hope and always to keep charging forward.

Onward and upward peeps!

What I learnt using the Presenter pattern

Thu, 10 Nov 2016 00:00:00 GMT

We recently did an overhaul for Instacart’s shopper app and committed to using a presenter pattern for this. It turned out awesome! Presenters are not a new concept. They’ve been around since the dawn of software engineering time. But the devil is in the implementation details. If you have an Activity, RecyclerView, Adapter etc. at how many levels would you have the presenter? How does the use of presenters enabled super fast testing? How does the use of presenters enable constantly changing user requirements? We’ll discuss all the juicy war stories in this session

Slides #

Learning Rx by Example (Part 2)

Wed, 09 Nov 2016 00:00:00 GMT

This is a revised version of a talk I first gave in 2015.

Slides #

New Year - 2016

Fri, 01 Jan 2016 07:00:00 GMT

I finished 2014 not having the slightest clue what would be in store. 2015 was a rollercoaster:

I started a new podcast Fragmented (with my cohost and now friend Donn Felker), bought my childhood dream car (a Mini Cooper), got a new job (Wedding Party was acquired by Instacart), visited NY for the first time (for a talk I gave at DroidCon NYC) and finally - this one really stumped me - moved to San Francisco.

The new year brings in a sea of sweeping change. With it I gain a little insight about myself and the world (yes, even the goofball that you see has been chiseled with each passing year). There were lows but we should focus on the highs.

Life is good, people can be amazing, let’s surprise ourselves and here’s to a peaceful and amazing 2016!

Painless UI Testing

Fri, 28 Aug 2015 00:00:00 GMT

What if you could get your UI tests to run as fast as your unit tests?

you would write more tests
you would feel happy writing the tests
your managers would be pleased with you not goofing around with that new testing framework around the corner

Using patterns of yore (like Martin Fowler’s supervising controller, effective use of presenters and view model state) we’re going to tackle everyday-real-annoying impediments to UI testing. We’ll address what parts of the UI need testing and effective ways of testing them.

The objective of the talk is to prove to the world that the title of this talk is not an oxymoron.

Slides #

A note about the warmth of the share and replay operators

Sat, 11 Jul 2015 07:00:00 GMT

A common question most android developers have when using RxJava is: how do I cache or persist the work done by my observables over a configuration change? If you start a network call and the user decides to rotate the screen, the work spent in executing that network call would have been in vain (considering the OS would re-create your activity).

There are two widely accepted solutions to this problem:

store the observable somewhere as a singleton, possibly apply the cache operator and re-subscribe on activity recreation
house your observable in a retained “worker” fragments ¹

I whipped up a quick example on github to demonstrate the second technique (which is generally my choice of poison). Now I’ve used the technique of worker fragments (successfully) a bunch of times before so I was a little surprised to see the example not work.

Let’s go over the use case again:

You have an observable that executes a long running network call. Before the call completes, you perform an activity rotation. After the activity is recreated, you continue the network call from where it left off or just use the result if it completes before your activity recreation process.

Instead of simulating this network call use case I decided to just fake it with a “hot” observable instead (which makes the use case a tad bit different but would help demonstrate the solution equally well). If you’re looking for a quick simple example that demonstrates the difference between a hot and cold observable, I strongly recommend watching this egghead.io video on the subject.

In fact, I used the exact same concoction of operators for my example:

Observable
 .interval(1, TimeUnit.SECONDS)
 .map(new Func1<Long, Integer>() {
 @Override
 public Integer call(Long aLong) {
 return aLong.intValue();
 }
 })
 .take(20)
 .share();

A little more investigation revealed that the share operator I used to fake the source stream was not really hot but “warm”. This is easier explained with Marble diagrams:

Here’s how we expect share to behave (and it does):

But owing to the activity recreation, what really happens is that the first subscriber (S1) unsubscribes from the source observable (O1 - housed in the worker fragment), after which a similar subscriber (S2) from the recreated activity subscribes again to O1 from the same worker fragment. So the marble diagram really lands up looking like this:

Notice that re-subscription? That changes things a little.

In this way, the share operator is “warm”. It behaves cold to first time subscribers but hot to subsequent ones.

the share operator behaves cold to first time subscribers but hot to subsequent ones

Epilogue: #

So how did I circumvent the problem? I added a fake subscriber that never unsubscribes.

storeObservable =
 Observable.interval(1, TimeUnit.SECONDS)
 .map(new Func1<Long, Integer>() {
 @Override
 public Integer call(Long aLong) {
 return aLong.intValue();
 }
 })
 .take(20)
 .share();

// Do not do this in production!
// this is a hack!
storeObservable = storeObservable.subscribe();

Clever but very hacky.² Think carefully before you write code like this in production.

Epilogue (Part 2): #

@fabioCollini on twitter said he preferred a replay().connect() approach over the publish().refcount() one which is what the share operator really is.

This reminded me of a tip that Dan mentioned once, replay is similar to share in that it’s hot to the first subscriber and cold to every other subscriber after the first item emits.³

replay is hot to the first subscriber and cold to every other subscriber after the first item emits

Because marble diagrams are amazing:

I’ve since modified the example to use a ConnectableObservable instead and it works pretty much the same way.

Alex Lockwood wrote about this approach here. ↩︎
I can’t take credit for this idea. The comments in the code reveal the identity of the troublemaker. ↩︎
Depending on what it’s replaying, it could also be cold to the first subscriber (he is quick to point out) ↩︎

Ken Burns: On Story

Wed, 17 Jun 2015 07:00:00 GMT

Learning Rx by Example (Part 1)

Thu, 04 Jun 2015 00:00:00 GMT

So RxJava is this new kid on the block. But what can you the Android developer really use it for today? We’ll look at everyday use cases and solve them with RxJava.

Remember that first day when you tasted Nutella? RxJava is Nutella for Android… everything is awesome with RxJava.

Slides #

The Audio Latency Problem on Android

Thu, 16 Apr 2015 07:00:00 GMT

when Billy Joel was on the Jimmy Falon show and they used the iPad app “Looper”, i immediately looked for the android equivalent. there wasn’t one. i’m an android developer and a sound engineer (enthusiast) so obviously the right thing to do, was build one…

i spent about two weeks and then gave up on the project cause it demanded far more time than i initially anticipated. the linked article is a fantastic read and summary on the problems with audio latency in android (and why i eventually just gave up on that project).

Fragmented Podcast - Episode #2 : Android Studio

Tue, 03 Mar 2015 07:00:00 GMT

hear ye, hear ye! the 2nd episode of the Fragmented Podcast is out. Donn and i start by discussing Lamas, blue dresses and IDEs for Android development!

Rx Is Coming

Mon, 02 Mar 2015 07:00:00 GMT

i spent a huge part of my 2014 on “Rx” (or reactive extensions) which is essentially a library that helps with a development pattern called “reactive programming”. i think Rx is going to be huge in the app development world. it’s already picked up a lot of steam, but i think it’s going to become a staple for professional app developers.

consider this extremely common scenario:

you’re in Burundi surfing facebook. you want to get the latest updates from facebook, so your smart phone (from a network in Burundi) shoots a request to the facebook servers in Menlo Park. that server reconciles your request and sends back 5 epic selfies from your dearest friends. in our universe, this takes time. maybe not a whole lot according to you (a second perhaps) but for that mini super-computer you hold in your hand, that’s 1000000 microseconds. that’s a long time that you’re asking it to twiddle its thumbs (given that it usually processes stuff in a couple of microseconds). what’s it supposed to do until it hears back from the facebook servers? after it’s done showing you the updates for your first screen, when would it know to trigger another update? what if the data that came back from the servers indicated that you need some more information? what if the third request in that chain failed for some reason? welcome to the world of asynchronous programming. Rx (or FRP as it is mistakingly assumed to be synonymous with) was built to deal with a lot of this pain.

a natural question is: don’t app developers do this anyway today? yes we do. but it’s painful and error prone. it also results in bad UX (spinners, progress indicators, alert dialogs for failed network issues and other technical problems that users really shouldn’t have to deal with).

you can get by very far without having to deal with many of the aforementioned problems (like keeping all your information saved on your device instead of say a big server machine located elsewhere that would require a network connection) but as more services move to storing data online, streaming data from servers, sharing data across multiple platforms and devices, dealing with the complexity of asynchronous programming has become common place.

how is it then, that every developer you know, isn’t already talking about this Rx stuff? the reception to Rx (see what i did there?) in the developer community has been …warm. the few serious developers who have started to use it, swear by it and say it’s the most amazing thing ever. the ones that are yet to go through this feat, currently see it as another fancy hipster developer pattern. it also has a very steep learning curve. this doesn’t help its cause (did i mention it happens to be a pattern pioneered by Microsoft?).

but make no mistake, Rx is coming. eventually everyone is going to suck it up and use it in its current form, or the dev community will fashion a variant that’s easier for newer developers to pick up.

RxJava Tip for the Day - Share, Publish, Refcount and All That Jazz

Wed, 21 Jan 2015 07:00:00 GMT

Ok, so in my previous post I innocuously introduced the .share() operator.

Observable<Object> tapEventEmitter = _rxBus.toObserverable().share();

The .share() operator is basically just a wrapper to the chained call .publish().refcount().

You’ll find the chained combo .publish().refcount() used in quite a few Rx examples on the web. It allows you to “share” the emission of the stream. Considering how powerpacked and frequently used this combo is, RxJava basically introduced the friendlier more useful operator share(). This mechanism is sometimes referred to as “multicasting”.

Let’s dig into some of the basics first:

“ConnectedObservable” - This is a kind of observable which doesn’t emit items even if subscribed to. It only starts emitting items after its .connect() method is called.

It is for this reason that a connected obesrvable is also considered “cold” or “inactive” before the connect method is invoked.

.publish()- This method allows us to change an ordinary observable into a “ConnectedObservable”. Simply call this method on an ordinary observable and it becomes a connected one.

We now know what 1/2 of the operator share does. Now why would you ever use a Connected Observable? The docs say:

In this way you can wait for all intended Subscribers to subscribe to the Observable before the Observable begins emitting items.

This essentially means that a regular usecase for publish would involve more than one subscriber. When you have more than one subscriber, it can get tricky to handle each of the subscriptions and dispose them off correctly. To make this process easier, Rx introduced this magical operator called refcount():

refcount() - This operator keeps track of how many subscribers are subscribed to the resulting Observable and refrains from disconnecting from the source ConnectedObservable until all such Observables are unsubscribed.

It essentially maintains a reference counter in the background and accordingly takes the correct action when a subscription needs to be unsubscribed or disposed off. This is the second 1/2 of the operator share. You are now armed with knowledge of what each of those terms mean.

Let’s look at the example from debouncedBuffer again and see how share was used there:

Observable<Object> tapEventEmitter = _rxBus.toObserverable().share();
// which is really the same as:
Observable<Object> tapEventEmitter = _rxBus.toObserverable().publish().refcount();

We now have a “shareable” observable called “tapEventEmitter” and because it’s sharable and still not yet ’live’ (publish from the share call changes it to a ConnectedObservable), we can use it to compose our niftier Observables and rest assured that we always have a reference to the original observable (the original observable being _rxBus.toObserverable() in this case).

Observable<Object> tapEventEmitter = _rxBus.toObserverable().share();
Observable<Object> debouncedEventEmitter = tapEventEmitter.debounce(1, TimeUnit.SECONDS);
tapEventEmitter.buffer(debouncedEventEmitter)

All this sounds good. There is however a possible race condition with this implementation (which Ben pointed out through a comment on this gist). The race condition occurs because there are two subscribers here (debounce and buffer) and they may come and go at different points. Remember that the RxBus is backed by a hot/live Subject which is constantly emitting items. By using the share operator we guarantee a reference to the same source, but NOT that they’ll receive the exact same items if the subscribers enter at different points of time. Ben explains this well:

The race condition is when the two consumers subscribe. Often on a hot stream it doesn’t matter when subscribers come and go, and refCount is perfect for that. The race condition refCount protects against is having only 1 active subscription upstream. However, if 2 Subscribers subscribe to a refcounted stream that emits 1, 2, 3, 4, 5, the first may get 1, 2, 3, 4, 5 and the second may get 2, 3, 4, 5.

To ensure all subscribers start at exactly the same time and get the exact same values, refCount can not be used. Either ConnectableObservable with a manual, imperative invocation of connect needs to be done, or the variant of publish(function) which connects everything within the function before connecting the upstream.

In our usage it’s almost immediate so it probably wouldn’t matter a whole lot but considering the use case, it’s ideal to have the exact same events emitted for the debouncedBuffer usecase. I added a third improved implementation to handle this race condition:

// don't start emitting items just yet by turning the observable to a connected one
ConnectableObservable<Object> tapEventEmitter = _rxBus.toObserverable().publish();

tapEventEmitter.publish((Func1) (stream) -> {

 // inside `publish`, "stream" is truly multicasted

 // applying the same technique for getting a debounced buffer sequence
 return stream.buffer(stream.debounce(1, TimeUnit.SECONDS));

}).subscribe((Action1) (taps) {
 _showTapCount(taps.size());
});

// start listening to events now
tapEventEmitter.connect();

Interested in an Android Developer Podcast?

Sun, 11 Jan 2015 07:00:00 GMT

i listen to a tonne of podcasts. i find activities such as doing my laundry, driving back home from work, doing the dishes … all delightful because it gives me a chance to strap on some headphones and listen to a bunch of podcasts. in the time that i run those dreadfully boring chores i’ve found myself learning so much about technology and good software development.

as i was driving back home today i was listening to an episode of Ruby Rogues and thought to myself:

why aren’t there more podcasts like this for Android?

the iOS folks have some amazing podcasts focused for the developer audience. heck, i listen to two of them and i’m not an iOS developer (granted they’re slightly more generic).

as an android developer there is exactly one show today that is focused on android development called “Android Developers Backstage”. it’s hosted by google engineers Chet Hasse and Tor Norbye (both of them work directly with Android). they’re funny and the podcast is amazing! if you’re an android developer you should absolutely be listening to it.

my only gripe with the show is that they live in their beautiful google bubble. on a recent show they interviewed Jake Wharton (a.k.a superman android dev) and i found it really interesting that they had genuinely not heard of some of the libraries that Jake works on (like Picasso, Retrofit and ButterKnife). i guess it makes sense though: they’re google engineers working on android directly. if they really needed something, they would have had it baked in.

but i don’t think i’m alone when i say that for some of us android developers, those libraries are indispensable for pushing out quality android apps quickly.

i want to hear more about such libraries.
what are some of your learnings as an android developer that you would love to share?
what are some tricks and techniques you have in your utility belt?
can you tell me about some android apps that are top notch and push the boundary in terms of quality and design?
- what are some interesting things they do?
- how do they do it?

i’ve been toying with the idea of starting an android podcast with a developer audience in mind. i’ve done a decent amount of sound-engineering in my day so the audio editing part isn’t daunting. it’s the whole planning around the actual podcast that sort of worries me. i’ll have to find developers to interview, do my homework before interviewing them, setup the environment and whole stack for the podcast, find a place to host the podcast and a whole bunch of other things that i can’t think of right now; all in addition to my regular job (which i also absolutely love).

it’s clearly a lot of work and will require a solid chunk of my free time. i don’t intend to make any money out of it so i’ll probably have to bear the costs myself intially (i really don’t mind that part at all though cause i’ll definitely be learning along the way). the effort only makes sense though if a larger group of people can benefit from this.

i’m trying to gauge interest and will explore the specifics only if people seem interested. so i ask you: would you genuinely be interested in a developer-focused android podcast? (let me know by answering this poll).

[update: many people were interseted, so i teamed up with the amazing Donn Felker to start “Fragmented - An Android developer podcast”. Let us know what you think.]

DebouncedBuffer With RxJava

Mon, 05 Jan 2015 07:00:00 GMT

This is a bonus RxJava post that I landed up writing along with my previous post on creating an event bus with RxJava. If you went through the code in the actual repo you would have noticed more than one version of the bottom fragment in the RxBus demo.

Originally I envisioned the RxBus example being a tad bit fanicer however as I coded up the example, I realized that too many concepts were getting conflated. The ridiculous simplicity of the RxBus implementation was lost. So I dumbed down the original example but left in the original code for the Rx padawans.

Original example:

Fancier one:

The fanciness is basically in the numbers being accumulated and shown in “chunks”. In my head I thought I could simply use the debounce operator (like the debounce search example) and be on my jolly way, but this was not to be… From the always helpful RxJava wiki:

debounce - only emit an item from the source Observable after a particular timespan has passed without the Observable emitting any other items

I wanted the “after a particular timespan has passed without the Observable emitting any other items” part of debounce, but I needed the whole list of emitted items (not just a single item). Thebufferoperator also seemed promising:

buffer - periodically gather items from an Observable into bundles and emit these bundles rather than emitting the items one at a time

“emit as bundles”, perfect! uh… not exactly, it says “periodically” and that literally means periodically. So EVERY X seconds/minutes it will emit a list of objects regardless of whether there were any taps/events. This would mean a bunch of empty lists would periodically be emitted when no taps were registered. I could get the example working if I tweaked the time component for buffer just enough and filter out the empty results, but it was a hack and not the way of the Rx.

What I really needed was a selective combination of debounce and buffer - a “debouncedBuffer” operator. Such an operator doesn’t exist but you could achieve something similar by calling .buffer() with a special “boundry observable” parameter, as Jedi master Ben Christensen points out in this Stack Overflow post (the Rx is strong with this one).

Essentially, if you pass an observable as a parameter to buffer, every time this observable emits an item, buffer will take the source observable and emit a list of items from the source observable (instead of the items emitted by the boundary observable).

<Source Observable For Actual Events>.buffer(<Boundary Observable that only tells "when" to take items from the Source>)

So what we’re going to do is use a “debouncedEventEmitter” as our boundary observable. The “debouncedEventEmitter” will basically emit a single item-which we really don’t care about-only after a certain time has elapsed from the emission of the first item.

Observable<Object> debouncedEventEmitter = tapEventEmitter.debounce(1, TimeUnit.SECONDS);

We now buffer our source observable again to give us a list of items (vs a single item) everytime the debouncedEventEmitter emits a single item.

Observable<List<Object>> debouncedBufferEmitter = tapEventEmitter.buffer(debouncedEventEmitter);

Altogether now:

Observable<Object> tapEventEmitter = _rxBus.toObserverable().share();
Observable<Object> debouncedEventEmitter = tapEventEmitter.debounce(1, TimeUnit.SECONDS);
Observable<List<Object>> debouncedBufferEmitter = tapEventEmitter.buffer(debouncedEventEmitter);

debouncedBufferEmitter.buffer(debouncedEventEmitter)
 .observeOn(AndroidSchedulers.mainThread())
 .subscribe(new Action1<List<Object>>() {
 @Override
 public void call(List<Object> taps) {
 _showTapCount(taps.size());
 }
 });

Notice the .share() operator? In my next post, I’ll go into the details of that operator along with .publish() and refcount().

[UPDATE: Ben pointed me to a niftier implementation of debounced buffer. I’ve added a third variant of the Bottom fragment that uses this approach. A subsequent post will go into the details.]

Follow discussion on Reddit.

New Year - 2015

Wed, 31 Dec 2014 07:00:00 GMT

i love the holidays. i especially love the new year’s though cause it’s an acceptable time to hit that big-nice-red reset button.

stuff I wanted to get done in 2013/2014 #

get back in shape (significant progress on this front)
get more sleep (been getting atleast 6 hours, which is good, now to bump it to 7)
get really good at Rails (switched gears and became an android developer. i like to think i’m a pretty decent one too)
get a job after my masters

stuff done in 2013/2014: #

joined wedding party #

i joined as a full-time rails dev but landed up becoming a full-time android dev for them. we have some of the craziest, smartest and fun loving peeps in the industry. i’m absolutely loving my time here.

released a lot of new android stuff #

besides releasing a tonne of cool features for wedding party, i managed to ship two big android projects: Android-floatlabel and learning Android-RxJava, both of which have been received pretty well by the open source community

new blog design #

i changed this blog’s design (again) to match my homepage. i’m really happy with this iteration of the design. i think it has just the right balance of minimalism, simplicity and style

getting fit(ter) #

i’m a regular again at the gym. i was probably at my fittest around 2007 and i’ve still got a long way to go, before i get to that shape again. but i’m getting there.

overall, 2013/2014 went by in a jiffy and was a total win!

stuff I want to do in 2015: #

start playing the piano #

this is an area i’ve totally fallen off the bandwagon. i don’t do enough sound-engineering or music anymore. i’m thinking of getting a piano/synthesizer and just start jamming again.

travel to atleast two new places that i’ve never been #

a bunch of my close friends and i love traveling and we hit a high in 2013 (just after graduation). it was amazing until 2014, where i’ve hit a complete travel slump.

release an independent (android) app #

i’ve always wanted to build the Day One app for android (given that they are probably never going to¹). there are very few high-quality journaling apps on android. i think this is a personal itch that i’m going to try to scratch.

here’s to a happy adventurous and exciting 2015!

3 years later, Day One released an Android app https://play.google.com/store/apps/details?id=com.dayoneapp.dayone ↩︎

Implementing an Event Bus With RxJava - RxBus

Wed, 24 Dec 2014 07:00:00 GMT

This post has three parts:

quick primer on what an event bus is
implementing the event bus with RxJava
parting thoughts on this approach

“RxBus” is not going to be a library. Implementing an event bus with RxJava is so ridiculously easy that it doesn’t warrant the bloat of an independent library.

Part 1: What is an event bus? #

Let’s talk about two concepts that seem similar: the Observer pattern and the Pub-sub pattern.

Observer pattern #

This is a pattern of development in which your class or primary object (known as the Observable) notifies other interested classes or objects (known as Observers) with relevant information (events).

Pub-sub pattern #

The objective of the pub-sub pattern is exactly the same as the Observer pattern viz. you want some other class to know of certain events taking place.

There’s an important semantic difference between the Observer and Pub-sub patterns though: in the pub-sub pattern the focus is on “broadcasting” messages outside. The Observable here doesn’t want to know who the events are going out to, just that they’ve gone out. In other words the Observable (a.k.a Publisher) doesn’t want to know who the Observers (a.k.a Subscribers) are.

Why the anonymity? #

It allows for this thing called “decoupling”, which is a good word in computer programming. You want to keep coupling as low as possible in your design.

Typically, you would expect the publisher to have direct knowledge of each of the many subscribers that it needs to notify, so it can go about notifying each of them, once the “event” or message is ready. But with an event bus, the publisher is relieved of such duties and this independence helps, because the publisher and subscriber need not have logic coded in them that establish the dependencies between the two.

In other words “consciously decouple” your code whenever you can*.

How the anonymity? #

Ok, so a natural question with the pub-sub pattern is: how do you actually achieve that anonymity between publisher and subscriber? An easy way is to just get hold of a middleman and let that middleman take care of all the communication. An event bus is one such middleman.

That’s it. An event bus is as simple as that.

Two event bus libraries that are commonly used in Android are Otto and Green Robot’s EventBus. There are plenty of posts online that explain how to implement them in your app.

Part 2: Implementing the event bus with RxJava #

I’ve been posting real world examples of using RxJava for Android in this github repo, so i’ll stick to posting the complete implementation in that repo. Here are the interesting parts of the implementation:

// this is the middleman object
public class RxBus {

 private final Subject<Object, Object> _bus = new SerializedSubject<>(PublishSubject.create());

 public void send(Object o) {
 _bus.onNext(o);
 }

 public Observable<Object> toObserverable() {
 return _bus;
 }
}

That’s it. You now have an event bus ready to use.

Here’s how you post an event to the bus:

@OnClick(R.id.btn_demo_rxbus_tap)
public void onTapButtonClicked() {

 _rxBus.send(new TapEvent());
}

and here’s how you listen to those events from other fragments/services etc.

// note that it is important to subscribe to the exact same _rxBus instance that was used to post the events
_rxBus.toObserverable()
 .subscribe(new Action1<Object>() {
 @Override
 public void call(Object event) {

 if(event instanceof TapEvent) {
 _showTapText();

 }else if(event instanceof SomeOtherEvent) {
 _doSomethingElse();
 }
 }
 });

In the example we post events from the top fragment (green part) and listen in (through the bus) from the bottom fragment (blue part).

Part 3 - parting thoughts #

Dead events #

There are some cases where it’s useful to know if there are any observers currently listening to the bus. For e.g. if you use an event bus to handle your GCM push notifications) and don’t want to send a push notification if the app is in the foreground, then it’s important to listen to “dead events”.

For e.g in a recent release for Wedding Party, we added “Messaging” to our app. If the user has the app open (thus having atleast 1 or more listeners to the bus) we don’t send push notifications but if they have the app in the background, then we send a push notification to let them know of chat messages. After an event is posted to the event bus, if no subscriber is listening, a dead event is returned. If we get back a dead event a push notification is shot out.

How would you do this with the RxBus implementation?

It’s pretty easy actually. Subjects have this helpful method on them hasObservers() that would tell us exactly just that. This was added in the 1.x release for RxJava, so you have to be on the latest version of RxAndroid (0.23.0 as of this writing) in order to see this method.

So should I use RxBus instead of Otto/EventBus? #

If you simply want to use an event bus with your Android app, you’re probably better off with a library like Otto (which i highly recommend) or EventBus. Otto has a clean api driven by annotations and is probably far more simpler to use.

If you’re familiar with Rx, already use RxJava in your app and want to get rid of an additional library, definitely try out the RxBus approach!

Did i miss anything? Do you have more suggestions on improving the RxBus implementation? Follow the discussion on Reddit, Google Plus, feel free to tweet your comments @kaushikgopal or just raise an issue in the repo.

Pssst. there are two bonus posts that delve a little more into the RxJava trickery I used to make the RxBus example a tad bit fancier. Stay tuned.

Learning RxJava With Android by Example

Mon, 15 Sep 2014 07:00:00 GMT

I’ve read and watched a lot on Rx. Most examples either use the J8 lambda notations/Scala/Groovy or some other awesome language that us Android developers are constantly envious of.

Unfortunately I could never find real-world simple examples in Android that could show me how to use RxJava. To scratch that itch, I created a github repo with a couple of nifty examples using RxJava. You can build the apk and run the app to see different working examples.

If you don’t know anything about RxJava, I would strongly recommend you first get acquainted with RxJava and understand the terminology really well. It has a pretty steep learning curve, so just throw yourself at it, until you start to understand the motivation behind its usage. Here are some resources to get you started:

Rx in 15 minutes - by Erik Meijer creator of the Reactive extensions. RxJava is essentially a Java port of Reactive extensions.
Rx Workshop - Channel9 Microsoft’s video channel on RX. Just peruse through the first few videos. You’ll pick a lot of useful info.
Watch this excellent talk by Ben Christensen - one of the creators of RxJava.
An interesting writeup I found somewhere in the interwebs.
Dan Lew started a nice primer series today, on RxJava for Android. Definitely follow his 3 part series.
Snoop around the RxJava wiki. Look at those marble diagrams specifically. You will have to come back to them repeatedly to get a good understanding of the operators.

Once you have a decent understanding of when to use RxJava and the different terms used, come back to the learning RxJava by example repo and you’ll find the examples a godsend. If not, contribute with the examples you think that will be.

Follow the discussion on Reddit or Google Plus.

Primer on Threading and Handlers in Android

Fri, 20 Jun 2014 07:00:00 GMT

Mobile devices are getting pretty fast, but they aren’t infinitely fast yet. If you want your app to be able to do any serious work without affecting the user experience by locking up the interface, you’ll have to resort to running things in parallel. On Android, this is done with “threads”.

Grab yourself a cup of coffee and read this post line by line. I’ll introduce you to the concept of threads, talk about how Java uses threads and explain how “Handlers” in Android help with threading.

Whenever you want to do asynchronous/parallel processing, you do it with threads.

Threads you say ? #

A thread or “thread of execution” is basically a sequence of instructions (of program code), that you send to your operating system.

Image Courtesy: Wikipedia.

“Typically” your CPU can process one thread, per core, at any time. So a multi-core processor (most Android devices today) by definition can handle multiple-threads of execution (which is to say, they can do multiple things at once).

Truth to multi-core processing and single-core multitasking #

I say “typically” because the corollary to the above statement is not necessarily true. Single-core devices can “simulate” multithreading using multitasking.

Every “task” that’s run on a thread can be broken down into multiple instructions. These instructions don’t have to happen all at once. So a single-core device can switch to a thread “1” finish an instruction 1A, then switch to thread “2” finish an instruction 2A, switch back to 1 finish 1B, 1C, 1D, switch to 2, finish 2B, 2C and so on…

This switching between threads happens so fast that it appears, even on a single-core device, that all the threads are making progress at exactly the same time. It’s an illusion caused by speed, much like Agent Brown appearing to have multiple heads and arms.

Now on to some code.

Threads in core Java #

In Java, when you want to do parallel processing, you execute your code in a Runnable either by extending the Thread class or implementing the Runnable interface

// Version 1
public class IAmAThread extends Thread {
 public IAmAThread() {
 super("IAmAThread");
 }

 @Override
 public void run() {
 // your code (sequence of instructions)
 }
}
// to execute this sequence of instructions in a separate thread.
new IAmAThread().start();

// Version 2
public class IAmARunnable implements Runnable {
 @Override
 public void run() {
 // your code (sequence of instructions)
 }
}
// to execute this sequence of instructions in a separate thread.
IAmARunnable myRunnable = new IAmARunnable();
new Thread(myRunnable).start();

Both of these approaches are fundamentally very similar. Version 1 involves creating an actual thread while Version 2 involves creating a runnable, which in-turn has to be called by a Thread.

Version 2, is generally the preferred approach (and is a much larger subject of discussion, beyond the scope of this post).

Threads in Android #

Whenever your app starts up in Android, all components are run on a single primary thread (by default) called the “main” thread. The primary role of this thread though, is to handle the user interface and dispatch events to the appropriate widgets/views. For this reason, the main thread is also referred to as the “UI” thread.

If you have a long running operation on your UI thread, the user interface is going to get locked up until this operation is complete. This is bad for your users! That’s why it’s important to understand how threads work in Android specifically, so you can offload some of the work to parallel threads. Android is pretty merciless about keeping things off the UI thread. If you have a long running operation on the UI thread you’re probably going to run into the infamous ANR that will conveniently allow your users to kill your app!

Now Android is all Java, so it supports the usage of the core Java Thread class to perform asynchronous processing. So you could use code very similar to the one shown in the “Threads in Java” section above, and start using threads in Android right away. But that can be a tad bit difficult.

Why is using core Java threads in Android difficult? #

Well, parallel processing is not as easy as it sounds because you have to maintain “concurrency” across the multiple threads. In the words of the very wise Tim Bray:

ordinary humans can’t do concurrency at scale (or really at all) …

Specifically for Android, the following is additionally cumbersome:

Synchronization with the UI thread is a major PITA (you typically want to do this, when you want to send progress updates to the UI, for your background operation)
Things change even more weirdly with orientation/configuration changes because an orientation change causes an activity to be recreated (so background threads may be trying to change the state of a destroyed activity, and if the background thread isn’t on the UI thread, well that complicates things even more because of point 1).
There’s also no default handling for thread pooling
Canceling thread actions requires custom code

Arr…ok, so how DO we do parallel processing in Android? #

Some (in)famous Android constructs you’ve probably come across:

Handler

This is the subject of our detailed discussion today
AsyncTask

Using AsyncTasks are truly the simplest way to handle threads in Android. That being said, they are also the most error prone.
IntentService

It requires more boiler plate code, but this is generally my preferred mechanism for off-loading long-running operations to the background. Armed with an EventBus like Otto, IntentServices become amazingly easy to implement.
Loader

These are geared more towards performing asynchronous tasks, that have to deal with data from databases or content providers.
Service (honorable mention)

If you’ve worked with Services closely, you should know that this is actually a little misleading. A common misconception is that Services run on the background thread. Nope! they “appear” to run in the background because they don’t have a UI component associated with them. They actually run on the UI thread (by default)…. So they run on the UI thread by default, even though they don’t have a UI component?

Naming has never been Google's strong suit. ActivityInstrumentationTestCase ... wait for it .... 2! Spinner anyone?

If you want your service to run on a background thread, you’ll have to manually spawn another thread and execute your operations in that thread (similar to an approach discussed above). Really you should just use IntentServices but that is a subject for another post.

Android Handlers: #

From the not-so-dummy-friendly Android developer documentation for Handlers:

A Handler allows you to send and process Message and Runnable objects associated with a thread’s MessageQueue. Each Handler instance is associated with a single thread and that thread’s message queue. When you create a new Handler, it is bound to the thread/message queue of the thread that is creating it – from that point on, it will deliver messages and runnables to that message queue and execute them as they come out of the message queue.

To understand that better, you probably need to know what Message Queues are.

Message Queues: #

Threads basically have something called a “Message Queue”. These message queues allow communication between threads and is a sort of pattern, where control (or content) is passed between the threads.

It’s actually a wonderful name, because it’s exactly just that: a queue of messages or sequence of instructions, for the thread, to perform one by one. This additionally allows us to do two more cool things:

“schedule” Messages and Runnables to be executed at some point in the future
enqueue an action to be performed on a different thread other than your own

Note: when I mention ‘message’ from here onwards, it’s the same as a runnable object or a sequence of instructions.

So going back to Handlers in Android…. if you read and pause at every single line, the docs make much more sense now:

A Handler allows you to send and process Message and Runnable objects associated with a thread’s MessageQueue.

So, a handler allows you to send messages to a thread’s message queue. check ✔ !

Each Handler instance is associated with a single thread and that thread’s message queue.

A handler can only be associated with a single thread. ✔

When you create a new Handler, it is bound to the thread / message queue of the thread that is creating it

So, which thread is a handler associated with? The thread that creates it. ✔

– from that point on, it will deliver messages and runnables to that message queue and execute them as they come out of the message queue.

Yeah yeah we already know that. Moving on…

Tip: Here’s something you probably didn’t know : in Android, every thread is associated with an instance of a Handler class, and it allows the thread to run along with other threads and communicate with them through messages.

Another Tip (if you’ve dealt with the more common AsyncTasks): AsyncTasks use Handlers but don’t run in the UI thread. They provide a channel to talk back to the UI, using the postExecute method.

This is all cool yo, so how do I create them Handlers? #

Two ways:

using the default constructor: new Handler()
using a parameterized constructor that takes a runnable object or callback object

What useful methods does the Handler API give me? #

Remember:

Handlers simply send messages or “posts” to the message queues.
They are convenience methods that help syncing back with the UI thread.

If you look at the API for Handlers now, the main methods provided make sense:

post
postDelayed
postAtTime

Code samples: #

The examples below are rudimentary, what you actually want to be closely following are the comments.

Example 1: using “post” method of the Handler #

public class TestActivity extends Activity {

 // ...
 // all standard stuff

 @Override
 public void onCreate(Bundle savedInstanceState) {

 // ...
 // all standard stuff

 // we're creating a new handler here
 // and we're in the UI Thread (default)
 // so this Handler is associated with the UI thread
 Handler mHandler = new Handler();

 // I want to start doing something really long
 // which means I should run the fella in another thread.
 // I do that by sending a message - in the form of another runnable object

 // But first, I'm going to create a Runnable object or a message for this
 Runnable mRunnableOnSeparateThread = new Runnable() {
 @Override
 public void run () {

 // do some long operation
 longOperation();

 // After mRunnableOnSeparateThread is done with it's job,
 // I need to tell the user that i'm done
 // which means I need to send a message back to the UI thread

 // who do we know that's associated with the UI thread?
 mHandler.post(new Runnable(){
 @Override
 public void run(){
 // do some UI related thing
 // like update a progress bar or TextView
 // ....
 }
 });


 }
 };

 // Cool but I've not executed the mRunnableOnSeparateThread yet
 // I've only defined the message to be sent
 // When I execute it though, I want it to be in a different thread
 // that was the whole point.

 new Thread(mRunnableOnSeparateThread).start();
 }

 }

If I didn’t have a handler object, posting back to the UI thread would have been pretty tricky.

Example 2: using postDelayed #

In a recent feature for Wedding Party, I had to emulate the auto-complete functionality with an EditText. Every change in text triggered an API call to retrieve some data from our servers.

I wanted to reduce the number of API calls shot out by the app, so I used the Handler’s postDelayed method to achieve this.

This example doesn’t focus on parallel processing, but rather the ability for the Handler to function as a Message Queue and schedule messages to be executed at some later point in the future

// the below code is inside a TextWatcher
// which implements the onTextChanged method
// I've simplified it to only highlight the parts we're
// interested in

private long lastChange = 0;

@Override
public void onTextChanged(final CharSequence chars,
 int start, int before, int count) {

 // The handler is spawned from the UI thread
 new Handler().postDelayed(

 // argument 1 for postDelated = message to be sent
 new Runnable() {
 @Override
 public void run() {

 if (noChangeInText_InTheLastFewSeconds()) {
 searchAndPopulateListView(chars.toString()); // logic
 }
 }
 },

 // argument 2 for postDelated = delay before execution
 300);

 lastChange = System.currentTimeMillis();
}


private boolean noChangeInText_InTheLastFewSeconds() {
 return System.currentTimeMillis() - lastChange >= 300
}

I leave the “postAtTime” as an exercise for the reader. Got a grip on Handlers? Happy threading!

Follow the discussion on Hacker News or Reddit or Google Plus.

How I remembered Roshambo 2.0 (Rock Paper Scissors Lizard Spock)

Fri, 07 Jun 2013 07:00:00 GMT

The title was just to grab your attention. The tl;dr version of this post is: get good at story telling. It’ll help you with two things:

Becoming a better presenter.

Improving your memory.

I urge you though, to read this post in it’s entirety. You might some of the stories interesting:

Presentations are generally looked at with much anxiety and trepidation (within the tech community at least). There are two ways to combat this:

Practice like crazy (joining a group like Toastmasters helps)
Have something interesting to say.

Obviously, you have to do both to become a good presenter, but I want to focus more on the latter point. You know what most human beings find interesting? Stories! Even crappy ones. We’re wired from birth to like stories. If i heard two presentations, both of mediocre quality, i would definitely prefer the one that had a story to tell. I think stories make your presentations more personal and relatable. Heck, it doesn’t even have to be your own. People relate more easily to stories because they feel they can associate themselves with your pain/experience. A post on ninjasandrobots (how cool is that domain name!) talks about leading with pain. It boils down to telling a story.

Using stories to captivate #

If you tell a great story, then it sticks. I have a professor here in CMU, that uses this tactic and boy is it mesmorizing. It totally helps that he’s got the experience (MIT, previous CTO of the research dev labs of a tech giant that makes phones etc. Hint: if you’ve used a mobile phone in the past 5-8 years, you have definitely used his ex-company’s phones). We were working on a project with him on collecting sensor data. He gave us an example of how data is always valuable. The only problem, is that the value of that data is realized at a different time.

He gave us this example: the fire department had a service where people could call in emergencies, along with pictures of the site. You can’t really control the inflow of data with the public, so you had people sending in pictures of dead cats around the city. Yes this was tragic, but there isn’t really much a fire department can do now with this info right? Yes and No. A few weeks later, there was an anthrax scare in the city and it was extremely important for the HAZMAT department to find the source of the outbreak. You know which creatures are most sensitive to anthrax? cats. Suddenly those dead cat pictures became tremendously useful, in tackling a major disease outbreak. That story was one of the many, that our professor told and mesmorized us into working on his project (note to self: write more posts about those stories).

Improving your memory #

I gave this goofy presentation on Roshambo 2.0 (the lizard-spock variant popularized by The Big Bang theory) once and obviously the presentation required that I get the sequence right. It’s pretty tricky, even Sheldon got it wrong… multiple times. This was sort of a lightening talk I had to give at school and it was a casual setting, which meant the audience were my friends and they would totally rip me apart if I got it wrong. I thankfully got it right in one shot :D and it didn’t really matter if my delivery style, poise, body language etc. was great. My presentation was a success mostly because I got it right in one swoop. People came up to me and asked if i had a photographic memory? It’s actually quite the opposite. I have a horrible memory. Close friends know that I have the admirable feat of genuinely forgetting my own birthday one year (if my dear folks and brother hadn’t reminded me at 12:00am, I would have probably gone through the whole day not realizing I clocked another year). Digression aside, the way I managed to get Roshambo 2.0 right was that I weaved a crazy story in my head to follow the sequence. If you aren’t interested in the story that I came up with, skip the next paragraph (why did you start reading this post though?).

I imagined myself starting with a pair of scissors cutting paper.I look at the paper and then realized i had used that to cover a rock once, the same rock that I used to chuck at a lizard. That pesky lizard was a blue necked one, similar to the one that poisons Spock in a fictional Star Trek episode. In that fictional episode, Spock was so mad with Kirk’s tomfoolery, that he chucks a scissor at Kirk, but misses and lands up breaking it. Kirk to make up for his actions, decides to kill/decaptiate the same blue necked Lizard(that poisoned Spock), with a scissor. During the battle, the Lizard needed nutrition, so it decides to eat paper. In a crazy twist of serendipitous circumstances, the paper consumed was the same one that Kirk initially wrote to disprove Spock, in an experiment Spock was doing, to vaporize Rock. Oh and Rock beats Scissors. The key here is to make your own story cause this might make no sense at all, but in my head I can see the whole story playing out crystal clear.

It’s magical how stories can greatly help improve memory. I’m pretty sure there are scientific studies conducted by people far more experienced and knowledgeable than me, proving this point but Roshambo 2.0 was proof enough for me.

If you’re not as excited as you were led to believe reading this post, I leave you with links to presentations given by the masters. You cannot not be impressed after this.

Sir Ken Robinson #

Doesn’t use slides, has a great sense of humor, comes up on stage and just tells his story (with an impressive British accent):

Schools kill creativity - 2006 : His legendary TED talk.
Bring on the learning revolution - 2010 : His follow up talk on TED.
How to escape education’s death valley - 2012

Steve Jobs #

You know he was going to be mentioned somehwere in the post…

Randy Pausch #

Besides the amazing stories he tells, his story alone is impressive and moving enough to captivate the audience.

For the techies: #

Tech presentations can also be made interesting. Here are some random examples that are favorites of mine:

Rock on!

A developer's life

Sat, 06 Apr 2013 07:00:00 GMT

This is by far the funniest stuff I’ve read this year. Never fails to crack me up…

We humans are capable of greatness

Sat, 06 Apr 2013 07:00:00 GMT

For All Our Failings, Despite Our Limitations and Fallibilities, We Humans Are Capable of Greatness…

Carl Sagan

Comfort in Coding

Sat, 19 Jan 2013 07:00:00 GMT

There’s something innately comforting about coding. The solution is not known but the variables are fixed. The ambiguities are minimal and the choices are simple. The rule book is adhered to. You mess up and you get bugs, you get it right and a solution is reached. If the solution is good, it becomes poetry.

I realize why management have it tough now. The jargon, documentation, definitions, ambiguity and interpretations that they have to deal with are such a mess.

I write this as I power through a course where in order to take a break from it all, I resort to coding.

New Year - 2013

Tue, 01 Jan 2013 07:00:00 GMT

My last post didn’t exactly end in an optimistic note. Let’s correct that:

Wishing you all a happy, joyous and peaceful 2013 folks!

The Mayans predicted that the world-as we know it-would end but we’re still here standing (cheers to that).

The new year is a time to reflect and wipe the slate clean. People advice against making new year resolutions but I do them anyway. I like taking a look back at my previous resolutions. Helps me get a better understanding of my achievement or lack thereof.

Stuff done in 2012: #

Got in to the masters program at Carnegie Mellon.
Learned Ruby(& Rails) and built a couple of sites with it. Long way to go but loving it.
Screwed around with some small github projects.
Moved this blog along with all my old wordpress posts to Octopress.

Not too bad.

Stuff I couldn’t get done in 2012: #

Get back in shape (This one’s been there since my 2009 new year resolution list. But I have a good feeling 2013 will see this task done).
Sound engineering (I did do a bunch of editing here and there for some folks, but this was stuff I had down and didn’t particularly learn anything new in the process).

Stuff I want to do in 2013 #

Get back in shape (In addition to hitting the gym planning to eat better).
Get more sleep (I have this bad feeling 2012 zapped some of my brain cells).
Get really good at Rails (looking at running through the Destroy all Software and Railcast screencasts).
Get a job after my masters, preferably doing something I love.

Music used on the new "All on iPad" commercial

Thu, 09 Aug 2012 07:00:00 GMT

Apple released a new iPad ad during the Olympics. If you’re curious to know which song they used, it’s the song “Driving” by Stolen Jars.

Two other songs i picked from their previous ads:

Goldengrove & The Kiss.

if Pixar did Justice League

Sun, 29 Jul 2012 07:00:00 GMT

i would give my savings away for something like this.

Daniel Araya

Learning and Looking Foolish

Sun, 17 Jun 2012 07:00:00 GMT

I’m willing to look foolish, if it means I’ll learn something.

This is the best piece of advice I’ve ever received, courtesy a chemistry professor back in my days of IIT. I did miserably in that course but I picked up this piece of advice that’s been a guiding beacon ever since.

on the new Twitter logo

Fri, 08 Jun 2012 07:00:00 GMT

Twitter’s got a new logo. It’s clean and simple. But here’s a more astute observation from underconsideration.com :

For the most part, all the news sources reporting on the revised bird have focused on its visual update, which I will get to soon, but the real story here is that Twitter has dropped its name from the logo. If you look at the opening image of this post, the change is quite drastic. And ballsy. Twitter has achieved in less than six years what Nike, Apple, and Target took decades to do: To be recognizable without a name, just an icon.

by way of the chairman

Stephen Fry - language

Sun, 20 May 2012 07:00:00 GMT

Hear this recitation by Stephen Fry ((this man could read the instruction manual of a tape recorder and i would still link to it and love it)), then think about what he says.

Hear it again, then meditate on what he says.

Earth - the pale blue dot

Sat, 19 May 2012 07:00:00 GMT

for all our failings, despite our limitations and fallibilities , we humans are capable of greatness…

from the book Pale Blue Dot: A Vision of the Human Future in Space by astronomer Carl Sagan

The Janitor from Columbia

Mon, 14 May 2012 07:00:00 GMT

Truly inspirational stuff. I see a Tom Hanks movie script already in the making.

Use paper towels more efficiently - shake and fold

Fri, 04 May 2012 07:00:00 GMT

I’m a little troubled that I love these kind of lifehack videos.

the first rule of Markdown

Tue, 24 Apr 2012 07:00:00 GMT

Frankly, I was surprised that Gruber mentioned Markdown previewing at all. If you’ve been around the Markdown community for any length of time, you know that the first rule of Markdown is: Gruber never talks about Markdown

footnote from the awesome drdrang

Learning is more important that Knowing

Wed, 18 Apr 2012 07:00:00 GMT

… You should mention what technologies you are using (because listing WCF or Java will save me the hassle of applying, and you the hassle of rejecting me), but don’t list specific tools, languages and frameworks as requirements.

Good developers who know Rails can learn Django or Node.

Going between Oracle, SQL Server, MySQL and Postgres is all pretty trivial.

… I remember being asked quite eagerly, during a pre-interview, if I knew a specific view engine (like erb, or haml…). Seriously, a view engine!?!? A shitty programmer can learn a new view engine in 10 minutes. Or a more common one that always gets to me is listing some specific version control software. Or a specific library that solves a trivial problem (I see this all the time from the .NET world with DI and mocking frameworks)

Good programmers not only learn, but they want to learn. They often know enough about a technology so that they have a good feel for what problems it might solve; and only invest time truly learning it when it’s needed.

do read the article in its entirety. it’s pretty short and pure gold.

Your Android phone is 15s incorrect ...

Thu, 29 Mar 2012 07:00:00 GMT

Dr.Neil Degrasse Tyson on the Verge:

.. the bulk of the Androids get their time from GPS satellites.. The time keeping bases for the GPS satellites was defined upto 1982 and since 1982, 15 seconds have been added to civil time and that 15s is not included in the Andorid time keeping settings (because their getting their time directly from GPS), whereas the iPhone compensates for this and puts the 15s backs in…

You should watch the whole episode, Dr Neil is one of the most entertaining astro physicists on the planet.

Good insight on interviewing programmers

Thu, 08 Mar 2012 07:00:00 GMT

If you’re in the business of hiring programmers, the article linked is a must read. It’s concise and a gold read. No excuse for not reading it.

Avoid nano-questions
A good engineer thinks abstractly in terms of designing and building systems, they think in terms of algorithms, components, and engineering design. They do not necessarily know all of the details of syntax of a given language, especially if they are used to a good IDE…
… it is more important that I be able to tell you when and where I should use inheritance, and when and where I should use polymorphism, than to be able to spit off the definition. ((bolded text my own))
Basically: Any question that takes 5 seconds to answer with Google is not a good question. My favorite phone interview question? “What’s your favorite language?” followed by “What are it’s weaknesses?”

Will it improve upon on the silence? - Sri Sathya Sai Baba

Tue, 10 Jan 2012 07:00:00 GMT

Before you speak, think:

Is it necessary?

Is it true?

Is it kind?

Will it hurt anyone?

Will it improve on the silence?

Sri Sathya Sai Baba

how Tommy Emmanuel mics his acoustic guitar

Sat, 07 Jan 2012 07:00:00 GMT

for his professional albums, he uses a combination of 4 mics as explained in this youtube video. the song he plays in the end is Mombasa, easily one of his best compositions.

on the move he records with an Apogee ONE as seen in this youtube video. for an on-the-move mic and sound capture device, the Apogee ONE is simply mind blowing.

Programmer Competency Matrix

Fri, 06 Jan 2012 07:00:00 GMT

definitely dated, but interesting yardsticks.

via Hacker News

Why it's important to know how to write for CS Majors

Tue, 03 Jan 2012 07:00:00 GMT

You’d be surprised how valuable the skill of eloquent communication is even in the field of IT. Keeping users apprised with your progress is perhaps the most important thing to do when working with clients. But keeping them apprised is tricky business and the ability to clearly put down in words,what to expect, is a basic necessity today.

Even if you have nothing to do with CS or computers, you should read the linked article. Fantastic advice.

Songs from TV

Sat, 31 Dec 2011 07:00:00 GMT

Proof that my TV watching addiction has not been in vain:

In the Waiting Line by Zero 7 (House S03e13)
Home by Zero 7
Grounds for Divorce by Elbow (House Season 6 premier)
I’m not Drowning by Steve Winwood (House s05e18)
Company by Philip Glass (House s05e23)
High School Composition (House s03e15 : the one with Dave Mathew) possibly originally by Jon Ehrlich
Pride by Syntax (Bones s01e16)
Babylon by David Carbonora (Mad Men s01e06)
Believe by The Bravery (Prison Break s04e07)
Perfect Day by The Constellations (Chuck s04e08)
Cobrastyle by Teddybears (Chuck s01e01)

What you need to know about memory and CPU

Tue, 20 Dec 2011 07:00:00 GMT

What you need to know about RAM, memory, CPU Processing and other important stuff that could tell you why your computer is slow.

Physical RAM/Memory #

RAM chips funcion quite literally like your Computer’s Memory. All the information that needs to be remembered when operating between different tasks (or even the same task) gets stored here. You know how people who have great memories can be awesome, that translates to the computer world as well, more memory = more awesome. So 8GB » 4GB » 2GB » 1GB » (this is 2011, don’t even consider anything less than 1GB).

Virtual RAM or Virtual Memory #

Just like how humans can’t store everything in their head, there are times when some of the stuff has to be written down or stored as reminders. When your computer’s physical RAM or memory is full, it begins to offload some of the information onto a special space carved out of your hard disk (your hard disk is like a big notebook, you’ve generally got plenty of space here). This carved out area is called a swapfile or Virtual Memory or VM. VM, is hard disk space that can be used as memory and VM size indicates the amount of disk space currently being used as memory.

Paging out/Thrashing: #

When you need to start writing everything onto your notebook, you’ve got a problem. You’re either not organized or you’re doing things too complex for your IQ to handle. In the computer world the process of writing stuff onto your virtual RAM is called Paging out or Thrashing. When you see too many page outs or thrasing cycles, you’ve got a problem because HDDs are much slower than RAM modules when calling back information (If you use solid state drives or SSDs, you’re going to see a marked performance difference. Even still, nothing like physical RAM). The number of gigabytes of information your operating system has moved between RAM and disk space is generally indicated by Page in/outs.

Page Out/Page Ins #

Page out is the movement of data from RAM to hard disk and Page in is the movement of data from hard disk to RAM. Ideally you shouldn’t have any page outs.

CPU Processing #

Physical RAM is the destination to store the temporary data, but the part instructing everyone around on which data to store and where, is the CPU. You can think of it as the actual brain. More GHz = bigger brain = more awesome. So a 2 GHz processor is generally more awesome than a 1.5 GHz processor.

CPU Processor usage #

You won’t generally find your CPU processor usage peaked (if you do, you’ve got a problem). It’s ok to have spikes in your processor usage. These are the times when your computer’s brain is doing some heavy lifting, telling eveyone where to go and what to do. But if you find your usage constantly high, 100% most of the time, there’s some ugly memory leak going on that needs to be taken care of.

GPU Video card memory #

For demanding games and other video graphics intensive processes, people generally have independent video cards that function like little CPUs themselves and have their own memory. The CPU part of a video card is called a GPU and the memory part is called -wait for it-memory. When doing heavy duty video editing, 3D graphics or games, you want a dedicated graphics card.

Real Memory #

The amount of real memory a program is using at that instant. This is real memory used from your memory chips on the RAM module.

Free Memory #

Good glorious free memory that is completely unused.

Wired Memory #

Also knows as Resident Memory, the memory is locked or reserved and cannot be shared with other processes. OS/System processes, drivers, kernel code etc. tend to use this memory.

Active Memory #

Memory actively being used. The Real Memory values mentioned earlier should sum up to this value.

Inactive Memory #

Memory that has been used to cache disk I/O. You can think of inactive memory like free memory that’s been reserved for a recently closed application, but will be used when ’true’ free memory has been exhausted. If you have 1 GB of memory (for the sake of making this discussion easier) on a freshly booted system, imagine the OS uses 300 MB and you open an app that uses 200 MB. You now have a total of 500 MB used, and 500 free. If you close that app that was using 200 MB, the memory is marked inactive and you’ll now have 300 used (OS), 200 inactive, and 500 free. If you open an app that requires 600 MB, it’ll use the free memory then pull from the inactive pool.

Used Memory #

Wired + Active + Inactive. Nothing useful here, move on.

Fonts used in new BBC TV series Sherlock

Mon, 19 Dec 2011 07:00:00 GMT

So my brother introduced me to this really awesome BBC TV Series: Sherlock. If you’re a type nerd or design enthusiast, the very first thing you would notice is the brilliant typography used throughout the show.

If you’re losing sleep finding out which fonts were used:

AF Generation Z (in the text messages)
P22 London Underground (when deducing the clues)

Steve Jobs

Thu, 06 Oct 2011 07:00:00 GMT

February 24, 1955 – October 5, 2011

Courtesy: Wikipedia

parkour wizardry @ Tempest Freerunning Academy

Fri, 29 Apr 2011 07:00:00 GMT

fantastic video, great stunts and carefully edited. must watch!

Tempest Freerunning Academy.

i just love the super smooth background score in the video. it’s a remix of the song Lights by Ellie Goulding and has become my favorite running tune. you can download it for free here.

via: kottke.org

great photography doesn't have to come only from DSLRs

Fri, 17 Dec 2010 07:00:00 GMT

These stunning shots were taken with an iPhone camera:

New Year - 2010

Thu, 31 Dec 2009 07:00:00 GMT

2009 was good. I didn’t do to well in terms of fulfilling my resolutions last year, but I’ve got a great feeling about 2010. Here’s 2010’s resolutions:

Get my website/blog back up #

I’ve been saying this for too long now. 2010 WILL see this task done. Period..

Read one book a month #

I sought to do something similar in 2009, instead I tweaked my rss feeds and lived like an information junkie. No regrets though. i’ve learned and gathered much more information than I would have reading just books. The problem though is that my attention span has dwindled to an alarming low. Going to take care of that.

Get fit, get a Tattoo! #

I recently watched the movie Avatar with my folks. Both my bro and I were fascinated with the movie and in particular, Sam Worthington’s tattoo. My mom remarked, if you can get as fit as him, then i’ll pick the tattoo for you. This was mind-blowing for me. You see my family is an extremely pious one, and the fact that my mom would even hint at the possibility of me getting a tattoo made me giddy with joy.. This isn’t going to be done in a year. But I want that tattoo so bad :)

(Tried googling around for a pic of the tattoo, this link is the best I could come up with. )

Happy New Year folks ! Here’s wishing your 2010 is ten times more snappier and jolly than you hope it to be. What are you planning for this 2010?

New Year - 2009

Wed, 31 Dec 2008 07:00:00 GMT

It’s New Year’s Eve and I’m all set with my resolutions. Until I started seriously blogging (which-if you believe-would be around mid 2008), I never really saw the point in drawing up these lists. It felt lame, pointless and a waste of time. But with the advent of my blogging ways, I realize that maintaining a resolution-list would help keep check and achieve my goals/ambitions much faster. Besides, 365 days from now it will be nice to see how my priorities and views might have changed.

Brace yourself:

Start Regularly Gymming again #

In 2006-2007 I morphed from a whooping 100kg couch potato to a 70kg cardio-freak. From the start-mid 2008, I was diligent with my gymming and en-route to my distant dream 6-pack. Time to start putting up Arnold posters again.

Read the gazillion books just bought #

One of the many good habits my brother passed on to me, is a love for reading books. What the bugger also passed on was an insatiable need to purchase all the awesomest books around. 2008 gave us Reality Check, Outliers, Tribes, Presentation Zenâ€¦ all of which I already posses a copy of. This is apart from the many books I purchased in 2007 but never got the time to fully read.

Get Sketching #

I was at one point of time(sometime between the 7th and 9th grades) quite a decent artist. After my 10th (board exams), I completely left this and continued only to pursue my musical inclinations. I want to revive that lost interest and talent. Vector Graphics is also something I’m seriously looking at.

Learn Arabic #

I love learning languages. I’ve spent a major part of my life in the middle-east and it’s a shame I haven’t picked the language up yet. The fascinating thing about Arabic is that the script is really easy. I can in fact read and write Arabic pretty well. Each time I try to speak though, my bakala owner thinks I’m a retard.

There is no later, only now! It is my ardent belief that the number one productivity-killer is procrastination. I’ve fallen short of quite a few of my goals this year primarily for this reason. No more!

It’s a modest list, one that currently seems doable. Time will tell…

About

Mon, 01 Jan 0001 00:00:00 GMT

I’m a Principal Engineer at Instacart leading the development of our Caper smart carts.

I started the popular Android podcast Fragmented and am a Google Developer Expert for Android.

I write about programming, tech, life, movies and music here.

Tools #

Bits #

Programming #

Berkeley Mono is my programming font of choice
Ghostty for terminal stuff (along with tmux)
Zed as my main IDE & text editor
- I switch between Claude Code & Codex CLI for agentic coding
Intellij for Android/Kotlin development
- Firebender for agentic coding in Intellij

MacOS #

Obsidian for notes & todos
Raycast is my launcher
Firefox for browsing
CleanShot for screenshots on my mac
Logic Pro for editing

Atoms #

Desk #

Nordik Leather Desk Mat
LEUCHTTURM1917 Soft cover journal dotted
Uniball Deluxe 0.5mm Micro pens

Audio #

Earthworks Ethos - 400 microphone
USBPre 2¹ audio interface
AirPods Max (yes for podcasting!)

Physical #

I drive a Tesla Model Y (and eagerly waiting to move to an R3)

These are no longer sold but are built like a tank. I’d probably pick the Motu 2 if my USBPre 2 ever fails ↩︎

Contact me

Mon, 01 Jan 0001 00:00:00 GMT

The best way to reach me is via email – blog @ kau.sh

I’m on social media, but I mostly post one-way:

RSS

Mon, 01 Jan 0001 00:00:00 GMT

Here are the different ways to subscribe to my content on this site via RSS.

Feed Links #

/feed.xml — General feed (all the content I post)
/blog/feed.xml — Blog posts only
/letter/feed.xml — Newsletter letters only

Custom feeds #

I use my own theme “Henry” for this site, so there’s ∞ flexibility to choose a customized feed based on your liking:

Slap /feed.xml or /feed.json at the end of most urls here, and you’ll get a feed for that topic. For example I tag my blog posts that are tech tips as /tags/tip. You can get a custom feed for this using the link /tags/tip/feed.xml.

Henry for Hugo is open source.

Kaushik Gopal's Website

Agentic Fluidity - OpenCode is OpenClaw for coding

Server-client architecture #

Getting started #

AI model choices 2026-01

Forking subagents in an AI coding session with tmux

My requirements #

Super thin glue layer #

Tool-agnostic forks #

Interactive, not one-shot #

No context bloat #

No personas #

Label the subagents! #

The solution #

Caveats #

Wi-Fi sharing is a killer Android feature

Avoid signing every device into a captive Wi-Fi portal #

Work around “one device at a time” Wi-Fi plans #

Fix “devices can’t see each other” networking #

Secure networking with a Tailscale setup #

How to enable Wi-Fi sharing #

Almost every Android phone #

Technical Details #

AI is a motorbike for the mind

Combating AI coding atrophy with Rust

Why Rust? #

Systems level language #

New paradigms #

Built with Rust #

Kotlin developers will feel at home #

How I’m learning Rust #

Main Resources #

Using AI as a Rust tutor #

AI-assisted coding → Vibe Engineering ← Vibe Coding

1. AI-assisted coding #

2. Vibe coding #

3. Vibe engineering #

Go with monthly AI subscriptions friends

Firefox + UbO is still better than Brave, Edge or any Chromium-based solution

Manifest V3 permanently nerfs Chromium-based browsers #

Brave’s workaround for Manifest V3 #

uBlock Origin Lite != uBlock Origin #

Firefox offers the best experience with uBlock Origin #

Cognitive Burden

On Writing #

On Coding #

Standardize with ⌘ O ⌘ P to reduce cognitive load

Product vs Model Innovation

Addendum #

Agent Skills: How is it different from command and other tools?

Skills and how it works #

Why the alternatives aren’t as good #

AGENTS.md (monolithic) #

Nested AGENTS.md #

Referenced instruction files #

Slash commands #

MCPs (Model Context Protocol) #

The Verdict #

Addendum #

Skills are an open standard #

Skills is universal #

Cargo Culting

Definition #

Example #

Etymology #

ExecPlans – How to get your coding agent to run for hours

We are becoming software Conductors

Software conductors #

Task Orchestration Mastery #

AI-Compatible System Design #

Parallel Experimentation #

Real-time Cost-Performance Arbitrage #

Observability & Evals as a Discipline #

Generalist Thinking Over Specialist Skills #

Sorting Prompts - LLMs are not wrong you just caught them mid thought

Build your own /init command like Claude Code

Three important things to get right for successful AI Coding

Context #

Prompt #

Custom commands #

`browser.tabs.insertAfterCurrent` → `true` #