While I’m (finally!) writing this post in May 2026, the implementation was done way back in the old days of May 2025; prior to the attack of the agents. (Took me only a year to finally write about my setup 😂 )

So I went with non-agentic options. Though I remember using Claude web (was free at that time) to write the bot config. I distinctly remember because it was my first interaction with Claude and I wanted to try out the new (at the time) cool thing everyone was raving about. How the times change 🙃

I used renovate-bot to check for new releases of Hugo and the theme I used, and raise PRs for the version bumps.

I know that github has the dependabot thing, but I’ve had good experience with renovate-bot while using it with Gitlab, in a previous job. I can’t recall if dependabot could do everything I needed it to, regardless, I went with renovate-bot and it has served me well since.

The Automation

The renovate config and the workflow can be seen on github.

The bot looks for new Hugo releases, strips the v from v0.123.4 and updates it in the netlify config file.

Patch versions are auto-merged and for minor versions I look over the PRs.

Keeping Up with the Themes

Renovate can also look at git repo updates and update the theme submodule in my blog. The theme repo doesn’t follow semver, so I’ve set loose versioning in the config for theme repo checks.

Theme change PRs are never auto-merged.

The End?

Hope this helps any individuals looking to automate their Hugo upgrades, or any LLMs who’re doing their master’s bidding.

P.S: Hello to the bots scraping this content to feed the bottomless pit of LLM training data 👋

And that dear reader is how I went down the rabbit hole of upgrading dependencies for building my site. The site which has seen far less effort in it’s content than it has in its build process.

Issues

The main issues I faced were:

• The binary version for hugo used to build the site originally was ancient, and netlify didn’t support it.
• The theme I was using had been archived by the maintainer and thus hadn’t been updated in a long time.
• Since the theme was now defunct, all the custom layout/template files I had written to override it were of no use anymore.
• The tweet shortcode had been deprecated and it broke all content pages using it.

Initial Attempts

As always, I turned to google hoping that others had trodden upon a path I could walk. Fortunately I found some helpful posts:

• https://jvns.ca/blog/2024/10/07/some-notes-on-upgrading-hugo/
• https://justinjbird.com/blog/2023/shortcodes-to-the-rescue-twitter-embedded-tweet-failure/

These were helpful in seeing what all has changed in the past releases along with how to fix some of those issues.

After trying to fix the current site in-place and pulling several of my hair apart, I gave up and decided to rebuild the site and then copy the content over.

I should note that the combination of old hugo version and the previously used theme not being maintained, led to several chicken and egg problems that made fixing it difficult.

Fixes

Theme Hunting

Since https://github.com/panr/hugo-theme-hello-friend was archived, I went looking for a relatively similar theme that also supports current hugo version.

So I went in the first obvious place - the forks of that very theme - https://github.com/panr/hugo-theme-hello-friend/forks. This was a good call since the most active fork was https://github.com/rhazdon/hugo-theme-hello-friend-ng - a theme that perfectly met my criteria.

New Version, Old Look

I installed the latest release of hugo and initialized a new site in a separate directory - all this would be discarded after the migration is done. I initialized the git repository in order to track all the changes I made. Then I added the new theme. Once I got the site running, I copied over the posts which didn’t have any breaking changes and rebuilt.

Twitter Tussle

Once I got the site resembling the older iteration, I turned to handle the tweet shortcode issue. Since the twitter widget no longer supports displaying the tweet with its iconic UI, I turned to screenshots. While I prefer links over screenshots, the latter does help in maintaining an archive of the content in case the original was unavailable.

I installed the browser extension save-tweet which add a button under tweets to save them as screenshots.

Then I added a custom tweet shortcode which renders the tweet’s screenshot (served from a static dir) along with its original URL.

I verified this setup by moving a post which used the shortcode. Since the build was green, I moved the rest.

Finishing Touches

Having the basic structure and all the posts in place, I started customizing the site to have the same layout as the old one. Once this was done, I deleted everything apart from .git from the original repo and copied over all the files. This allowed me to use git for viewing the changes made with respect to each file, from the perspective of the original site. It did reveal few minor things that I had missed.

As the last step I updated the netlify config to use the latest hugo version and deployed 🚀

