How Linux demand-pages memory, what mmap does to physical pages, why replacing a mapping breaks direct memory access and shared memory, and how userfaultfd lets you lazily populate memory without destroying the mapping.

A dive into the spectrum of sandboxing and isolation, from Linux namespaces and gVisor to hardware-enforced microVMs and WebAssembly, and why picking the right boundary matters for multi-tenant workloads.

A look at what Python's GIL is, why it makes thread-based async checkpoint saves counterproductive during PyTorch training, and how process-based async with pinned memory is better

The machines have become powerful enough to write code for us. What does this mean for those of us who love understanding how things work? And how do we keep learning when AI does the heavy lifting?

A simple architecture for BM25 search over object storage using immutable Tantivy shards, stateless indexers and query nodes, and local NVMe caching for sub-second queries.

A personal reflection on Diwali. The festival of lights, the world I grew up in, and choosing light in darker times.

Physically remove rows in Parquet on S3 with MPU + UploadPartCopy, copy-on-write objects, and a tiny CAS head to make it simple, fast, and compliant.

A thought experiment in building Parquet-like columnar table on S3 with row-level deletes using conditional writes, tombstone files, and a single-object transaction pointer.

Moving large JSON payloads from PostgreSQL TOAST tables to Parquet on S3 with deterministic sharding, row-group pruning, and range-based reads for millisecond point lookups.

Eliminating PostgreSQL catalog traversal overhead with local partition calculations for up to 20x faster hash partition queries.

If AI learns from human intelligence, can it ever truly transcend its origins? Is AGI a technical milestone or philosophical mirage?

When LLM models generates clean, professional-looking code, it's tempting to stop exploring alternatives. But therein lies the risks that comes with premature closure. So what is premature closure?

A follow-up exploration into PostgreSQL CTE materialization, diving deeper into why non-idempotent subqueries can execute multiple times, leading to unexpected results.

How a seemingly straightforward DELETE query using a CTE and LIMIT returned more rows than expected due to query planner optimization.

Safely leverage PostgreSQL's asynchronous commit for significant performance gains

While these tools boost productivity, they're not a replacement for critical thinking. Taking the time to understand why something works (or breaks) and building strong mental models isn't just busy work

Practical scaling strategies for application developers who don't have a dedicated database team

Testing against a real database uncovers hidden pitfalls that can appear as the application matures

When dealing with very large PostgreSQL tables (we're talking 15TB+), sometimes routine maintenance like archiving very old data can become surprisingly challenging

This new capability extends PostgreSQL logical replication, enabling DDL tracking and bringing more flexibility to database migrations through pg_easy_replicate

When you use `IF NOT EXISTS` and re-run your index creation, the task can silently complete while leaving behind an invalid index.

The dichotomy between the progressive ethos that once permeated the tech industry and the current political endorsements by its so called elites suggests a community at a crossroads. It beckons a fundamental question: what are the core values we hold dear, and how do they translate into our actions and legacies

pg_easy_replicate is a CLI orchestrator tool that makes the process of setting up and managing logical replication between PostgreSQL databases a breeze.

I explored various approaches and ended up with a worker pool model using a Semaphore, here they are

Have you ever had a brilliant idea that you wanted to act on immediately? We've all been there, and it's tempting to jump right in. But what if I told you there's immense value in simply sitting on an idea?

The urgency often obscures the fact that incidents cause more incidents. Incidents are not isolated events but links in a chain, each capable of setting off a cascade of further issues. The key lies in resisting these impulses, favoring a methodical exploration of safe, effective and reversible solutions.

It's about being agile enough to shift directions based on detailed, early feedback and being fearless in the face of potential failure because every detail examined is a lesson learned.

Imagine looking for a specific book in a library. Reading through books sequentially is like a sequential scan in a database, while jumping directly to the desired book is like a random access. The `random_page_cost` reflects the relative cost of random access compared to sequential access in the database. At a very high level.

It means believing that each member will effectively handle their responsibilities, understanding that collective problem-solving is more powerful when issues arise, and recognizing that fast doesn't equate to reckless.

Foreign keys are a bit like that well-intentioned friend who insists on double-checking everything you do. They’re often recommended as a must-have for enforcing referential integrity checks in your database.

pg-osc is a CLI tool for making non-blocking, zero downtime schema changes in PostgreSQL

Why I enjoy PostgreSQL - Infrastructure Engineer's Perspective

Network failures and especially transient ones, are a given.

One thing I noticed when inspecting signals is that there isn't really an easy way of doing so.