NULL BITMAP by Justin Jaffray

Programming note; this is the 150th issue of NULL BITMAP, and NULL BITMAP will be going on a hiatus for a while, maybe just for the Summer, maybe indefinitely.

Much like everyone else who wants to engage as little as possible with "here are some effective threats to make the computer do what you want" while still learning about exciting new computer things, I have been learning how to use Jujutsu.

I might have mentioned before that I've been slowly working through the Simple tutorial for building a Sea of Nodes compiler.

LangChain recently posted about a database they built.

I have been tinkering with a little tactics game not so different from Fire Emblem.

I have been tinkering with non-database stuff recently and I don't really have any of it in a place to share something fun about.

I had a picnic this weekend and at it I gave Phil a pen plot that I had been meaning to for a while: I want to explain it here because I think it's cool!

I have long thought of the hash join/merge join duopoly as reflective of the fundamental truth that basically all data-processing related algorithms are based on either hashing or sorting.

I've been reflecting a bit on my philosophy of learning stuff.

I used to have this thought that optimizations in compilers and databases were a bit of a bandaid to badly-written code or something.

Something I didn't understand for a while is that the process of turning row-oriented data into column-oriented data isn't a totally bespoke, foreign concept in the realm of databases.

We talk here sometimes about how to test SQL dialects with tools like TLP and PQS.

I love sampling algorithms.

Every time I have ever explained the Boyer-Moore majority element algorithm to someone, people have reliably found it very charming.

We love generative testing in the world of query languages, because languages in general are in a lot of ways, too complex to test by hand.

I've liked Cryptic Crosswords...somewhat.

Last week we simulated a queueing algorithm.

I read a great post this week from Marc Brooker: SFQ: Simple, Stateless, Stochastic Fairness.

We talked a couple issues ago about the application of Linearity of Expectation to building intuition about Copysets, and the ways that we're both constrained and freed by the laws of probability.

My friend taught me a really funny parsing algorithm this week and sent me Operator precedence by textual substitution.

That expectation is linear is one of my favourite facts.

I was going through the list of CIDR papers this year and looking for ones that were relevant to my interests.

That's right, we're back to the world of databases.

Last week I talked about my forays into Compiler Construction (1996).

Something I believe wholeheartedly is that writing simple little programs is good, and writing the same simple little programs many times is even better.

I recently came across a cute game called https://enclose.horse.

This is the last NULL BITMAP of the year.

I am busy with holiday stuff so this post is a little bit half-baked.

Last week we talked about the different ways we can decompose a simple predicate which is a conjunction of two simpler predicates.

One of the fundamental things that query planners have to do is decompose predicates.