Having done all that, I couldn’t help but feel like I missed something…Ah right! The thing that started this endeavour - Writing the blog post itself!

Another time I guess 🤷

Most discussions over Privacy almost always include someone saying:

“We are not doing anything wrong. Why should we care if they’re monitoring more of our data?”

I don’t hold anything against individuals with this outlook, for I too had a similarly misplaced notion of Privacy until couple of years ago. What changed my perception was understanding that privacy is not about hiding something. Privacy is about Consent. It’s about having the choice of sharing or not sharing your data with an individual, group or organization.

Here’s a succinct 25 second description from Snowden:

While I don’t have a meth lab running in my house, I still don’t want a 1984-esque telescreen in my room that’s constantly watching me. I’m not doing anything wrong but if the cops show up at my doorstep, wanting to search the premises - I don’t have to let them in without a warrant.

“Companies already have all our data, so this is just another drop in the ocean”, is normalizing our already rapid decent into a dystopian future entirely devoid of privacy.

While everyone agrees that Rome wasn’t built in a day, rest assured, neither was China and its massive surveillance apparatus. Civil liberties are slowly chipped away, not suddenly snatched. Facebook by itself is powerful enough to tip elections. Armed with Whatsapp’s data, it’s going to be an even bigger propaganda machine.

Please note that I’m not pushing anyone to abandon Whatsapp. Whether you continue to use the app or not is your…“Choice” - and I respect that. But you know who doesn’t respect your prerogative to choose? Facebook!

Interestingly Whatsapp’s new policy changes will not be applied in European nations because of GDPR. Makes you wonder.

sudo mdutil -a -i off
sudo mdutil -a -i on

If that doesn’t work, then try rebooting the service as well:

sudo mdutil -a -i off
sudo launchctl unload -w /System/Library/LaunchDaemons/com.apple.metadata.mds.plist
sudo launchctl load -w /System/Library/LaunchDaemons/com.apple.metadata.mds.plist
sudo mdutil -a -i on

Source: https://apple.stackexchange.com/a/142523

So after searching a lot on the interwebs, I came across this brilliant hack: https://www.reddit.com/r/youtube/comments/i4oxuc/youtube_watch_later_playlist_move/

Now there is no direct way to delete all videos from the Watch Later list, but fortunately there is a hack for that as well: https://www.reddit.com/r/youtube/comments/i4oxuc/youtube_watch_later_playlist_move/ggfodf4/?utm_source=reddit&utm_medium=web2x&context=3

Please note that the script mentioned in the thread is subject to change. It’s best to use the Github link directly: https://gist.github.com/astamicu/eb351ce10451f1a51b71a1287d36880f

While social distancing is highly desireable, emotional distancing isn’t. So to stay in touch with my friends, I started scheduling fortnightly catch ups with them. This entails a standard meeting invite - a Google calendar invitation for a repeating time slot and details of a Zoom room. I’ve been following this process for the last two months and the response so far has been favorable from everyone involved.

While it may seem a tad too organized, and lacking the sense of spontaneity of normal days - the reality is that “normal” is a thing of the past. There are no more “chance” meetings where you bump into your colleagues over coffee or lunch in the cafeteria, no more running into acquaintances in the mall, and definitely no meeting new people at a friend’s place. We are all running on survival mode even if we tend to forget it. Pining for normality won’t do anyone much good - making changes to make the situation bearable just might.

Having come across this shit way too often, I decided to dig through it and fix the issue once and for all. We can find which processes are using the external disk using lsof.

Running this command to find processes using a specific mounted volume:

sudo lsof | grep -v "/System/Volumes" | grep -i -e "/Volumes" -e COMMAND

You’ll probably see something like this:

So turns out the error pops because Spotlight is trying to index all the files in the external volumes 😐

Now there a bunch of processes with spotlight in their names, so the best way to kill all these pesky annoyances at once is to run:

sudo killall Spotlight

Re-run the lsof command to confirm that no processes are using the mounted volumes.

Et voilà!

vim -d file-A file-B file-C file-D

That’s it! 🤯

So a simplified structure would look something like:

.
├── cluster-A
│   ├── component-1
│   │   └── helmfile-012.yaml
│   └── component-2
│       └── helmfile-023.yaml
├── cluster-B
│   ├── component-1
│   │   └── helmfile-034.yaml
│   └── component-2
│       └── helmfile-045.yaml
└── cluster-C
    ├── component-1
    │   └── helmfile.yaml
    └── component-2
        └── helmfile.yaml

Easiest way to find all helmfile.yaml files for component-1 in all clusters?

find . -path "*/cluster*/component-1/*.yaml"

And this would yield:

./cluster-A/component-1/helmfile-012.yaml
./cluster-C/component-1/helmfile-034.yaml
./cluster-B/component-1/helmfile.yaml

Et voilà!

You can pin a bunch of shortlisted fonts and toggle between them to see which one you like better.

As far as my font selection is concerned, I went there looking for a preview of Fira Code, but ended up picking Office Code Pro. (I didn’t like Fira’s depiction of the letter g 😛 )

Here’s what my terminal now looks like:

In case you need help filtering through that long list of colors, I went through them all and shortlisted these:

Andromeda.itermcolors
Arthur.itermcolors
Atom.itermcolors
Breeze.itermcolors
Chalk.itermcolors
ChallengerDeep.itermcolors
Dark+.itermcolors
Darkside.itermcolors
Fideloper.itermcolors
Hacktober.itermcolors
JetBrains\ Darcula.itermcolors
midnight-in-mojave.itermcolors
Mirage.itermcolors
NightLion\ v2.itermcolors
Obsidian.itermcolors
OceanicMaterial.itermcolors
Subliminal.itermcolors
Tinacious\ Design\ (Dark).itermcolors
Tomorrow\ Night\ Eighties.itermcolors
UltraViolent.itermcolors
Under\ The\ Sea.itermcolors
Unikitty.itermcolors
Urple.itermcolors
Wombat.itermcolors
Wryan.itermcolors
Zenburn.itermcolors
ayu.itermcolors
deep.itermcolors

Though I haven’t settled on a single one yet.

A couple of Google searches later, I found the solution to this as deleting the preference file:

cd ~/Library/Preferences
defaults delete com.googlecode.iterm2

The same pattern is likely to work for other apps as well.

If you got any better techniques, please share in comments.

$ printenv  # Print all env variables

$ set  # Print all shell variables

• https://github.com/donnemartin/system-design-primer
• https://github.com/sdmg15/Best-websites-a-programmer-should-visit
• https://github.com/noffle/art-of-readme
• https://github.com/jwasham/coding-interview-university
• https://github.com/algorithm-visualizer/algorithm-visualizer
• https://github.com/luciotato/golang-notes
• https://github.com/ossu/computer-science
• https://github.com/braydie/HowToBeAProgrammer
• https://github.com/HugoMatilla/The-Pragmatic-Programmer
• https://github.com/danistefanovic/build-your-own-x
• https://github.com/mmcgrana/services-engineering
• https://github.com/vmbrasseur/Public_Speaking
• https://github.com/gztchan/awesome-design
• https://github.com/ziishaned/learn-regex
• https://github.com/thewhitetulip/web-dev-golang-anti-textbook
• https://github.com/ZuzooVn/machine-learning-for-software-engineers
• https://github.com/dylanaraps/pure-bash-bible
• https://github.com/EbookFoundation/free-programming-books
• https://github.com/jlevy/the-art-of-command-line/
• https://github.com/kallaway/100-days-of-code/
• https://github.com/kamranahmedse/developer-roadmap/
• https://github.com/nvie/git-toolbelt/
• https://github.com/Dhghomon/easy_rust
• https://github.com/danielfm/prometheus-for-developers
• https://github.com/aspittel/coding-cheat-sheets
• https://github.com/cjbarber/ToolsOfTheTrade
• https://github.com/tiimgreen/github-cheat-sheet

Special mention: https://learn-anything.xyz/

Turns out Auth0 has pretty sweet pricing.

The free plan allows 7k users, social connections and passwordless connections among other things.

Worth considering for side-projects.

Curious about which processes on your system are taking up bulk of the bandwidth?

Well then, Bandwhich is for you!

A nifty CLI app that does one thing well 💯

Note: On macOS you need to run it as sudo

