Apache DataFusion is one of the most capable query engines available today — but until now, .NET developers had no way to use it. DataFusionSharp bridges that gap with idiomatic C# bindings built on Rust FFI and Apache Arrow.
A practical exploration of how restructuring array accesses in C++ can help compilers generate vectorized code that’s 2x faster, with detailed assembly analysis of bitpacking implementations.
Deploy .NET Aspire applications to AWS without maintaining separate infrastructure code. One C# project switches between local emulation and production. Aspire handles orchestration, AWS CDK handles provisioning.
Stop paying for AWS services during development or fighting over shared dev environments. Here’s how to use LocalStack with .NET Aspire to develop against AWS services locally, with automatic configuration injection that makes the same code work in development and production.
When stakeholders need software project estimates but you only have vague requirements, single-point estimates are useless. Using PERT estimation and statistical confidence levels, you can quantify uncertainty and give decision-makers the information they actually need.
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.
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.
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
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.
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.
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
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%.
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.
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.
C# async exception handling exhibits different behaviors based on method signatures. Article describes how ‘async void’ and ‘async Task’ handle exceptions when a method throws an exception.
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.
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.
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 the first post on my blog. Stay tuned for more content!