Simple and highly relevant #cleancode principles: - Write code that's easy to delete. Instead of aiming to write permanent code, write code that is easy to "throw away". This mindset forces you to build small, decoupled modules with minimal dependencies. - Don't Repeat

Just hit version 36.0 today 🎂 - Improved Dad jokes - Lighter - Resilient to failures

This post from Kaivalya Apte - The Geek Narrator about software performance optimization is so good! 🏆 How would you apply these principles to your GitHub Actions workflows?

In case you don't know The GeekNarrator podcast is also available on other channels: creators.spotify.com/pod/profile/ka… you can watch/listen all the episodes here and spread some love.

Most system design (and interviews) are bombed because of a mix of the following: - No clarification questions - Biased and false assumptions - Lack of customer/user empathy - Trying to focus only on technical aspects - Trying to align with theoretical concepts and leaving

Databases are simple….. You only need to: - Use proper indexing (avoid over and under indexing) - Use proper data types - Optimise queries - Set up read replicas - Manage spiky data volumes - Handle transactions and concurrency - Manage security and access policies -

A gentle reminder and positive life hack: It’s better to block, unfollow, unsubscribe than to spread hate and bring your own state of mind to the lowest and meanest possible state imaginable. You are not that. You are better. (Not only for social media)

Similarly, I feel coding with Agentic-AI makes achieving mental flow, like we did coding "alone", very hard if not impossible. Its a complete mental shift. While output has increased, I'm still doubtful about the overall outcome.

The solution is less important than: - the way you reached the solution - the thought process you developed - the questions you asked to define the problem - the assumptions you validated along the way - the tradeoffs you made - the limitations you discovered - the discussions

Multithreading in OCaml 🙈

After a break, I am back with new episodes :) Soon bringing following amazing folks and topics: - Philipp Fent to talk about CedarDB - social:x#tweet@user:jimmy to talk about authzed - Ian Eyberg to talk about NanoVMs Super interesting technologies! Stay tuned!

Joran Dirk Greef IIUC, BloomFilters are mainly used to avoid doing the work, ex. In LSM to reduce the SST search space. With the improvements in performance of memory, network and disk the following may become true? “overhead of avoiding work” = “doing the work” Bloomfilters may be removed,

Kaivalya Apte - The Geek Narrator Nailed it. The other angle is that LSMs are typically used for write-heavy workloads, and also with some degree of write amplification from compaction across multiple levels, each time recreating bloom filters multiple times, but not always using them. This means the

Joran Dirk Greef Kaivalya Apte - The Geek Narrator It's like a cache which keep on getting evicted, defeating the whole purpose of caching

Kaivalya Apte - The Geek Narrator Both write and read paths (as explained) became faster/simpler for (most) workloads. We often assume in industry (almost as a mantra) that “engineering is tradeoffs” but I think our mental models can more often shift to a global maxima (or “superidea” per early Nintendo

“Design a unique ID generator” If you have started thinking about the design right away without understanding the problem first, your design will be aligned with only “your mental model”. What questions would you ask to define the problem? Comment below 👇