A straightforward explanation of Paxos using a simple Python Flask HTTP implementation to show how distributed systems achieve consensus in the presence of faults.

Continue reading

A deep dive into how to structure a marketing measurement and experimentation framework — from universal control groups and campaign holdouts to attribution windows, outlier handling, and statistical rigor. Based on lessons from building a real-world policy for large-scale marketing analytics.

Continue reading

I explore several points that are rarely explained in Modern Monetary Theory narratives: from taxation in non-tax economies to central bank independence, inflation targets, and the many forms of money that exist beyond government spending. These are areas where the story of MMT could be told more completely.

Continue reading

I argue that widely used digital infrastructure like operating systems, compilers and browsers deserve public investment, just like roads, hospitals, and schools.

Continue reading

This article explains how Practical Byzantine Fault Tolerance (PBFT) builds on Lamport’s theoretical consensus algorithms by introducing leaders, quorums, and cryptographic optimizations to make Byzantine consensus practical, contrasts it with Paxos and crash-fault tolerance, and explores its influence on modern blockchain protocols.

Continue reading

This article, following Lamport's work, extends the original Byzantine Generals algorithm from “oral-messages” to signed messages, showing how digital signatures drastically simplify the problem and reduce message complexity, with an implementation given in Python using Flask HTTP nodes.

Continue reading

This article examines where Lamport's original oral-messages Byzantine Generals algorithm does and does not apply in practice, contrasting unsuitable cases like distributed databases and rocket launches with a suitable case in redundant flight control systems.

Continue reading

This follow-up factors Lamport’s Byzantine Generals algorithm into a generalized class that's independent of I/O and payloads. Any node can initiate a round (be "king"), values can be arbitrary strings, and multiple rounds can run concurrently.

Continue reading

I discuss Lamport's Byzantine Generals problem and why it requires a total of N≥3M+1 nodes with M malicious nodes, and then implement the solution using Python with HTTP Flask servers.

Continue reading

This post shows how to implement the Ricart–Agrawala Distributed Mutual Exclusion algorithm with Lamport's logical clocks using HTTP Flask servers.

Continue reading

This post shows how to implement Lamport’s Bakery algorithm with Python HTTP Flask servers. The Python code is short and readable, helping newcomers grasp the algorithm’s logic without the syntactic overhead of C++. The asynchronous HTTP flow also generates plenty of overlap between workers, so the need for mutual exclusion is obvious. Exposing the variables through REST endpoints enables observation of ticket picking and critical section entry in real time, potentially making the flow of the algorithm easier to understand.

Continue reading

I explore Lamport’s Bakery algorithm and show how a naive C++20 implementation breaks on weak memory models, how to fix it with std::atomic, and how to implement bounded tickets.

Continue reading

Andrej Karpathy says we’re marching from hand-written “Software 1.0” to NN-driven “2.0” and, finally, LLM-powered “3.0.” In my view, neural nets haven’t eaten deterministic code—kernels, browsers, games, and most business logic still run old-school. What has changed is the supply chain: LLM co-pilots (“Software 1.5”) already touch nearly every commit, nudging us towards language and architectures that LLMs are good at. The future belongs to teams that harness those co-pilots while keeping humans firmly on the trigger.

Continue reading

I summarize thoughts and lessons learned of implementing the same async message queue server in C++, Python and JavaScript over the past 2 years.

Continue reading

I write the final version of the async message queue server in modern C++20, wire compatible with the Python and Javascript versions.

Continue reading

A visual and analytical walk from pure white noise to a true random walk.

Continue reading

The article examines how simple autoregressive stochastic processes behave with the Dickey-Fuller test.

Continue reading

This post explores how to use the Dickey–Fuller test to check the random‑walk hypothesis for time series using a pure NumPy implementation, and using Monte Carlo simulations to compute critical‑value tables.

Continue reading

In this follow-up, I analyze 10 years of data on a select group of stocks to show that while higher take-profit and stop-loss thresholds boost win ratios and Sharpe ratios, longer holding times can lower annualized returns.

Continue reading

In this article, I explore how adopting longer-term, resilient trading strategies with higher take-profit and stop-loss thresholds can deliver more consistent, risk-adjusted performance.

Continue reading