• Logitech MK240 Nano x 3 ($20 per piece)

• Logitech Pebble 2 Combo x 3 ($60 per piece)

See, this is modest and I was relatively happy with my setup. I don’t suffer from RSI or wrist issues (yet). Maybe because I don’t touch type? However, I do suffer from shoulder fatigue / feeling my chest is closed / squeezed (because mobile, compact keyboards).

But I was conveniently ignoring all this, including some of my friends who swear by the split / ergonomic keyboards. But a few days ago, a colleague 3D printed his own keyboard and my inspiration to look into split keyboards was re-ignited.

Anyways, three weeks in, this post is about my approach to getting into the split keyboards rabbit hole and some tips for those who are just getting started like me.

Validating the idea

Before even diving into all the resources above and spending “dozens of dollars” as a colleague called it, I wanted to see if any kind of split would make sense for me / how would that feel. So I did something hacky / funny (but surprisingly functional).

I connected two Bluetooth keyboards and used thick paper to block the keys as a split would have. It took me only ~30 minutes to get used to this setup and I could already feel the benefits of chest opening up because of the split. There was no going back from here.

But there was a problem (not visual, but functional). Since these are two keyboards connected separately to the laptop over Bluetooth, the modifier keys don’t work across the keyboards i.e. shift (left keyboard) + p (right keyboard) to print P. This was an annoyance, for the first time I was using right shift and other “redundant keys” on both sides.

Luckily, there is a nice (almost turnkey) software solution to this. It is called Karabiner-Elements. It automatically detects all connected keyboards and other input devices and all I had to do was to toggle “Modify events” on. This was enough to share modifier key state between the two physical and completely separate keyboards.

Strategy / Plan

Based on the A Beginner’s Guide to Split Keyboards article, I want to do the following:

• Get a simple row-staggered split keyboard: This matches my idea validation setup most closely. My goal is to be very productive from day 0. I am getting a Keychron Q11. It hasn’t arrived yet, but I am excited and a little worried as it is a high-profile keyboard, and for years now I am used to low-profile keys and slim keyboards.

• Research a simple column-staggered split keyboard: My initial research (and trying it out at the meetup) points to the Lily58 as a good starting keyboard. I almost had it second-hand before another buyer beat me to it (darn it).

• Prototype with cardboard: For research, I am using the splitkbcompare app and cardboard boxes to play around (very early days).

• Consider a build: I might also try building something like a Cheapino or some other idea.

Falling into the rabbit hole

Here are some resources:

Concepts & Guides

• A Beginner’s Guide to Split Keyboards → this is an absolute gem of a blog post to read about different types of keyboards, switches and keys, how to make a decision, what to look for etc.

• Other useful glossary / terminology links

  • Layouts

  • Mechanical switches

  • Gateron switches

• This is also a great resource to see what’s available out there in one place awesome-split-keyboards

Communities & Events

• I got lucky here, I asked a friend who ‘knows tech stuff, especially devices’ that I am getting into the deep end of mechanical keyboards and voilà, he hosts this meetup (I didn’t know) and the next scheduled event was 3 days later. The cue here is to find a meetup / event around you, maybe something exists?

  • This meetup was good for 2 reasons:

    • I could validate my terminology understanding as I could hold conversations

    • A lot of folks brought their keyboards that were laid on the table to try / get a feel for switches etc.

• Then there is this /r/ErgoMechKeyboards community

Inspiration (Videos)

• 34 keys is all you need: an ergonomic keyboard journey

  • Sounds crazy right? The answer to this is layers. Like when you hold shift, the lowercase letters become capital letters, that is a layer. In a keyboard with fewer keys, you have numpad on one layer, function keys on another layer (everyone maps their own, here is a concrete example and here is another one).

• How to Build a Handwired Keyboard

Closing

I am really excited to get into the world of split keyboards and I hope that this post inspired you to do the same.

Update

• My Keychron Q11 arrived, took me about 3 hours to be productive and about a day or two to be more or less at the same typing speed as before. Love the key noise. Took me a while to get used to the higher profile keys but switching to something super low profile like the Apple’s magic keyboard (which I sometimes use when in a co-working space) is not an issue at all.

While you know how to fix this bug instantly, this is still a major context switch as you have to

• stash or temporarily commit your current changes

• open a new branch

• make the “minor” change

• re-create the context

git-worktree aims to address this issue by allowing you to work on multiple branches in the same repository.

However, it only provides the ability to quickly switch a branch without losing context. To have a working project where you can test changes end to end, you need some additional things like

• the environment variables, as the .env files are usually git ignored, they aren’t copied over in the git-worktree folder.

• ability to run multiple versions of the codebase (if it is a web server for example)

Enter my setup

Worktrunk

A friend introduced me to Worktrunk the other day and I instantly loved it. Although, you can use git-worktree commands directly, worktrunk provides nicer APIs to achieve the same goals (copying .env files over, less typing).

It is a very thin wrapper, here is an example

$ wt switch -c feat1
# gets translate to
# git worktree add -b feat ../repo.feat1 && \
# cd ../repo.feat1

See their docs for other examples but you get the idea.

