Shai Asher

The cache was working perfectly. That was the problem.

Sun, 06 Sep 2026 09:00:00 +0300

02:47

Falafel Corp runs a one-person on-call rotation, which is a staffing decision that looks efficient right up until the night it isn’t. Tonight it is your turn, and the phone goes off on the nightstand, and you are awake before you are conscious.

The Bloom Filter Optimization Saga: The "Benign" Read That Wasn't

Sat, 05 Sep 2026 14:46:43 +0000

A Go Concurrency And Memory Model Deep Dive

In software engineering, some of the most insidious bugs are the ones that hide behind correct-looking code. This is a war story about a data race that slipped into a highly optimized, “thread-safe” Go Bloom filter. It’s a practical lesson in humility and a reminder that when it comes to concurrency, the Go race detector is the ultimate arbiter of truth.

Finding Errors in Log Streams

Sat, 05 Sep 2026 12:00:00 +0300

Two questions come up constantly when processing large log files:

Where is the 1000th error?

How many errors happened before this timestamp?

They look trivial. At scale they are not. The obvious implementation scans the whole dataset for every question, and with ten million entries that is ten million comparisons to answer one of them.

The Bloom Filter Optimization Saga: A Deep Dive into Go Assembly and AVX2

Mon, 10 Nov 2025 11:18:02 +0000

If you’ve ever wondered how high-performance Go programs achieve their incredible speeds, the answer often lies hidden just beneath the surface, in files exactly like avx2.s. This file is a fascinating example of targeted, low-level optimization.

So, let’s break down what this code does, why it exists, and how it works its magic.

The Bloom Filter Optimization Saga: Anatomy of a Go Concurrency Bug - Part 2

Thu, 06 Nov 2025 19:16:25 +0000

Final Optimization: Solving the 10x Performance Hit

This brings us to the performance report. We have successfully achieved a fully thread-safe implementation, but at a high cost. The performance results file shows a catastrophic 8-12x performance regression.

The Root Cause: The bottleneck is not the sync.Pool and not the atomic operations. It is the fix for Race #2: positions := make([]uint64, bf.hashCount)

The Bloom Filter Optimization Saga: Anatomy of a Go Concurrency Bug - Part 1

Sun, 02 Nov 2025 19:27:14 +0000

Github Project : https://github.com/shaia/BloomFilter

When ‘Read’ Operations Mutate State

I recently investigated a critical bug in theBloomFilter package that was causing panics under concurrent use. Thebloomfilter_concurrent_test.go file said it all: every test was skipped, citing a “nil pointer dereference in storage layer”.

The Bloom Filter Optimization Saga: From 3 Seconds to 66 Microseconds

Thu, 30 Oct 2025 19:13:00 +0000

Building high-performance libraries often involves more than just clever algorithms. It’s a journey of measurement, discovery, and sometimes, learning that your “obvious” fix made things worse. Go SIMD-Optimized Bloom Filter, which you can read all about here, is a project that started with a 4x SIMD speedup and ended with a 6,595x overall speedup after a deep dive into Go’s profiling tools.

The most profound rules of software development.

Tue, 14 Oct 2025 08:37:55 +0000

Category 1: On System Evolution & Complexity

These laws describe the inherent nature of how software systems behave over time. They are not rules to follow but truths to accept and manage.

1. Gall’s Law: A complex system that works is invariably found to have evolved from a simple system that worked.

CFD - Part 1

Sun, 28 Sep 2025 08:42:09 +0000

CFD Flow Animation

In a previous post, we discussed the Navier-Stokes equations, which govern the behavior of fluids.

What is CFD? A Broader Perspective

Computational Fluid Dynamics (CFD) is a branch of fluid mechanics that uses numerical analysis and algorithms to solve and simulate problems involving fluid flows. It lies at the intersection of physics, mathematics, and computer science. At its heart, CFD is about translating the laws of nature — encapsulated in partial differential equations (PDEs) — into something a computer can solve.

The Equations of Everything That Flows

Thu, 25 Sep 2025 08:07:34 +0000

