Economics of coding

How to achieve peak performance in code.

Ever hit a point where optimizing your code started yielding diminishing returns or even made things worse?

This reality closely mirrors an important economic principle: the Laffer Curve.

The Laffer Curve illustrates the relationship between tax rates and tax revenue.

It posits that starting from a 0% tax rate, increasing tax rates will also increase revenue.

But that happens only up to a point.

Contrary to what some believe, it’s not a straight line. It’s a curve.

Beyond this peak, further increases in tax rates actually decrease revenue, as they discourage earning or promote tax evasion to reduce overall revenue.

The curve demonstrates that there's an optimal tax rate that maximizes revenue without discouraging economic activity.

This goes to show that every system has its optimal point.

If we return to our initial optimization question, we can easily see the resemblance.

Too little optimization and your application drags.

Too much, and you’re in a quagmire of complexity.

Which way you should go depends heavily on where you currently stand.

Over-optimization

Sky-high tax rates will eventually halt economic activity.

Like setting tax rates without economic understanding, optimizing without profiling is flying blind. It can lead to wasted efforts on parts of your code that don’t actually need it.

Think premature optimization. Pushing for optimization at every turn decreases overall productivity and hampers software maintainability.

Under-optimization

Low tax rates miss out on important revenue.

Under-optimized code can lead to lackluster performance. Although speedy at first, code that is not cared for is guaranteed to become a big ball of mud.

How to find the sweet spot

Measure and monitor

Determining optimal tax rates demands understanding of the economy.

In the same vein, you need to dive into the domain first to find bottlenecks and hot points. Profiling tools and benchmarks help you to understand where the hot points, worth optimizing, are.

Understand the law of diminishing returns

The Laffer Curve hints at evaluating trade-offs.

In code there’s a balance between performance and maintainability. Aim for the right level of optimization that provides both speed and clarity. Not all effort is equally fruitful.

Consider maintainability

Too high or too low taxes lead to long-term economic damage.

Both overly optimized code and spaghetti balls of mud are hard to maintain and cause issues down the line.

Pushing for extreme performance can make your code unreadable. Like high tax rates stifle business, dense code stifles collaboration and future changes.

Iterate and refine

Tax policies often need tweaks and revisions based on changing economic conditions.

Similarly, as your software evolves and grows, revisit optimization decisions.

Conclusion

Just like economics, code is an ecosystem. You can think of your codebase like an economy. It has its resources (data), processes (algorithms) and agents (functions).

Overburdening any aspect, like with excessive optimization, can disrupt the harmony.

Just as policymakers use the Laffer Curve to inform decisions, let balance guide your coding strategy.

The best performance comes from equilibrium. Not extremes.

---

P.S. If you liked this post, share it with your friends and colleagues.

---