Copying .env files

This is very project specific so it would vary from project to project but usually my projects are powered by .env files. You can run a git hook using lefthook to generate an env file (by getting the relevant secrets from 1password or locally encrypted env files using dotenvx for example). In fact, this is what I was doing until a week or so ago before I ran into worktrunk.

Worktrunk has a concept of .worktreeinclude file which is a .gitignore style file for copying files over, here is what it looks like for a web project that I work on

$ cat .worktreeinclude
.env
.dev.vars

Just this file is not enough, you need a way to run worktrunk hooks on each work tree, here is my config currently

$ cat .config/wt.toml
[post-create]
install = "pnpm install"
env = "wt step copy-ignored"

So essentially, when a git-worktree is created via worktrunk, we install the dependencies and copy over the .env files (yes this works for nested files too). With this, you are already ready to work on the project and run a dev server (but what about port clashes?).

Clash of the dev servers

You are usually testing things end to end in a web server, I usually like to even run projects with https on a custom URL. To power this, I use caddy, here is what my Caddyfile usually looks.

$ cat Caddyfile
trackfootball.localhost {
  reverse_proxy localhost:5173
}

But when using multiple git-worktrees, I didn’t want to stop the dev server so port 5173 (vite default) gets free. I wanted to create a predictable pattern so the next available port is used (and is addressable with https).

Luckily, vite does half the job of running the dev server at 5174, if 5173 is not available but depending on your application, you might have to get a random port and run your application there.

For the other half, I use caddy, here is the modified Caddyfile

$ cat Caddyfile                                                                                                                                   
:80 {
        @default host trackfootball.localhost
        reverse_proxy @default localhost:5173

        @port header_regexp port Host ^trackfootball-([0-9]+)\.localhost
        reverse_proxy @port localhost:{re.port.1}
}

Essentially, this allows the following scheme to work

trackfootball.localhost - localhost:5173 # hardcoded, existing setup keeps on working
trackfootball-5173.localhost - localhost:5173 # port derived from url
trackfootball-5174.localhost - localhost:5174 # port derived from url

# and so on...

You might have to change some other things in your application for this to work for you or change the URL scheme to suit your application needs.

For example, this setup doesn’t support ‘login’ locally for me because the cookie domain is set to trackfootball.localhost. But it doesn’t affect my local because of my local login setup (more on that later, I don’t really recommend that approach). I will likely change this to be 5173.trackfootball.localhost in the future so the local login + cookies keep on working without any change.

Bonus - AI agents

Is it 2026 without a post mentioning AI agents? While this post is 100% handwritten, you might have noticed by now that the above setup would make AI agents have access to isolated environment with git-worktree easily (depending on what all do you need to / want to isolate in your environment).

In fact, worktrunk supports running any binary command with a single command while creating the git-worktree. Here is how you would boot the amp in one go:

$ wt switch -c -x amp feat1

Bonus - local login

I mentioned earlier in the post about why I am not bothered with local login auth cookie not working in my current setup, the reason is that I use an env var UNSAFE_AUTH_BYPASS_USER to completely bypass authentication locally (it is something I am experimenting with and don’t recommend it yet). In code it roughly looks like this:

    ctx.user = null

    if (
      env.UNSAFE_AUTH_BYPASS_USER === '1' ||
      env.UNSAFE_AUTH_BYPASS_USER === 'true'
    ) {
      ctx.user = {
        id: 1,
        createdAt: new Date('2021-05-05T12:41:06.248Z'),
        updatedAt: new Date('2025-06-14T19:07:43.754Z'),
        email: 'john.doe@mail.com',
        firstName: 'John',
        lastName: 'Doe',
        locale: 'en',
        picture: 'https://i.pravatar.cc/150?u=jd@mail.com',
        auth0Sub: 'google-oauth2|104619003144932489723',
        emailVerified: true,
        type: 'ADMIN',
      } as User
      return
    }

I did this to not having to deal with login flow and expiry locally (which I don’t recommend as it means that this code path will be less frequently hit). This also makes it easier for an AI agent to build features behind auth as it doesn’t have to struggle with authentication for each task.

Conclusion

This post described my current git-worktree setup, this hasn’t stood the test of time yet but I wanted to share it already to get feedback from the wider community.

Thanks for reading this and please share tips and your setup with me.

Now, it is time to get rid of Twitter as well. However, I am not ready to delete it fully yet. So, I devised a plan to block access for one year using Shamir’s Secret Sharing Scheme (SSSS).

In Harry Potter speak, Voldemort would have run:

ssss-split -t 1 -n 7

This means, there are 7 splits (of his soul) and any one of them keeps him immortal.

Here is my plan:

1. Generate a password (passphrase variant) using Bitwarden Password Generator and keep it in the clipboard.

2. Change Twitter password.

3. brew install ssss (it is an implementation of Shamir’s Secret Sharing Scheme).

4. ssss-split -t 4 -n 7 to split the password into 7 chunks, 4 of which are needed to reconstruct it

   1. Use futureme dot org to send me 1 split in 1 year from now.

   2. Use superpost dot com to send myself 1 split, this will be the only split that I would keep.

   3. Give 1 split each to friends / family who won’t budge until the one-year period is over.

   4. tl;dr Distribute the 7 splits such that getting 4 of them in a year should be safe enough.

