When I Realized We Were Throwing Away Half Our Engine’s Potential

当我意识到我们浪费了引擎一半的潜力时

The Problem We Were Actually Solving As I dug deeper into the requirements, I realized that we were trying to optimize for speed and responsiveness at the expense of something far more critical: configurability. Our initial design assumed that the rules engine would be fixed, and any changes would be manually implemented by a core team member. But in reality, our clients wanted to be able to tweak the engine in real-time, without requiring additional engineering work. The catch was that we’d already committed to a fixed architecture, which meant that minor changes would compound quickly and become showstoppers.

我们真正要解决的问题 随着我深入研究需求，我意识到我们为了追求速度和响应能力，却牺牲了一个更为关键的因素：可配置性。我们最初的设计假设规则引擎是固定的，任何变更都将由核心团队成员手动实现。但实际上，客户希望能够实时调整引擎，而无需额外的工程投入。问题在于，我们已经采用了固定的架构，这意味着微小的改动会迅速累积，最终成为阻碍项目进展的“拦路虎”。

What We Tried First (And Why It Failed) We tried to implement a bespoke, monolithic rules engine using a popular high-level language. The codebase grew rapidly, and performance began to tank. Our initial benchmarks showed a 50% increase in latency with just a few dozen users. The problem was that this language, despite its popularity, was not designed for systems engineering. It lacked the necessary abstractions for concurrent programming and had a garbage collector that incurred a 50ms pause every 10ms – the perfect storm of latency.

我们最初的尝试（以及为何失败） 我们尝试使用一种流行的高级语言来实现一个定制的单体规则引擎。代码库迅速膨胀，性能开始急剧下降。最初的基准测试显示，仅在几十个用户的情况下，延迟就增加了 50%。问题在于，这种语言尽管流行，却并非为系统工程而设计。它缺乏并发编程所需的必要抽象，且其垃圾回收机制每 10 毫秒就会产生 50 毫秒的停顿——这简直是延迟问题的“完美风暴”。

The Architecture Decision After months of struggling with the monolithic approach, I made the call to rewrite the rules engine from scratch using Rust. This wasn’t an easy decision – Rust had a steep learning curve and required a radical shift in our team’s skills. However, the promise of memory safety, zero-overhead abstractions, and control over the runtime won out. We started by implementing a core library that encapsulated the rules logic and then built a high-level API on top for configuration and invocation.

架构决策 在与单体架构苦苦挣扎数月后，我决定使用 Rust 从零开始重写规则引擎。这不是一个容易的决定——Rust 的学习曲线非常陡峭，需要团队技能进行彻底的转型。然而，内存安全、零开销抽象以及对运行时的掌控力最终胜出。我们首先实现了一个封装规则逻辑的核心库，然后在之上构建了用于配置和调用的高级 API。

What The Numbers Said After The results were staggering. Our latency dropped by 90% compared to the previous monolithic implementation. More importantly, we saw a marked decrease in system calls and a significant reduction in CPU usage – our users no longer felt the pinch of performance degradation. We benchmarked our system at 10,000 concurrent users and saw a median latency of 100ms, with a 99th percentile at 200ms. The takeaway was clear: our rules engine was now a non-issue in our overall performance story.

事后的数据表现 结果令人震惊。与之前的单体实现相比，我们的延迟降低了 90%。更重要的是，系统调用显著减少，CPU 使用率也大幅下降——用户不再感受到性能下降带来的困扰。我们在 10,000 个并发用户的情况下对系统进行了基准测试，中位延迟为 100 毫秒，99 分位延迟为 200 毫秒。结论很明确：在我们的整体性能表现中，规则引擎已不再是问题。

What I Would Do Differently Looking back, I would’ve avoided the monolithic approach from the beginning. Our initial design should’ve taken configurability as a first-class citizen from day one. I also wish we’d invested more time in exploring off-the-shelf solutions and libraries that already addressed concurrent programming and performance. Not only would this have saved us months of development time, but it would’ve also allowed us to better utilize our team’s strengths.

如果重来一次，我会怎么做 回过头看，我从一开始就会避免采用单体架构。我们的初始设计应该从第一天起就将可配置性视为核心要素。我也希望我们能投入更多时间去探索那些已经解决了并发编程和性能问题的现成解决方案和库。这不仅能为我们节省数月的开发时间，还能让我们更好地发挥团队的优势。