Articles

Transactional Outbox Pattern: Now with Optimistic Sending

4 minute read

The standard transactional outbox pattern ensures consistency but adds latency and load. This article introduces optimistic sending - a simple upgrade that tries to publish events immediately and falls back only if needed. Faster, lighter, just as reliable.

Transactional Outbox Pattern: From Theory to Production

12 minute read

When microservices need to update state and notify others at the same time, it’s easy to run into problems - lost events, race conditions, or partial failures. The transactional outbox pattern offers a practical way to ensure both data and events are handled reliably. This article breaks down how the pattern works, what makes it production-ready, and where things can go wrong.

Rendezvous Hashing: Peer-to-Peer Approach to Distributed Caching in .NET

15 minute read

Discover how to leverage rendezvous hashing to create a peer-to-peer caching layer for your .NET service running in Kubernetes - eliminating the need for external cache services while efficiently distributing data for improved performance and resource utilization

Practical Functional Programming in C#: Using Option and Result Patterns

7 minute read

Discover how to leverage functional programming patterns in C# to write more maintainable and error-resistant code. Learn practical applications of Option and Result types using Language.Ext, moving beyond null checks and exception handling to create more explicit and safer code without sacrificing readability.

Universal Scalability Law

5 minute read

Ever wonder why doubling database server’s CPU cores doesn’t double performance? Through real-world AWS RDS benchmarks, we’ll explore the Universal Scalability Law and learn why throwing more hardware at performance problems isn’t always the answer. Tests with RDS instances revealed some surprising patterns that might change how you approach your next capacity planning meeting.

Rounding Numbers: There’s More Than One Right Answer

2 minute read

Programming languages often use banker’s rounding - rounding to the nearest even digit - which means 1.25 becomes 1.2 while 1.35 becomes 1.4, contradicting the familiar rule of always rounding 5 up

Capacity Planning: Understanding the 80% Server Utilization Rule

5 minute read

Why there is a recommendation of keeping server utilization below 80%? Using basic queueing theory, we explore how request latency grows exponentially as servers get busier, and why modern autoscaling systems trigger even earlier at 60-70%.

Luhn Algorithm: Credit Card Number Validation in Nanoseconds

5 minute read

Ever mistyped your credit card number and gotten an instant error? That split-second check isn’t database magic - it’s clever 1950s math that catches typos faster than you can blink. From credit cards to ISBNs, this elegant checksum algorithm silently guards against human error millions of times each day.

Rendezvous Hashing: The Path to Faster Hashes Calculation

10 minute read

Examines how to optimize compute complexity of Rendezvous hashing. Explores different approaches to make the process more computationally efficient while maintaining fair data distribution, ultimately proposing an improved method that significantly reduces processing overhead.

Recursive vs. Iterative DFS: A Performance Surprise

16 minute read

Exploration of DFS implementation performance across various binary tree structures. Article challenges common assumptions about recursion and iteration, showing surprising insights into how tree characteristics and CPU optimizations influence implementation performance.

BDD: Behind the scenes (Part 2)

11 minute read

In Part 2 of BDD series, we dive into a practical example using a simple ToDo application. We explore the implementation of BDD tests using Python, Behave, and Selenium, demonstrating how to structure a BDD project, write Gherkin scenarios, create step definitions, and implement Page Objects. The article covers key components like hooks, service registry, application controller, and WebDriver factory, providing insights into best practices for BDD implementation in web application testing.

BDD: Behind the scenes (Part 1)

11 minute read

Behavior-Driven Development (BDD) is an agile software development process that enhances collaboration between technical and non-technical team members. It focuses on defining application behavior through universally understandable examples, improving communication and shared understanding of project goals. This article explores BDD for web applications using Python, covering key components like Gherkin, Cucumber/Behave, Selenium, and Docker.

Welcome to My Blog

less than 1 minute read

Welcome to the first post on my blog. Stay tuned for more content!