5. Test the password retrieval with ssss-combine, this ensures that everything is in order. Passphrase variant makes it easy to cross check.

6. Yeet the password from the clipboard.

Risks

• I am unable to retrieve 4 splits when the time comes → that’s alright, not being able to access Twitter is something I can live with

  • Though if this happens, I won’t be able to delete past posts → on the fence about that, but I do believe that the internet is written in ink, my current self is willing to live with this risk

• Someone gets access to my 4 secrets → not an issue, there is a 2FA layer in between

• I can use password reset → to mitigate this, I change my email on a custom domain and transferred that over to a friend. My friend can of course reset the password (and disabled 2FA h/t captnemo.in) and therefore some level of trust is involved.

What’s next?

I am not doing this because I spend a lot of time on socials (spoken like a true addict, eh?). I follow minimalism at both digital and physical levels and have no apps installed, I use socials from web versions which is much less addictive. I don’t spend a lot of time on social networks. But it does affect my attention, I do tend to get nerd sniped by cool things happening out there and end up losing time / attention as a second order effect.

Twitter has given me many friends and connections, the feeling of meeting an internet person in real life for the first time is always amazing.

However, over the recent years the general quality has dropped with the onset of politics and bots. In the past, posting 100 tweets might yield 10 meaningful connections. Now, it yields maybe 1 in 100 (or fewer).

I will replace Twitter and find better ways to connect with people in real life and will use this extra time and attention to practice cool things that interest me. Mostly that would be writing software, mathematics, football analytics and movies. Looking forward to diving deep into several topics with Shugyo (修行) in mind.

With this Twitter block my social network posture remains:

• Instagram - not a problem, it is a private account with like 27 followers, close friends and family.

• LinkedIn - nothing changes, it is a professional network.

• Twitter - blocked.

• Bsky - exists, I don’t really use it, so don’t need to change anything.

• HackerNews - not a problem, I sometimes submit Show HNs that don’t get a lot of traction.

• I have no other social accounts.

In an ideal world, I will be in a place where I can just delete Twitter once I am back next year.

I will continue to write on this blog, mostly long-form content. Feel free to subscribe and let’s stay in touch.

In early 2023, I did a DNA test with 23andme. Of course, I made the rookie mistake of using my real name to create a profile. It might be too late for me but maybe this post helps others.

Creating a fake name would have been totally viable (according to some Reddit posts). As I got the reports back and became more aware of the subject (and how DNA data can be abused), it felt “wrong” to store it on a cloud service (iCloud, I did enable end to end encryption, so there is hope).

This + watching too much sci-fi birthed the idea of self-hosting everything including photos, media and files and having control of the email domain.

This year, the goal to move off Google and Apple photos was achieved. But first, let me talk about why I want to go off cloud for this (besides just privacy reasons)

I use an iPhone and Google Photos, so the pictures were getting synced to both clouds

• iCloud capacity was 200GB, Google’s capacity was 2TB - didn’t like this mismatch

• Wasn’t sure if either / both these upload the full quality picture or pre-process them

• Wasn’t sure about the relationship between the two clouds. Which one was the source of truth?

• Privacy concerns (obviously)

Current setup - Synology Photos + Tailscale

Hardware

• Synology DiskStation DS224+ 2 Bay Dekstop NAS

• Seagate IronWolf 4TB Internal Hard Drive x 2

Setup

• Synology Hybrid Raid SHR (3.6TB usable space)

• Google Drive for backups (more later)

While I didn’t purchase Synology NAS for Photos. It was meant for sensitive files like DNA data, identity document scans. In my research I quickly realized that synology photos has come a long way and can actually replace Google/Apple photos app.

The Synology Photos app offers a “backup” feature that downloads original quality pictures from Apple Photos and then you can optionally delete photos from Apple Photos. This is what I use but my “backup” is the “real” copy of my photos.

To access it on mobile devices, I use Tailscale and point the Synology Photos app to the Tailscale IP.

I could delete Google Photos. Apple Photos is not deletable (as the app is also the OS level API to move things around, duh) but I disabled photos sync to iCloud.

Experience so far

• Since I suddenly had much more storage space available. I started recording videos in Apple Log format and started taking photos in DNG (digital negative) format.

• DNG / Log - this is still experimental, log needs to be processed and DNG needs to be converted to JPEG (possible in Synology) before posting to socials.

• Tailscale makes accessing the library remotely easy BUT makes using a VPN hard. As iOS can only have one VPN at a time and I haven’t explored split DNS VPN on iOS yet (maybe it isn’t possible?). I can use Tailscale + Mullvad integration in dire situations.

• Backups still go to Google Drive, but they are encrypted on the device.

Ending this post with this security quote

If something is on the network, assume that it is exposed.

Hit me up if you have any questions about the setup.

As they say,

“the opposite of excellence is mediocrity”

I would like to add

“the opposite of good decision is indecision”

(and not a bad decision)

