Engineering Logs
My technical diary for things I learn while building systems that I think may be useful to other engineers.
How One New Feature in Trypema Turned Into a Major Version Release
How solving persistent monthly rate limits for Celeris led to live reads, safe conditional updates, history preservation, independent providers, and Trypema v2.
On the Topic of Making Simple Useful Things (A Distributed Counter)
Counting things across multiple servers sounds trivial. It is not. A walkthrough of the design space for distributed counters, from atomic Redis scripts to per instance tracking with automatic cleanup of dead instances, and the Rust crate I built to handle all of it.
Why I Built Trypema: Rate Limiting, Rust, and One Stubborn Problem
The story behind Trypema, a Rust rate limiting library I built while solving a real problem, and how I ended up creating a hybrid provider nobody asked for.
How to Implement an In-Memory Rate Limiter in Rust
A step by step approach to implementing an in-memory rate limiter in Rust.
Is Programming Enough? The Tales of a Software Engineer
Exploring the essential soft skills beyond programming that software engineers need to succeed in the business world - from communication and time management to collaboration and problem-solving
Understanding the Client-Server Model in Distributed Computing
Exploring the fundamental architecture in distributed computing that facilitates efficient allocation of tasks and workloads between clients and servers through network communication
Break the Tutorial Trap: How to Become a Better Software Engineer with Projects & Structure
Practical advice for moving beyond tutorial-following by building structured projects that teach real engineering skills.
Error Handling in Rust Where Bugs Go to Take a Vacation
Safeguarding Software Reliability with Rust's Error Handling Mechanisms - exploring Result and Option enums, the ? operator, custom error types, and panic! for robust error management
Overview of Lifetimes in Rust: A Guide for Developers
A comprehensive guide to understanding Rust's lifetime system and how it ensures memory safety without a garbage collector.
Overview of The Proxy Design Pattern
A simplified overview of the proxy design pattern with examples in Java - exploring structural design patterns that provide surrogates or placeholders for other objects
Embracing Perfection: A Journey into Rust Programming
Exploring Rust's core features and concepts that make it a powerful and compelling language for developers seeking memory safety and performance.