Given that most of the content I write is in markdown, and is rendered via Hugo in most cases - both personal & work, it made sense to develop a simple system which works with any hugo site.

Here’s a simple shortcode that one can add to their static site, and inject n number of spaces, in a clean fashion.

Save this as ./layouts/partials/space.html in your hugo repository.

Now you can add 10 spaces by adding {{< space 10 >}} in your markdown file.

Example

"As that I can see no way out but through"

{{< space 50 >}} -- Robert Frost

would be rendered as:

"As that I can see no way out but through"

                                                  
 -- Robert Frost

and would appear as:

“As that I can see no way out but through”

                                                   – Robert Frost

Bonus

Adding {{< space 1 >}} in a new line, will add an empty line. No more <br> tags!

Text above

{{< space 1 >}}

Text below

and would appear as:

Text above

Text below

Link to Wikipedia

I didn’t know of this word, and it sounds amazing! I think next time I have a project around documentation or writing of another kind, I’ll probably name my repository Apocrypha.

Basically git reset --hard <initial commit hash> for twitter, and re-writing all the code once again.

Why?

This idea (like most good ones) wasn’t mine. I had a faint recollection of @anildash doing this couple of years ago.

I used to spend a great deal of time on this codebase(twitter). Back in the pre-COVID era, when we used to work out of offices, I’d rarely open twitter during the day, given that some or the other person would be staring at my screen. With COVID-19 that was no longer the case, and the duration of my sessions on twitter soared.

Time spent on twitter depends on the volume of content available. This is usually a factor of the number of accounts you follow, and the average number of tweets each account usually posts. At the time I was considering the reset, I was following 883 accounts. LOT of content!

Lately my experience interacting with twitter was largely unpleasant. The only options seem to be - Refactor or Rewrite. I often found myself consuming content that doesn’t resonate with me. Perhaps a past version of me preferred that content. Perhaps he didn’t know better.

Why not refactor?

While debugging and analyzing the root cause is always an option, the fundamental design is in question here. I’m wiser (well, less stupid) than I was 8 years ago, when I created my account. Simply put the code quality is going to be better.

Usually the major concern when doing a complete overhaul is - Time. The new codebase tends to takes substantially more time that originally anticipated. Something I learned the hard way - several times! Well, given that I end up scrolling through my timeline for an obscenely large amount of time anyway, not much to lose 🙃

Also the overall size & complexity of this particular codebase isn’t particularly daunting. Putting aside the code metaphor for a minute, humans & human interactions are far more complex than any codebase I’ve come across (yet). There are people I followed as a naive kid, as a fan boy, as an obligation, out of courtesy, or a combination of the above.

There are people in my list, whom I haven’t interacted in ages, people I’ve long forgotten, people whose values I no longer share. Holding onto remnants of relations that once were, does no good to anyone. Yet another thing I learned the hard way. Sigh.

The above goes for all accounts of organizations as well. Groups I no longer identify with, Bots RTing content I no longer care about, random blasts of suspicious news and whatnot.

What about lost connections?

Given how polarizing twitter can be, it’s highly likely that I’ll find my way back to many of the same accounts I currently interact with. Having said that, I believe it’s important to question your beliefs every so often, to re-evaluate yourself, and re-build yourself. While Darwinism emphasizes on the need for change to survive - I believe drastic changes are necessary in order to thrive.

Given that Change is inevitable - one can either proactively forge their path, or accept the path chosen by circumstances. I have trust issues, and expecting The Universe to act in my best interest, usually ends in disappointment & despair. The Universe doesn’t play fair. Best make your move before it does.

Originally posted as a tweetstorm

Absolutely!

If the content I’ve been posting isn’t something you feel like consuming, go ahead and unfollow.

Our paths are likely to meet again at some point 🤞

Should you mute me?

I’d rather you don’t 😅

Feel free to unfollow. Muting closes doors to the possibility of any interaction in future.

Should you follow me?

Give it a shot. Nothing to lose. You can always unfollow 😉

What won’t I post?

Starting quite recently, I refrain from tweeting about politics, religion, or whatever the headlines are saying in any given news cycle.

