Some thoughts about things I have worked on or I am interested in.

Remember to treat everytinhg you read in the internet with a grain of salt.

Add context to errors

It is Friday evening. Bob just wants to wrap up the small bug fix in the service developed by his team, be done for the week, and pack up for his weekend trip. Bob is tired but determined. He quickly glances through the code, it is nice and readable, so with a quick search, and a few jumps to definition, he finds the suspect. He shoots a few lines of code before asking any questions, and… Done!

Implementing Practical Byzantine Fault Tolerance - Part 3

Part 3: Protocol Implementation This is the final part of my brief description of pBFT protocol implementation. The first one gave a general overview of the protocol, and the second one covered a high-level view of the project and its different parts. In this one, we are going to take a very quick tour of the normal case implementation and look more closely at view changes. Normal Case Operations I have covered more important parts of normal case operations in part one together with a handy diagram featured in the paper, and the code for the majority of that is fairly simple.

Implementing Practical Byzantine Fault Tolerance - Part 2

Part 2: Implementation Overview This is the second part of the article describing a learning implementation of Practical Byzantine Fault Tolerance Algorithm. In the first part I gave a general overview of the protocol, and how it unfolds for the base case. As it turns out, implementing pBFT even for non-production scenarios is not a one-evening project. This post outlines the assumptions, and decisions I have made for the implementation, together with the general structure of the project and some more interesting parts.

Implementing Practical Byzantine Fault Tolerance - Part 1

Part 1: The Foundation Practical Byzantine Fault Tolerance is one of the seminal papers in the world of Distributed Systems. It is one of the first practical solutions proposed to the Byzantine Fault Problem (also known as the Byzantine Generals problem). NOTE: To keep this post focused instead of describing everything from the ground up I will assume readers’ familiarity with some of those base concepts, or being comfortable to move on despite not knowing them.

Single syscall "Hello, world" - in Rust - part 2

… or There and Back Again Returning to Rust As in every hero’s journey, after gaining the wisdom of the gods, the hero shall bring it back to his roots. If we squint our eyes a bit, that is (kind of) what we are going to do. Our exploration in the previous post revealed some suspects that blow up our syscalls count in a simple “Hello, world” Rust application, those are:

Single syscall "Hello, world" - part 1

“Hello World” is the first program of many. Regardless of the programming language, we are learning it is a canonical example of how to create a program that simply prints “Hello, world!” to the screen. One might then ask, how complex it really is? After all, it is just a single write(2) syscall, right? NOTE: This post refers specifically to Linux, as I will use some Linux-only tools. The basics For the purpose of my “Hello, world” I want to use Rust.