Most decisions are reversible, maybe not instantly but usually in 1-2 year time frame, usually less. Therefore, one must optimize for making “hard” decisions daily. Over time, the muscle builds and hard decisions get easier and slowly unlock more options for you.

The Avoidance Problem

Just making decisions is and getting better at them is not enough. You must also constantly put yourself in a position where you have to make decisions at a high cadence. This is where courage and or a system / framework to make choices that put you in front of decisions that you would otherwise avoid is important.

This post ended up being way more abstract than I originally intended it to be. I might revisit it but that’s all I have to offer for now.

1. next thing to work on is well defined

2. it is easier to recover from a slump by picking up the next thing

Read that post here if you are curious.

But can we summarize “stuckness” and all the possible solutions (distilling all the bodies of work on productivity) in one go?

“Stuckness” is this uneasy feeling when you are tasked with something that you ought not to be doing or it is at a hardness level that is unpleasant for you and your whole body-mind system wants to avoid that and it is pretty good at distracting you. This is where easier work that gives you a feeling of progress like microblogging or doom-scrolling kicks in.

The solution almost always is “act and do something”, do the next step, the smallest thing that you can do to move in the problem space where you are stuck. Most productivity systems encourage this one thing

• GTD (getting things done) encourages you to take up the micro-dopamine or distracting tasks in one go and build a pipeline for the rest

• The one thing encourages you to take up one thing at a time (which should be the topic of your “stuckness”)

• Eat the Frog encourages you to take up the hardest thing first thing in the morning. That’s usually the thing you are stuck at or has the potential for getting stuck at.

Once you read enough self help books and try enough productivity solutions — you realize that almost all of them are true (or none of them are true depending on your perspective). If you are able to follow any of the productivity systems for long enough (let’s say 1+ year), you will likely be in the top 1% percentile of productivity.

Some folks might want to point out that real life is different and instead of a “single stuckness” there is “nested stuckness” (things blocked on one another) and “parallel stuckness” (multiple priorities that are actually equal). This is true and I believe that’s where many people fail to stick to the plan because eventually things get so overwhelming that you think that the productivity system you employed is not working. That’s why mentally linking “action” as a solution to “stuckness” is so important.

To summarize, make “action” the default. Action is the solution to “stuckness”. Practice this thought so many times that it becomes the default reaction. That’s where the real growth will start to happen.

When in doubt do something, do anything, just act.

Doing minimalism with physical good is still easier than doing minimalism with digital goods. You see the things, can touch them, stack them up and give them away.

With digital good usually being a file or just a database entry the ceiling almost becomes infinite. I remember from early 2000s when phone photography was starting to pick up. My father was losing his love for his hobby of photography. When I asked him why, he answered (paraphrased) “in the world of SLR cameras, every shot had a cost of being filmed on a physical photo roll and that made each picture more valuable and precious”.

With the prevalence of free photos, we end up taking many more pictures than before but fewer ever make it to a family photo album (if the concept lives on at all).

But anyways, personally, I have always been good at physical minimalism (Maybe even too good, once a friend visited me and force ordered some stuff on my amazon that he deemed as life necessities. I am grateful to having such friends). A “trick” that I have been using to manage minimalism in the digital realm has been to try and have a physical copy of a digital item that should be on my mind.

Example, all books, movies I have have a physical “mirror” (sounds unintuitive in minimalism land but provides a ceiling where none exists). I don’t delete older books but just put them in a cold storage that aren’t accessible. That means the stuff on “top of my mind” in digital world gets capped. This doesn’t apply to all the books, I might read a book in digital if I have decided to read something but keep a physical copy if I plan to re-read the book.

I do something similar with movies (I self host all the movies since last month, no more streaming services as the fragmentation in the industry meant loss of value, unlike spotify which seems to have won the music wars) and PS5 games.

Overall, minimalism brings clarity to me and some logistics are justified.

Microblogging (like Twitter) is pretty interesting. The limits of 240 characters (previously even 140) has a huge advantages like that it forces you to be terse and deliver condensed idea in a concise form (which I am sure seasoned writers benefit from and love) and it reduces the bar to entry (Tweeting is much easier than writing a full blown blog post).

The downsides of modern social network economics encourage a lot of live status updates (shit posting etc.). I believe on the long run that is detrimental to craft of writing on the long run. Further “stream of consciousness” writing has advantages like feeling expressed yet to be a good writer, you need to do what mastering any craft takes, which is to write more and more and some more.

Microblogging satisfies the dopamine needs and the “need to write” might suffer in some people, specially those who started the craft of writing with microblogging platforms.

Some of this might not apply to everyone and that’s okay but I am sure it does apply to a lot of folks and with this piece of text. I wanted to raise awareness on the topic.

Going forward, I will refrain a lot of posting “status updates” type of posts on Twitter and resort more to long form / blog like texts.

After all, it aligns with a very strong personal value I have. I value “attention” a lot (maybe it is even the most valuable thing we have) for both myself and you.

Until next time.

In this post, I would like to deliberate on some properties of an abstract productivity system using which as a base, one can form a system that works for them.

It boils down to the following:

1. A productivity system should help you to make progress during "bad" days.