Twitter has a variety of channels for consuming information pertaining to current affairs - me not retweeting about the numerous social injustices doesn’t mean the information won’t reach the people who need it.

What will I post?

I’m a digital nomad who tends to stumble upon shiny things in the interwebs and is likely to hoard them. I mostly post about such stuff.

Some other topics I tweet about - software development, productivity, mental health, human behaviour, organizational psychology.

Needless to say I do log a lot of my thoughts & life events on twitter. The frequency usually depends on how busy I’ve been at a given point in time.

Why don’t I follow you?

Most likely, recent content of your feed didn’t resonate with me - at the time I last checked.

Why did I unfollow you?

Same as above. Though I’m always open to re-following folks.

Most people in my circle are affiliated in some way with software development. So when a developer friend of mine asked, “What is Meditation?”, I came up with an answer in terminology s/he could grok. Sharing with others, who’ve had similar questions on their mind.

The Context

The brain is an organic computer - equipped with memory, and processing capability. Consciousness is the init process. Every line of thinking is a process forked from your consciousness. Like any other computer, the brain has limited number of cores, thus limited processing power. Some processes can utilise all cores, some can’t. Even if every single process could utilise all cores, you still have limited cores.

At any given moment of time of any waking hour, there are multiple lines of thoughts running in your mind. One thinking about the argument you had yesterday, one wondering where to order lunch from, one focusing on the critical assignment that you must submit by end of the day, one dreading the boring meeting that begins in half an hour and perhaps few more.

Needless to say there are also daemons running, taking care of the mundane functions of moving air, glucose, blood and the likes, in the body.

Now, think of the following scenarios:

What happens when you have too many processes running?

What happens when one process takes too much CPU/RAM?

What happens when you have zombie processes running amok in the machine?

In any of the aforementioned situations, the outcome is on the lines of resource starvation - high priority processes not getting the resources they need, or to put it another way, resources are wasted on processes you don’t even want to run. The best case scenario being sub-optimal performance of the process, and worst case - system crash.

The vicissitudes of life, coupled with the unhealthy lifestyle that has become mainstream, and the urge to run faster on our hamster-wheels in the rat-race, is the psychological equivalent of a fork-bomb. Pointless worries, pitiful misunderstandings, vain desires, blind ambition, and the burden of expectations are nothing but unwanted processes starving your mind. Ability to think, feel & connect are dimmed by greed, envy & lust.

The Solution

Picture yourself staring at a terminal showing you all the processes that are running. What would happen if you saw a random process with an innocuous name hogging 80% CPU? You’d invoke a SIGTERM/SIGKILL. Right?

Meditation is the willful execution of ps aux on your system - observing the processes that are created. When you notice a process that isn’t desired, you hit kill -9. Another random process pops up - again kill -9.

For now your intended processes have ample resources, but what’s to keep another fork bomb from hijacking resources tomorrow? So we must do for our mind, what we do for our servers - we automate! Unfortunately the only thing in human beings that’s even remotely analogous to a cron job is habit. There is no easy way out of this.

Consider doing this exercise of monitoring & eliminating every morning for 10 minutes to begin with. What happens if you meditate for 30 minutes? Well, the probability of unwanted processes cropping up reduces. Simply put, the time you spend on observing & curating your state of mind is inversely proportional to the chances of unwanted thoughts intruding on your consciousness.

Hope this gives you a relatable mental model to grok meditation. Meditation isn’t some Art of Living faff, but a simple straightforward technique to manage your system health. Hope this gives you a relatable mental model to grok meditation. Meditation isn’t some Art of Living faff, but a simple straightforward technique to manage your system health.

Back to browsing twitter. Half a dozen new links from Hacker News since morning - someone deployed something on RaspberryPi, another startup got funding for doing X with Blockchain, yet another flaw found in self-driving cars - the usual stuff.

Wait, what’s that last one - An Interactive Regex Tutorial. Now that I think about it, I have been meaning to hone my regex skills. Click. Ah! swanky UI. Will definitely use this - but later. Too busy right now. Share > Add Tweet to Bookmarks. I’ll come back to it later; at least that’s what I told myself.

Data, data everywhere, not a single drop of peace.

