Shortcuts can make or break a developer’s productivity. It also turns out that Visual
Pareto's Law, also known as the 80/20 rule, has been circulating mainstream Internet for a while now, especially in productivity and motivational circles. The general gist goes, 80% of the output is often produced by 20% of the input.
The 80/20 rule is applied across multiple disciplines, including, but not limited to, distribution of income, economics, sales, management, athletics, and productivity, to name a few.
It is a rule that’s often cited and used in business and sports — but what about in programming?
Software engineering is a massive area that spans numerous physical and digital layers, services, devices, and languages. The novice is often under the impression that you just need to learn a few select things and you’re done.
Except when it comes to digital technologies, you’re never quite done.
There are a lot of things to learn when it comes to programming.
However, if we look at it, there are a lot of similarities across the different languages that are currently in popular usage. Overarching concepts and patterns sit on top and span over different linguistic differences.
Functional and object-oriented are often the most popular to target if you want to write effective code. Modular patterns and event-driven often come into conversations about how to increase efficiency and effectiveness as developers.
Then, there are patterns and actions in code that comes up over and over again, regardless of which language you’re dealing with — but you need to know the specifics and finer details of how to implement it for your chosen stack.
They are things like CRUD patterns, dealing with arrays, transforming data, and passing things between components and classes.
Sessions, open/close connections to databases, social login API consumptions, and payment gateway integrations are some common requirements for back ends. Routing and modular CSS are important ones for front ends.
5% Work Smarter Not Harder
Manual work is the biggest inefficient use of time when it comes to programming. Manual patterns in programming are even worse.
What exactly are manual patterns?
One of its official names is an imperative pattern — or a procedure where the program needs to take in that specific order to produce the correct output. In reality, things never appear in the order they need to be 100% of the time.
Flexible code is not about covering every possible scenario that comes up by coding for all the potential contingencies. It’s about writing your code in a way that only depends on the combination of factors and not the order in which they appear. By doing this, you eliminate a layer of complexity.
Coding smart is the process of reducing complexity and therefore potential points of failure. In addition to this, the number of lines you need to maintain will also be reduced as a side effect.
Creative code is never recommended — unless you’re doing code poetry, which is something different.
Programming is not art. Programming is the process of translating business requirements into a digital format. However, the ability to creatively connect your knowledge points together is what makes or breaks your final output.
More often than not, writing code can be seen as mechanical and emotionless. In a way, it is. The idea of creativity is rooted in passion and imagination.
However, as Mark Twain once stated:
“There is no such thing as a new idea. It is impossible. We simply take a lot of old ideas and put them into a sort of mental kaleidoscope. We give them a turn and they make new and curious combinations.
We keep on turning and making new combinations indefinitely; but they are the same old pieces of colored glass that have been in use through all the ages.”
Being able to create creative solutions is the ability to connect knowledge points together to produce effective software in the given time.
80% Making Dots
“You can’t connect the dots looking forward; you can only connect them looking backwards. So, you have to trust that the dots will somehow connect in your future.”
— Steve Jobs, Stanford commencement speech
The most effective and efficient developers among us seem to be a never-ending pool of knowledge that spans across different domains. They seem to know about everything there is to know. You can talk to them about any topic.
From the common things we see on our social media feeds to random tidbits of knowledge, like the process of glassmaking.
They spend their time learning, reading, and consuming things beyond their current domain of knowledge. It’s not just limited to the tech stack they’re required to be experts in.
The impact of this is that they extend their creative boundaries by having more dots to connect when creative solutions are required.
Having different domains of knowledge also allows the best among us to create software solutions that are intuitive to the experiences and expectations of different stakeholders.
This is because the person behind the code is also an active consumer of the thing they’re creating. They are aware of the annoyances and broken bits. This gives a fresh perspective for when a solution is required.
It All Adds Up to 100%
20% of actual work determines the effectiveness of the output. However, how you spend the rest of the 80% also matters.
We don’t really get to see the 80% until it materializes in some form within the 20% equation. This is because every project requires a different cocktail of 20%.
There is no single combination that works every time — no magical solution to every problem. The mythical unicorn developer is just a developer that knows how to engage the right 20% consistently.
Knowledge is only the tip of everything. Yes, it does account for a great deal of how sturdy, modular, and flexible to growth your final delivery is.
The ability to recognize patterns and implement knowledge points are also major factors in being an effective and efficient developer.
To figure out what the right 20% is for your project, you need the range of knowledge points to pick from. That is why the 80% matters too — and why you should cultivate this as much as you can, in addition to spending your time learning patterns and methods of coding.