Fluids are everywhere. Air rushes past airplane wings, rivers bend and twist through valleys, smoke curls lazily from a candle, and blood flows through our veins. These are all examples of matter in motion—continuous, smooth, impossible to pin down to just a handful of particles.

SIMD-Optimized Bloom Filter in Go: An In-Depth Exploration

Mon, 22 Sep 2025 07:03:20 +0000

Project Repository: https://github.com/shaia/BloomFilter

From Go to Assembly

When we think of Go, we think of concurrency, simplicity, and “good enough” performance. But what happens when “good enough” isn’t good enough? What happens when you need to squeeze every last drop of performance out of the CPU for a critical, hot-path operation?

Solving the Pandigital Puzzle with AVX2 SIMD Acceleration.

Mon, 21 Jul 2025 12:53:38 +0000

Using AVX2 SIMD instructions in C++ to accelerate the search for the largest 1-9 pandigital concatenated product.

If you’ve ever tackled Project Euler Problem 38, you’re likely familiar with the hunt for the largest 1-to-9 pandigital number that can be formed by concatenating the product of an integer with (1, 2, ..., n).

Solving Project Euler 38 with MATLAB: The Vectorized Pandigital Blitz

Sun, 20 Jul 2025 19:19:31 +0000

This post is part of a multi-language series exploring the problem of finding the largest 1–9 pandigital concatenated product. Check out the C# and Python editions too.

Why MATLAB?

MATLAB might not be the first language that comes to mind for algorithmic problem solving, but its strength in matrix manipulation and vectorized computation makes it a powerful ally for concise, high-performance numeric routines.

Solving Pandigital Multiples with C# and Length‑Based Pruning

Sun, 20 Jul 2025 18:54:33 +0000

In this post, we’ll explore a C# implementation that finds the largest 1–9 pandigital concatenated product by mathematically pruning the search space based on digit lengths, rather than brute-forcing all possibilities.

1. The Pandigital Multiples Problem Recap

We seek the maximum 9‑digit number formed by concatenating the products:

Optimizing Pandigital Multiples in Python

Sun, 20 Jul 2025 18:53:29 +0000

In this follow-up post, we’ll transform our straightforward brute-force solution into a lean, mean, Pythonic machine, avoiding strings, pruning early, and utilizing bitmasks and vectorized data structures for clarity and speed.

1. Integer‑Only Concatenation

Instead of building a string, we’ll assemble the concatenated product as an integer. We keep track of:

Programmatically Finding Pandigital Multiples

Sun, 20 Jul 2025 16:41:53 +0000

In this post we’ll go step by step through a clear, Python-based approach to solve the “concatenated pandigital multiples” problem. We’ll explain each part in simple terms, provide complete code examples, and ensure every detail is fully understandable—even if you’re new to programming.

Project Euler 38: Solving with Pen and Paper Like It’s 1899 🖊️

Sun, 20 Jul 2025 16:40:36 +0000

In the age of compilers and cloud computing, it’s easy to forget how powerful logic and a pencil can be. Project Euler Problem 38 — finding the largest 1 to 9 pandigital number formed as a concatenated product — is typically solved with code. But what if we couldn’t code it? Could we solve it by Hand?

The Fascinating World of Pandigital Multiples

Sun, 13 Jul 2025 18:17:04 +0000

Ever wondered how numbers can combine in surprising ways to reveal hidden patterns? Welcome to the story of pandigital multiples—a playful intersection of arithmetic and puzzling beauty that anyone can appreciate.

What Are Pandigital Numbers?

Pandigital simply means a number that uses each of the digits from 1 through 9 exactly once.
For example, 123456789 and 918273645 are both 1–9 pandigital: they contain each digit without repeating or skipping.

Why does this matter? Pandigital numbers are like a perfect sudoku row: every piece in place, no duplication, a self-contained harmony of digits.

About Slow Is Smooth

Sat, 12 Jul 2025 01:21:03 +0000

I’m Shai Asher. I write systems code — mostly Go, C and C++, and assembly for the stretches where the compiler and I disagree about something measurable.

This site is where that work gets written down. Not the tidied version: the one with the measurements still in it, including the measurements that said I was wrong.