2. A productivity system should increase your trust in yourself.

Let's dive deep into each of these

Progress

Life happens, you could be having the most productive time of your life, only for the streak to be broken by unexpected (or expected) travel. Or you could be sick. A productivity system shouldn't make you feel guilty during these times of unavailability, neither are you expected to be productive when you should be enjoying or recovering.

Getting back to momentum once you are available again should be enabled by your fancy task list. Which means it should have bite sized tasks waiting for you to take take up and well defined themes of what to do.

If you are curious like me, you need a list of things you won't do or do next year. Always protect yourself from being nerd-sniped.

Trust

I didn't make this connection between trusting yourself and productivity systems for a while. In the beginning, I was making the rookie mistake of being too ambitious, only to fall short on goals.

Only when I started aiming for the "next step that I can take" in a bigger goal and capped the ambition to meet myself where I am, I made this connection of trust. I went from the usual over ambition stressful goal system to "I am someone who achieves 100% of his goals".

Of course, this only works if you are honest and don't make the goals too easy. Learning / growth should feel hard like a good workout but never hurt / injure you. The productivity equivalent is that you are stopped in your tracks and stop relying on a plan.

Other Tips

Immutable - Make the system immutable, it is okay to drop goals / change plans but when you do, write a note that you did that. That would help you with honestly finding your capacity and retrospective review, so you can plan better in future.

Administrative tasks - If you are like me an find doing taxes and other admin tasks super tedious. Just keep mental bandwidth that 20% of your time WILL go into doing administrative tasks. Just doing the mental space separation adds to expectation-reality matrix and helps put them on the list and therefore getting them done (you are the person who achieves all of your goals remember wink wink).

1. Write an update script: symlinks are needed to work around updating a running instance of cursor

   $ cat ~/Documents/software/cursor/update.sh 
   #!/bin/bash
   
   APPDIR="/opt/cursor"
   SYMLINK="$APPDIR/cursor.AppImage"
   TIMESTAMP=$(date +"%Y%m%d%H%M%S")
   
   # Fetch the latest download URL from the Cursor API
   APPIMAGE_URL=$(curl -s 'https://www.cursor.com/api/download?platform=linux-x64&releaseTrack=latest' | jq -r '.downloadUrl')
   
   # Validate that we got a URL
   if [[ -z "$APPIMAGE_URL" || "$APPIMAGE_URL" == "null" ]]; then
       echo "Failed to fetch download URL from Cursor API"
       exit 1
   fi
   
   # Download to a versioned filename
   NEW_APPIMAGE="$APPDIR/cursor.AppImage.$TIMESTAMP"
   mkdir -p "$APPDIR"
   wget -O "$NEW_APPIMAGE" "$APPIMAGE_URL"
   chmod +x "$NEW_APPIMAGE"
   
   # Update the symlink to point to the new version
   ln -sfn "$NEW_APPIMAGE" "$SYMLINK"
   
   # Optionally, clean up older versions (keep last 3)
   ls -tp "$APPDIR"/cursor.AppImage.* | grep -v '/$' | tail -n +4 | xargs -r rm --
   
   echo "Cursor updated successfully: $NEW_APPIMAGE"

2. Make an update systemd service

   $ cat /etc/systemd/system/cursor-update.service 
   [Unit]
   Description=Update Cursor
   
   [Service]
   ExecStart=/home/d/software/cursor/update.sh
   Type=oneshot

3. Run it on a schedule

   $ cat /etc/systemd/system/cursor-update.timer 
   [Unit]
   Description=Run Update Cursor every 6 hours
   
   [Timer]
   OnBootSec=5min
   OnUnitActiveSec=6h
   Persistent=true
   
   [Install]
   WantedBy=timers.target

Here is my experience from the batch

The Planning

I knew about RC from about 2017, when I met someone who was attending a batch in Bangalore. I wanted to do a batch since then and the original idea was to find time in life to do it in person from NY. Fast forward to late 2022, when I was planning for the year 2023. I thought that I would do a batch in 2023 but RC wasn't yet open to in-person, so I planned my batch remotely.

I just planned it way too early (as RC ended up opening for in-person batches). By February 2023, I knew that I would do this batch at the end of the year. Yes, if that sounds too early and too far ahead, it is true. For the last 2-3 years, I plan my yearly goals ahead of time and I chose this time for an RC batch because

1. it is easier to take vacations around Christmas (I originally planned to take time off and do a half-batch but by the end of the year I ended up leaving my job to do a full-batch)

2. winters in Berlin is brutal, I thought it would be a great time to do the RC batch and add a kind, social programming community to dark winter times

The Experience - First Half

I quit my job in September, so I roughly had 1 month before my batch started and I was simply tinkering and having fun building zoid-fs. When my batch started, it was a wonderful experience from the beginning, I met a lot of kind and curious programmers working on the edge of their abilities. Since, I had some momentum with my project, it acted as an anchor and protected me from the overwhelm of multiple streams of things happening at RC, there are always many different tracks of things happening at RC and FOMO can be real.

