Software Engineering on Kianoosh's Blog

TypeScript: The Illusion of Structure

Fri, 13 Feb 2026 00:00:00 +0000

It’s been around seven years since I started coding with JavaScript, and for the last two years I’ve been working almost exclusively with TypeScript for backend development. Sometimes relationships just don’t work out — and I’m starting to feel that JavaScript and TypeScript are simply not a good fit for backend systems when projects become serious and complex 🔒

As soon as you try to do anything non-trivial with your ORM, things start getting messy — and it doesn’t really matter whether you’re using TypeORM or Prisma. The moment you need “ORM magic” like sharing transactions across repositories, handling nested soft deletes, or coordinating complex lifecycle behavior, you find yourself fighting the abstractions rather than benefiting from them.

Software Modularity: Trivial Concept, Yet Still Rarely Done Right!

Wed, 07 Jan 2026 00:00:00 +0000

If you’ve ever read any software engineering blog or book, you’ve probably seen the word “Modularity” mentioned many times. But ask most engineers what modularity really means, what benefits it brings, and how to actually break a system into modules — and you’ll often get vague or unclear answers.

To find clear and timeless answers, we need to go back to the 1960s and 70s, when these ideas were first introduced and refined. In his famous 1972 paper (over 8,000 citations and still cited 250+ times in 2025!), David Parnas tackled a problem that was unsolved until then: the criteria for decomposing software into modules.

Engineering for Exabytes: Lessons from IBM COS

Mon, 29 Dec 2025 00:00:00 +0000

Beyond Standard Storage

After my last post on the MinIO shift, I started going down the rabbit hole. We often take object storage for granted, but when you step back and ask, “How do you actually manage data at an Exabyte scale?”, the answers get fascinating.

How do you design a system that reaches 15-nines of durability without bankrupting the company on hardware?

I recently found an IBM Redpaper on their Cloud Object Storage (COS) that peels back the layers. It explains the engineering choices required to operate at that magnitude.

Open Source is Not Enough: The Post-MinIO Era

Sun, 28 Dec 2025 00:00:00 +0000

The End of the “Default” Choice

For years, MinIO has been the reflex choice for S3-compatible object storage in Kubernetes setups, SaaS platforms, and data lakes. It was the standard we all reached for.

However, recently (December 3, 2025), the landscape shifted. MinIO officially moved into maintenance mode. This means no new features and, critically, community pull requests are no longer being merged. The development focus has shifted entirely to their commercial offerings.

The Maintenance Cliff: LLMs and the Learning Loop

Thu, 25 Dec 2025 00:00:00 +0000

The Assembly Line Fallacy

In our industry, there is a persistent temptation to treat software engineering like an assembly line. We constantly aim to abstract work into higher-level languages, reusable components, and “black box” services to increase velocity.

In a recent article on MartinFowler.com, Unmesh Joshi critiques this tendency. He argues that this efficiency-obsessed approach clashes with the most fundamental property of our work: learning.

When we rely entirely on readymade solutions without understanding the “why” and “how” underneath, we treat code as a static asset rather than a dynamic expression of knowledge.

Discipline Under Pressure: Shipping Without Messing Up

Wed, 20 Aug 2025 00:00:00 +0000

The Reality of Urgency in Startups

It’s crucial for every senior software engineer, technical leader, or anyone accountable for delivering technical solutions to know how to handle urgent tasks wisely. Let’s call this person a leader — and today, that’s you.

In some industries, or at certain stages of a company’s lifecycle, urgent requirements hit technical teams constantly. I currently work as a technical lead at a startup (Done), where the rules of the game seem to change every other week.