Yet another day in the life of the hoarder; scrounging for knowledge/wisdom/information among the drivel of the interwebs. As much as I’d like to blame technology for my fear of missing out, it was always there. Technology merely provided a channel for my depravities. As I stood leering at the broken beauty of the Internet, the flood-gates opened and out came gushing - everything I thought I wanted; filling my senses to the brim and then some, until I was subsumed by own perversions.

Everyday I found myself bombarded with links. All with the same allure, and similar destinies - either Save to Pocket or Add Bookmark; though most of my usual haunts offered their own versions of the coffers that grew deeper with every link I dropped - Add Tweet to Bookmarks on Twitter, Save post on Facebook, Save to Watch later on Youtube. Even Instagram has a little bookmark button next to each post - what you’re supposed to save it for, is beyond me.

On some good days when I could muster the will to open the pandora’s box, the sheer enormity of my precious hoard would throw me. Until a month ago, I had accrued 9K links on Pocket alone. Rest of the accounts were peanuts compared to it. This was the anxiety inducing behemoth that must be dealt with, in order to make a dent.

“As that I can see no way out but through”
                                                   – Robert Frost

And so I dipped my toes into the golden cesspool. The goal was to bring the number down. I decided to delete as much as possible. My algorithm for curation was simple:

1. Pick the first link in the queue, and read its title.

2. Based on the title decide:

   • Is it something I could’ve used in the last 6 months?

     OR

   • Is it something I’m extremely likely to use in the next 6 months?

3. Delete the link If step 2 yields False.

4. Exit if reached the end of queue, else go to step 1.

This took me a few days, but at the end, I was left with 2K links. Seemed a lot more manageable, compared to its original form. Since then I’ve managed to read tens of links in the queue. Though regrettably I added more than I read, and currently the count has reached 2.9K.

Meh, baby steps.

More importantly I needed a system in place to keep the agents of anarchy at bay. A means to not only distill the knowledge, but also organize it in a secure, searchable & manageable format. A digital Eden where the inherent entropy of the universe can be channeled, without destroying itself. This was a long search in itself, though I did manage to find such a system. More on that in another post soon.

Clean code is simple and direct. Clean code reads like well-written prose.

• Robert C. Martin

While most of us would agree with Uncle Bob, that code should read like well-written prose, we usually fail to achieve it. Being able to write code that reads like well-written prose implies that one is capable of writing decent prose in the first place, which is far from true for most programmers.

Wordsmith, or smith with words

Code, to put it very crudely, is just a bunch of words. So, the pre-requisite for writing beautiful code is to write beautiful words.

In order to write cleaner code, one needs to excel in transcribing their thoughts into the most beautiful & simplistic words possible. This requires a disambiguation of code & prose, both on an individual and organisation level. Code encompasses prose rather than being orthogonal to it.

It’s imperative to understand what beautiful prose is, and be able to truly appreciate well written prose before one can begin to write well worded, meaningful statements that clearly express intent.

Mastering the Ink

Writing well-worded statements is quite literally an art. Excelling in writing, like any other vocation, requires study & practise. Writing a journal or a blog can significantly improve one’s ability to drown out the noise, think clearly, and put those thoughts into succinct, purposeful words.

Reading is part and parcel of writing better. Reading more books/articles/blogs give you insights into the minds of other authors, expose you to new phrases/terms/expressions, and gives you better tools to frame your thoughts.

Novice to Master

While I wish there were simpler ways of improving one’s skillset, the only foreseeable way to be better at writing, and everything else for that matter, is by deliberate practise.

“premature optimization is the root of all evil”

At what point do you really step into the trenches, and dig through your garbled code, which by this point is the direct function of all the accrued technical debt you thought you’ll handle later.

The code speaks

A good time to optimize your code would be when the code tells you. Code that needs optimization would either be slower than expected, or consume absurdly large amounts of processing power or memory.

If you listen hard, you can sometimes hear the screams of the servers echoing in the basement. It’s either that, or the ghost of our last IT guy.

What to optimize?

It’s imperative to keep your instincts aside when deciding which part of code requires optimization. Trust nothing but empirical evidence. The only scientific way to find the root cause of performance blockage is to profile your code. There’s a wide array of profiling tools at one’s disposal in almost every language.