Timezone wise, I was in Europe, so I had the following setup, I would start working a bit late (I was mostly playing Football in the morning), like 10am-11am and work on my projects till 5pm. Then the US folks are available, so I was using the evenings mostly to pair program, attend events and do coffee chats. This worked really well for me.

With zoid-fs, I originally wanted to build a CRDT aware file system, so you can mount, say Obsidian on this file-system and it auto syncs across machines and there is never a collision. Though while working on the project, I diverted my attention to making it as much POSIX compliant (by running it against a POSIX test suite) and performant as possible. That meant that my data structures (chunked binary per file) is not the best suited for CRDTs and that was okay. It can support various backends and I would in future write a non-efficient (text only files, one DB column / file) backend that supports CRDTs.

However, I was able to do some cool things with this file system, like

1. Making SQLite in SQLite work

2. Automatic document sorting with LLMs

3. Making it a distributed FS by simply mounting it on Turso

4. (incomplete) Making PostgreSQL createdb work in this FS, so PostgreSQL in SQLite

I also wanted to make a "always" compressed filesystem which led me to the rabbit-hole of my second big project in RC. I started the compression bits and got curious about how does compression **really** work, that led to me building zoid-zip. It is super slow but it does compress and decompress text files and it led me to appreciation for the field of data compression and information theory. I read further a lot about how to make this faster / production ready but didn't pursue to programming those as I wanted to move on to some other things.

It was also during this project that I learned a lot about bit manipulation and ArrayBuffers in JavaScript. In this project, I do all the necessary bit manipulation without using bitwise operators but getting a DataView in which bits are always available in an array, see Uint1Array. I think this is different from any other programming language and pretty cool.

All of this has happened and not even the first half of the batch is over, so of course I felt super productive. Besides, I used the "coffee chat" feature of RC and was meeting new people every day. This was a very fulfilling period of my life.

At this point, I spontaneously decided to tackle a project that I always wanted to do. I got into computers and programming because I used to play game boy games in a GBA emulator roughly when I was around 10-11 years old. I was always fascinated by emulation and decided to take a stab at it. This led to zoid-boy. I still had ~10 days left in the first half of my batch and I didn't want my RC time to become just about this project, so I time-boxed it. I wanted to build as much of the emulator that I can in these 10 days and then abandon the project. When I started, I was relatively confident that I would be able to reach at least a single pixel on screen stage (that didn't happen). I also didn't want to boringly type all instructions, so I wrote a small parser + code-generator that generates the CPU based on the assembly instruction mnemonic. Then, I went through this blog. It goes instruction by instruction and shows the state of the CPU and I just matched the state with the state of my generated CPU. With this workflow, I was able to get the boot rom to a success state and that was the end of this project.

The Break

During the mid-batch break, I travelled to Japan and didn't even carry my main laptop with me. This was my second trip to Japan in 2023 and again one of the best trips of my life but I won't digress too much in this post

• March 2023 Trip

  • Mt. Fuji

  • Osaka Castle

• December 2023 Trip

The Experience - Second Half

Unlike the momentum of the first half, my second half at RC started a bit slow. The batch resumed on 3rd January 2024 but I was set to return to Berlin on 9th January 2024. So there was a small overlap of travel i.e. unproductive time. Besides, I wasn't sure yet what would I do in the second half of the batch.

Was doing a bunch of reading/side quests (mentioned in the next section) before the first "Impossible Day" of the second half. "Impossible Day" is an RC event where you attempt to do a project in 1-day that you feel is impossible (for you). I started a no-code website builder and that was the foundation of my second half at RC (and till now after my batch).

I wanted it to support custom domains and everything and have a simpler infrastructure/deployment setup. So, I played around with setting up SSL for user defined domains with Caddy and deployments with Kamal and was pleasantly surprised by how good these tools are. Then, I dived into the rabbit hole of CSS in depth and layout system to build such a no code system.

Learned a lot while building this and I am still working mainly on this in the last few months.

Side Quests

So far, I only wrote about the main projects that I worked on at RC. I also did this thing that I call "time-boxables" where I spend 1-2 day doing something like a small project or play around with something, here is a quick list of such things (not ordered)

- Trying to turn my primary dev environment to a NixOS VM. Eventually, there was enough friction that I switched to using Ubuntu VM and now I am back to macOS. I started doing this because building FUSE filesystem experience was way better in Linux vs macOS

- Game of Life, believe it or not, in a pair programming workshop, I programmed game of life for the first time in my life. It was super fun.

- Attended nand2tetris, maptime, crafting interpreters, emulators and VMs group, cryptopals, sadservers for a while on and off

- LLM based cover letter generator (to practice doing automatic document sorting with LLM in the file system)

- Open sourced TrackFootball.app

- Had German B1 exam on 14th November, so smack in the middle of things. That worked out well, I passed

- Update CV for potentials jobs etc + some interviews. Also, landed some "dream roles" at the start of the RC batch, so it didn't work out. This was top tier learning experience though, I feel that saying no to a dream role is super hard and I felt like I levelled up in taking responsibility of my own life when I did that to continue RC + planned sabbatical

- Played around with Calcite, wanted to build an SQL layer on top of FoundationDB. This project is super interesting to me, it died because FoundationDB doesn't work on any ARM processor, so I couldn't get a workflow setup (yet)

