Killing a PostgreSQL Connection

Let’s kill a PG connection

PostgreSQL Schemas: Namespacing for Objects

For organizing objects in your DB, or setting up multi-tenancy

PostgreSQL: Create a Read-only User/Group

Let’s create a read only group in PG and add users to it

LRU vs FIFO (with Lazy Promotion and Quick Demotion)

Sprinkling some lazy promotion and quick demotion on FIFO

Notes on 'A large scale analysis of hundreds of in-memory cache clusters at Twitter'

TTLs are prevalent, object sizes are small, metadata overhead can be large, object sizes change, FIFO is better than LRU, you’ve got to address memory fragmentation

Tiered Storage via 2-Tree

Split a data-structure into two: a memory-optimized ’top’-tree and a disk optimized ‘bottom’-tree. Implement a lightweight migration protocol for hot records to move up and cold records down.

Pointer Swizzling Buffer Pools

Switching pointers as the data pointed to moves to and fro memory and secondary storage

Compacting Transactional Data in HyPer

Keep hot tuples uncompressed, organize cold data into chunks of columns then use lightweight compression, handle both OLTP and OLAP workloads

Virtual Memory Hot/Cold Data Re-organization for OLTP

Hot/Cold aware memory allocation with locking of the hot region to physical memory and letting the OS swap out cold LRU pages as needed.

Offline (but Faster and more Accurate) Classification of Hot and Cold Data

Hint, it’s based on exponential smoothing

Anti-Caching

Track hot/cold data at tuple-level granularity. Evict LRU cold data in blocks.

Programmatically creating a DuckDB table from an Arrow schema

PyArrow lets you create an empty table. Use that instead of custom mappings to create a DuckDB schema.

Handling panics from goroutines you've spawned

It’s one thing to handle a panic that’s occured within a function. It’s an entirely different affair to handle a panic that occured within a goroutine that’s been spawned.

Benchmarking SQLite inserts

Going from 750 writes per second to 25,0000 with a bit of configuring

Getting started with TLA+

End-to-End Arguments in System Design

Paper Review

Distributed Reference Counting

Malloc excess bytes

Space requested from malloc is a lower bound (at least or more)

Go data-structure tricks: google/Btree

A couple of interesting approaches to concurrency and memory allocation from the Go google/btree package

Speeding up unique constraint checks in PostgreSQL... or not

Are exclusion constraints using hash indexes faster than plain old uniqueness checks? Let’s find out

SQL gotcha: now() vs 'now'

Make sure you’re using the correct defaults when defining columns

Bugs From ignoring C Operator Associativity

Mistakes were made

Go Channels Suffice for Synchronization

Or how to implement Futures/Promises in Go without having to juggle locks and waitgroups

Golang Custom Loggers: using Postgres and Leveldb

Coupling logging to the some destination (in this case Postgres and leveldb) within the application itself isn’t by any means a good idea. Still, given the flexibility interfaces in Go provide, why not give it a try ¯\(ツ)/¯

Handling Bank Transactions, V2

Version 2 of a simplified Node.js-based API + PG database layer for handling a bank’s intra-account transfer operations

Handling Bank Transactions, V1

Overview of a simplified Node.js-based API + Postgres database layer for handling a bank’s intra-account transfer operations

Var, Let, Const and the 'commonly' expected behaviour

Javascript quirks and idiosyncracies. Or why learning a new programming language is hard when coming in with implicit assumptions from other languages

PG Transactions & Isolation levels: Airline Seat Booking

Using the right isolation level to avoid nasty billing errors when building database-managed booking systems

Logging with trace IDs in Node.js - pino, express and cls-hooked

A neat way to add tracing or transaction ids for each request-response cycle with as little modification to the rest of the code as possible

Programming Pearls - Array Rotation

Programming, Pearls and a couple of interesting solutions for rotating elements within an array