How Quantitative Code Simplification Boosted Our Backend System Efficiency

Background

Code simplification is a method of system refactoring that aims to reduce unnecessary code through quantifiable metrics, thereby lowering complexity, improving readability and operability, and reducing development and maintenance costs.

As software systems evolve, code bases grow, function call graphs become tangled, and complexity rises, especially in critical systems with frequent business changes. Consequently, code reduction becomes an urgent task, often appearing as small technical improvements on a to‑do list.

“Reading code takes more than ten times the effort of writing it. Making code easy to read is therefore crucial.” – Robert C. Martin

Our core coupon system (alsc‑pc) faced massive code volume (tens of millions of lines) and high complexity, prompting us to explore systematic code reduction.

Solution

The solution addresses three main challenges: decision difficulty, high investment, and high risk.

1. Decision Difficulty

Evaluating ROI for code reduction is hard; there is no universal metric for how much effort is needed to cut 10% or 20% of code. We propose using production traffic to quantify the proportion of effective functions, providing data‑driven guidance for decisions.

Sampling 460,000 traffic events over a month showed that effective functions accounted for about 5.5% of total functions.

Function Coverage (Effective Functions) = Number of functions covered by replay traffic / Total number of functions

When the effective function ratio falls below 10%, code simplification is likely to yield significant benefits.

2. High Investment

Deep code analysis involves building a function call network; isolated classes/functions are easy to handle, but the core network requires manual business‑logic analysis.

It is essential to distinguish between code simplification (questioning necessity of each function) and regular refactoring (adhering to SOLID principles).

We weight functions by the number of times they are called relative to total traffic:

Function Weight = Call count of the function / Total traffic

The weighting data helps developers validate their mental model of the call graph, providing rapid feedback during code walkthroughs and reducing analysis overhead by 30‑40%.

IDE plugins can surface these metrics directly.

3. High Risk

Deleting code is high‑risk; safeguards must ensure no loss of functionality, performance, or availability. Strategies include regression testing, gray‑scale releases, stress testing, and drills.

For the alsc‑pc refactor, we created a new system alsc‑coupon to migrate effective code, addressing challenges such as manual traffic fixing, mock configurations, and high‑availability concerns.

Key Difficulty / Risk

Quality Strategy

High migration cost

Use function weighting tool for evaluation

High testing cost

Comprehensive regression and validation, including simulation and custom comparison tools

Configuration consistency risk

Configuration consistency detection pipeline

Financial loss risk

VIP mock and anomaly injection for extensive scenario coverage

High‑availability risk

Stress testing focusing on isolation and disaster recovery

These measures, combined with existing techniques such as E2E regression (万象仿真), configuration consistency checks, and VIP testing, form a robust quality assurance framework.

In the early 20th century, a Ford motor failure was solved by simply reducing 16 coil turns—illustrating that knowing where to cut is the real challenge.

The core difficulty lies in systematically identifying the exact places to simplify code.

Conclusion

Quantitative function weighting, data‑driven decision making, and targeted risk mitigation can significantly streamline code simplification projects, improving developer efficiency and system reliability.