- Picked up Effect.website and moved a bunch of small application to Effect. I am sure it will be big in the TypeScript ecosystem

- Wrote a TCP PostgreSQL proxy to hot-swap the user in the proxy. This meant I had to re-implement the secure authentication in PostgreSQL wire protocol

- Fakegres - distributed PostgreSQL built with Raft backed by SQLite (technically this was after my RC batch)

Closing Thoughts on RC and Advice

If you are just going to start a batch or on the fence for doing a batch, this section is for you. Please take it with a grain of salt as everyone is different. What works for me might not work for you

Do regular checkins: in the first half of the batch, I did a written check-in almost every day so I felt more coherent, productive and the time felt slow. In the 2nd half of the batch, I did check-ins sporadically and it felt like that the time just flew by. I didn't do video check-ins though they are available for two reasons, one I prefer written over video more and two it happened at 5:30pm in the evening for me, when I was already wrapping up the coding part of my day

Avoid FOMO: A lot of stuff is happening at RC at any given time and while I had the anchor of my projects. I still felt a bit of FOMO when saying no to events. Luckily, RC has the policy of "never graduating", and these events keep on happening in various shapes across batches. So, you can always do something outside of your batch. I convinced myself of this perpetual availability to say to to more things

Self-directives: RC self directives are super powerful and in one of the related workshops, someone mentioned "when in doubt, write code". This was a very powerful directive for me. It took away all the stuck-ness from things that I experienced as I was no longer bound to planning/doing things right.

People are awesome: RC is a very unique community of kind and curious programmers, my personal experience was better than expected. Not only it was fun to talk to folks doing their own curious projects, there was a lot of positive energy in seeing folks just follow they curiosity and working on things just for the fun of it. Some people ask me, if they can do whatever I did in RC without doing a batch since it is self directed, the answer is no because the people and the vibe make all the difference. When you are working on hard projects and are stuck, it is empowering to see other people share their journeys of pushing through their limits and at RC there are people from various expertise and background, so there is a big chance that you would get unblocked by someone in a pairing session.

Presentations: Presentations is also a great recurring event at RC, folks present all sorts of cool things that I didn't think were possible!

The End

My RC batch was a great and fulfilling experience for me and I will surely do another batch in the future. I am grateful to have shared with likeminded and curious people. If you have any questions regarding RC or are curious about any of my side projects, please don't hesitate to reach out on Twitter.

To lose 1kg, you approximately have to be in ~7700 calorie deficit. For simplicity and to be on the “safer” side, I will use 8000 calories = 1kg weight loss. TK source

Example numbers for my use case:

• Weight: 72kg

• Body Fat Percentage: 24%

• Lean Mass (weight - fat): 72 - 24% of 72 = ~55kg
  (note, this includes bones)

• Basal Metabolic Rate: 55 * 30 = 1650 calories
  (or resting energy or daily calorie intake to maintain the weight)

• Active Energy (Daily Average for 1 Year) = 600 calories

• Total Daily Energy = 1650 + 600 = 2250 calories

• Weight Loss Goal: 0.5kg / week = deficit of ~570 calories / day

• Calorie Budget per Day = 2250 - 570 = 1680 calories

I was 78kg at the beginning of this year! Also documenting my experiments on Twitter:

Follow here:

https://twitter.com/divyenduz/status/1609546345076883456

Gotchas / Other Things / FAQ

1. To lose 0.5 kg (a sane speed) in a week, you need to lose around 4000 calories which is being in a deficit of ~570 calories per day.
   
   Why sane speed? because if you do it too quickly, your body slows down the metabolic rate
   

2. Body fat percentage → mine is based on InBody scan, DEXA scan is more accurate. But if you have nothing available, there are crude methods available.
   

3. Why multiply lean body mass by 30 calories to calculate basal metabolic rate? It is based on the book exercised

   

4. Calorie math goes like this
   1g carb = 4 calories
   1g protein = 4 calories
   1g fat = 9 calories
   1g alcohol = 7 calories (safe to treat it like fat) TK source
   

5. Glycemic index → some foods are broken down slower than others, make you feel more satiated. If you are more satiated, you eat less. Fat has a high glycemic index
   

6. balanced diet → don’t try to skip fat totally or be leaned towards one macro nutrient.
   
   Besides macro nutrients, a balanced diet also helps with various micro nutrients that the body needs
   

7. Hard things about counting calories → food labels can be +/- 10% off, weighting everything is hard, not all food is calorie counted, hidden calories (like sauces etc.)
   

8. Hard things about resting energy → it changes, specially if you shift your diet drastically. Apple watch and many online tools calculate it incorrectly because they use non-lean mass (see point 2)

1. Availability of tools like strace

2. More documentation on the internet vs macOS

3. libfuse is more stable in failure modes vs OSXFuse (which means when I did something bad Linux crashes more gracefully than macOS)

Tweet: https://twitter.com/divyenduz/status/1712769548389065079

Demo: https://www.loom.com/share/aef864889f3840c7af85551bd479fc83