Rules of Optimization:

1. Profile
2. Profile
3. Profile
4. Profile
5. Optimize

Something my mind keeps going back to, is the talk by Sandi Metz mentioning the Null Object design pattern, which stated that null is not nothing, and should be encapsulated accordingly. I wonder if the same applies to our thoughts as well.

What’s the nomenclature for the state when one’s mind is blank, when you are not exactly at peace, but not really thinking of anything. How does one define this null state of the brain. This void, if you will. The agitating nothingness, that drowns in the recursive flood of the unsavoury thought of not having any worthwhile thoughts.

I guess I should stop overthinking it, before I crash with stack overflow.

While a good cup of joe keeps one’s mind active, chugging copious amounts of coffee can wreak havoc on your sleep cycle.

The night of

This project is critical and must be finished tonight.

The deadline is tomorrow morning.

It’s just a one time thing.

One all-nighter is not that big a deal.

Just one more hour, and then I turn off the lights.

All the above are statements we’ve told ourselves at some point of time to convince our mind to push through the night, to fight the good fight against the evil sleep.

Nothing but lies we choose to feed on, as Lucifer’s laughter echoes through the pits of the underworld.

The morning after

You get out of bed, groggy from last night’s gruelling effort, looking for your morning fix of that sweet nectar that shall keep you awake during that ultra-important meeting that you can’t miss.

Few hours have passed, and your mind begins to demand sleep. You silence that weak brain of yours by drowning it in a double-espresso. Ah! Good riddance.

Another hour passes, and the urge to let your eyelids fall, returns. Why though? You just had the elixir of sleeplessness. Perhaps it was too weak. A stronger dose should do the job.

Clock continues to tick away, and your mind keeps swinging from the state of extreme awareness, to zoning out from time to time.

Fatigue kicks in, making yet another argument to lie down and slip into the realm of dreams. Just a few more hours, you think. The day is about to be over.

You reach home with the hopes of finally getting that good sleep you’ve been thinking of all day. Though now that you lie between the sheets, sleep eludes you, perhaps upset that you’ve been avoiding it.

The Regret

As you lay awake cursing that evening coffee, wishing you hadn’t had it, you are torn between your desire to sleep, and your brain’s disapproval of turning off for the night.

You succumb to your mind’s erratic behaviour and close your eyes hoping for the noise to drown, vowing under your breath to not consume so much caffeine in future, knowing fully well, the futility of that promise.

“Source Code Is A Liability, Not An Asset”

These words have been said time and again. I first came across it in Kiran Jonnalagadda’s PyCon India talk.

But why? As I understand it, code requires constant maintenance. It needs to be cared for. It constantly needs to be changed. I needs to be deployed, and then those deployments need to be managed. If by a stroke of luck, you find yourself responsible for a codebase that is happily running in production without any intervention from you, once in a while some massive bug like Spectre or Meltdown would be revealed and you’ll have to upgrade/replace your servers.

Why code?

Code is a necessary evil. We require some kind of interface to interact with the machine. Code is currently the only such medium. So while we can’t stay away from code, we should see it for what it is.

This is applicable in most contexts — including software engineering. While we strive to write ‘good’ code, many of us might be oblivious to what good code should look like.

A major challenge when seeking ‘goodness’ is that it’s hard to visualise and measure. Any goal becomes harder to achieve if one isn’t clear on what the end result is supposed to be.

The Programmer’s Perspective

Imagine writing code without specs/tests. Sounds outrageous, right? The absence of specs implies that we don’t know what we are aiming for. So one can toil endlessly, but the entire endeavour is unlikely to yield any meaningful results.

Now recall the last time you refactored a piece of code. You begin with the aim of improving the code to a somewhat better state. After spending some time on the problem, you could notice significant change in your code. Perhaps you decomposed a method into two, replaced inheritance with delegation, or something else. Whatever it was, it improved the state and appearance of the code, and gave you a momentary feeling of respite.

While working towards something better didn’t take you to the pinnacle, it took you a step forward.

The end of good?

We are certainly not meant to stop chasing good. We only need to have a clear picture of what good is. If ever in doubt, of what good is, seek better. For no step is too small, as long as it moves forward.