The Art of Clean Code – The Pareto Principle in Tech

5/5 - (6 votes)

If you’re a developer looking to up your coding game, you need to be familiar with the 80/20 rule.

Otherwise known as the Pareto Principle, it’s an age-old concept that, when applied to programming, can revolutionize how you approach your workflow and productivity.

If you haven’t read it, check out the previous article in this series:

πŸ‘‰ The Art of Clean Code – Complexity Kills Your Success

Understanding the 80/20 Principle

Vilfredo Pareto, an Italian economist, observed this phenomenon β€” that a small number of causes often lead to a large majority of effects.

The Pareto Principle, or the 80/20 rule, states that approximately 80% of effects come from 20% of causes. In coding, this might mean that 20% of your codebase could result in 80% of the bugs. Recognizing these patterns is key to prioritizing where you invest your time and efforts for maximum output.

Specifically, here’s a list of examples in tech and programming context:

  1. Coding: 80% of software bugs often arise from 20% of the code.
  2. Product Features: 20% of product features could be responsible for 80% of user engagement.
  3. Website Traffic: 80% of web traffic might come from 20% of the content.
  4. Server Load: 20% of system processes might consume 80% of computing resources.
  5. Tech Sales: In a tech company, 80% of sales might come from 20% of customers.
  6. Security Vulnerabilities: 20% of security vulnerabilities could cause 80% of security breaches.
  7. User Feedback: 80% of useful product feedback may come from 20% of users.
  8. Learning New Technologies: 20% of learning concepts and techniques could be applicable to 80% of everyday programming tasks.

Here’s an example for monthly active users of different platforms:

And another statistic:

How the 80/20 Principle Plays Out in Programming

Let’s dive into an everyday scenario for a programmer. Imagine your project has a vast codebase, but only certain functions are causing performance hang-ups.

Instead of combing through every line of code, you identify the crucial few β€” the 20% causing 80% of your runtime woes β€” and you hone in on refining and optimizing those areas.

πŸ‘‰ Python cProfile – 7 Strategies to Speed Up Your App

Big players like IBM and Microsoft rely on this principle to optimize user experience by focusing on the code that’s executed most frequently.

Applying the 80/20 Principle to Personal Productivity

This principle doesn’t just optimize software; it can boost your productivity too. Within a typical team, a small group often carries the bulk of a project’s success.

By identifying and replicating the effective behaviors of this top 20%, you could significantly increase your contribution and value as a programmer.

The Art of Clean Code: “This 16-times difference in average performance is a fact in millions of organizations throughout the world. The Pareto distribution is also fractal, which means that the top 20 percent of the top 20 percent generate 80 percent of 80 percent of the results, accounting for even more significant performance differences in large organizations with thousands of employees.”

The Key to Success: Measured Metrics

The trick is to find success metrics β€” behaviors you can track and influence.

  • For a researcher, it could be the number of times they’re cited in other works.
  • For a coder, perhaps it’s the number of lines written or bugs fixed.
  • For an investor, it might be the number of annual reports read (=Warren Buffett’s approach)

By focusing on actionable metrics, you’re more likely to achieve tangible improvements in your career. But don’t focus on just any metric — it is vitally important for you to find the metric that matters most in your environment.

Again: Find the one metric that will be most relevant for your own success!

For example, as a researcher:

Now why should you do that? The reason is simple: It pays!

The Power of Focus and Specialization for Coders

By focusing your learning and development efforts on specific areas, you can climb higher up in the Pareto distribution of productivity and gain disproportionately higher rewards.

Think niche, go deep, and become the go-to expert in that area β€” whether it’s in a programming language, a development framework, or a particular technology.

The Art of Clean Code: “That’s why it doesn’t pay to spread your attention: if you don’t focus, you participate in many Pareto distributions. Consider Figure 2-7: Alice and Bob
can each invest three units of learning effort every day. Alice focuses on one thing: programming. She spends her three units of effort on learning to code. Bob spreads his focus across multiple disciplines: one unit of time polishing his chess skills, one unit improving his programming skills, and one unit improving his political skills. He’s reached average skill and output in each of the three areas. But the Pareto distribution disproportionally rewards the top performers, so Alice collects more total output reward.”

Persistence, focus, and a clear success metric are what separates the top freelancers from the rest.

Practical Tips to Apply the 80/20 Rule in Your Coding Life

  1. Define Your Success Metrics: Determine the key behaviors that will drive success in your area of coding. I have always used the success metric of number of lines of code written in a day. It makes sure you’ll keep coding, get better, attract more coding friends, get even better, and make more money and impact as a result.
  2. Set Clear Goals: Know where you’re headed long-term to stay focused on what’s truly important.
  3. Optimize and Outsource: Concentrate on activities that give you the biggest bang for your buck and outsource or minimize the rest.
  4. Learn From Successes and Failures: Reflect on your experiences to understand what works and what doesn’t.
  5. Don’t Fuck Up: Just avoiding things that reduce value like smoking, eating unhealthily, sleeping little, drinking alcohol, watching Netflix, porn, etc. Avoiding things that drag you down is one of your biggest leverage points. If you minimize the things with negative values, your average value will explode.
  6. Educate Yourself Continuously: Keep reading and learning to expand your capabilities and understand your domain better.
  7. Iterate and Optimize Existing Work: Rather than always starting from scratch, improve what you already have for exponential gains.

With the Pareto Principle, coders like you can not only improve efficiencies but also carve out a path for significant advancements in your career. Take the leap from being average to exceptional by identifying and focusing relentlessly on the vital few rather than the trivial many.

The gain? You’ll reach explosive success, impact, and income levels:

Finally, allow me the following comment: The Pareto Distribution is fractal. You can zoom in and there’s another Pareto distribution:

The Art of Clean Code: “Twenty percent of the top 20 percent of coders will earn
80 percent of the 80 percent of income. In other words, 4 percent of the coders will earn 64 percent of the income! This implies that you’re never stuck with your current financial situation, even if you already belong to the top 20 percent of coders.”

πŸ‘‰ Stay tuned in the Finxter Newsletter (free)

In the next lesson on the Finxter blog, you’ll learn a key concept that helps you focus on the vital few features of your software: you’ll learn how to build a minimum viable product:

πŸ‘‰ The Art of Clean Code – Minimum Viable Product (MVP)