To set up a Linux dev environment still using macOS as the main operating system, I was using a hosted linux server (SSDNodes.com) but the latency was too much, so I thought about doing a local Linux VM (NixOS) and SSH into it.

Note: this is not a tutorial, I have skimmed fast through the details of how I made things work. If something is unclear, please feel free to reach out.

Goal

Since I am new to NixOS, the goal is simple, make this FUSE project run smoothly. I don’t have to be a Nix expert today but it should also not come in my way once my happy development path is set up. I should be able to pick my NixOS battles.

Eventually, I would like to move all my development to this setup, so switching to a new laptop can be “ideally“ one command.

Note that this is an experimental setup, I haven’t used it enough yet to comment on, if it is good or not.

Note my understanding of Nix is limited, this is almost the first time I “dove deep” into it. If I am doing something incorrectly, please let me know.

How it Works

For getting NixOS VM, I used OrbStack, this was the easiest part of the process. Going from nothing to a running NixOS VM took less than 5 minutes.

Cursor + Remote-SSH

Cursor (VSCode’s fork) remote SSH was the first hurdle, two problems

1. SSH credentials didn’t work, orb does some magic so, just ssh orb should work™ and it does in Teminal but Cursor failed to resolve the orb URL. So, I had to use the raw connection details from OrbStack.

   

2. remote-ssh didn’t work, in hindsight I know that is because NixOS + VSCode need some work to play together. Mainly, it doesn’t work because the node binary bundled with VSCode/Cursor doesn’t work in NixOS (different architectures). There are three ways to fix this

   1. Copy a working node in the ~/.cursor-server/bin/<version> folder. We will get later to how can you install such a node version in NixOS.

   2. Use nixos-cursor-server, I made this as a fork of nixos-vscode-server, and to my surprise it worked! All I had to do was global rename
      /s/vscode-server/cursor-server/g
      in text and file names and rebuild flake.nix file with
      nix flake update

   3. Use nix-ld, it is a way to “Run unpatched dynamic binaries on NixOS”

This was enough (I tried them all, settled with b.) to make remote-SSH work, however the in-editor terminal is still not working, it fails with:

Interestingly, it works in VSCode, just fails in terminal. I have a hunch about why this might be happening but in the interest of setting up the development environment further, I skipped this for now. I can always SSH with iterm and use tmux (which is also my normal development flow)

libfuse (and dynamic library loading)

FUSE bindings require libfuse to be installed on the machine, installing dependencies is easy enough in NixOS, for global dependencies (and CLIs), edit the configuration nix file

sudo vi /etc/nixos/configuration.nix

and run

sudo nixos-rebuild switch

Here is how the relevant part of my configuration.nix looks like:

My expectation was that, just doing this will both install fuse and make it available for bindings. It did install fuse but the binding command failed with

As the error message suggests, it was unable to find libfuse. Linux has a way to find packages (they are expected to be in well known places) and there are hooks to load them from non-standard paths.

On NixOS, things are installed at /nix/<*> path instead of /usr/lib or /lib for example. I eventually fixed this properly (while building Prisma, further in the blog post) but at this moment, I did what the error message told me to do i.e. find libfuse and put that in PKG_CONFIG_PATH

Then, put the first path (I am not sure why there are so many) in an env var like

PKG_CONFIG_PATH=<path-to-folder-containing-fuse.pc>:$PKG_CONFIG_PATH

I later realised that this is the “wrong” way to do it, and the proper (to the best of my knowledge, please correct me if I am wrong) way to do it is via nix-shell (idk, maybe flake is even better but I haven’t used them yet).

Anyways, setting this env var made “npm install” work which means node-gyp was able to find libfuse and everyone was happy.

Prisma (more dynamic linking)

Prisma’s architecture involves binaries that it downloads in the background.

The problem is that they don’t have precompiled binaries for NixOS. Probably not for the library or something (I am not sure if this is a bug or not) but this is what happens if I try to run

npx prisma version

I know that you can compile + provide custom binary paths to Prisma CLI and that’s the path I took. That is cloning prisma-engines repo and running

cargo build --release

The problem, cargo expects some libs to be installed at available at standard paths, like openssl etc

The same solutions that were needed for libfuse + bindings were needed here, however, I read a bit more and realized a better way to do dynamic linking using nix-shell

nix-shell provides a temporary shell unique to the project (shell.nix file lives in the project). Using this file, you can easily populate env vars and otherwise the build environment for a project to work. Here is how my shell.nix file looks for prisma-engines repository

(I think it is missing the “correct” way to link openssl, because I patched it the same way I did libfuse, using OPENSSL_DIR env var). For some binary dependencies, it is using nix-ld.

Proper way might be this: NixOS + Libraries

Once cargo build --release worked, I had to make the correct env vars, to do that, I used shell.nix in the main project directory now with following contents

Note: I had to rename the libquery_engine.so binary to libquery_engine.node, to make it work (I am not sure yet where this requirement comes from but only .node works)

Summary

This blog post and my setup is WIP (as you can see) but I am surprised with the amount of good documentation that NixOS has on various topics and I was able to get the thing to work. Overall, I hope to make this VM my primary development environment eventually and open source my configuration.