Complexity, Abstraction, and Simplicity
At their core, computers are simply a device of ones and zeros. They are beautifully complex and binary. However, all of the ones and zeros are hiding behind an abstraction. An abstraction is a layer within a system that hides complexity below. We don’t think about all the hidden complexity in our world, but it is everywhere. For example, I thought that businesses were the epitome of efficient machines when I was young. Then I started working and realized the shiny marketing materials of the marketing department were only an abstraction of some genius, chaos, and head-scratching behind the scenes.
If you follow the abstractional history of the computer, you will see that each step of the process was a huge step forward in hiding the ones and zeros. Initially, computers were giant machines with vacuum tubes (the original one and zero). Then the ones and zeros moved to transistors which were a lot smaller. Next, programming went from punch cards to programming languages, and then DOS turned into Windows, and Apple released the iPhone. Each step of this process was a monumental leap forward, but it took time to hide all the ones and zeros so you could enjoy the latest YouTube video. The first generation computer, the ENIAC, used 18,000 Vacuum-Tubes and was made in 1945. Seventy years later, some ex Paypal employees formed YouTube in 2005.
Great, but why does it matter? If you are a Product Manager, Business Analyst, or another type of knowledge worker, you are almost always delivering abstractions. Think about the humble business report. Most of the time, it isn’t showing the raw data. Instead, it often excludes the outliers and includes baked-in assumptions and some tribal knowledge that was lost when Joe left the company.
The goal of a knowledge worker is to deliver the most elegant solution for your customer, and elegant solutions are only possible if you simplify the complex.
Simplify Simplify Simplify
Systems, products, and processes naturally move toward complexity. For example, the ENAIC computer could only solve one problem at a time and had six people programming it by wiring “functional units” together. On the other hand, Windows 95 has approximately 2 million lines of code, and Android phone has 12 to 15 million. That may seem like a lot, but it is significantly smaller than Windows 10, which has bout 50 million lines. It will become more complex no matter what you are working on, so it is essential to keep it simple because complexity creates future debt.
Rules to keep it simple
- Reduce — Limit the number of fields, metrics, and steps. If whatever you can do can be reduced, reduce it.
- Reuse — Use what you have. Reuse what you have. It is harder to reuse versus adding new. However, the continued simplicity will pay you dividends in the future.
- Recycle — If you have a process that can be recycled into something new, use it.
Abstract Carefully
Good abstractions like programming languages and nesting applications within windows pass the test of time and are here to stay, as are nesting applications within application windows. These good abstractions also provide a general solution used in many contexts. For example, there are many programming languages, but the underlying concepts are universal. And the application window that Xerox initially developed is now the home for every program and application.
Abstracting Rules
- Generalize — If you can have the opportunity to provide a general-purpose solution, it might take more time to build, but it will be worth it.
- Find the Real Problem — Spend your time figuring out the real problem. First, be curious and ask why. Then, ask your end-users what they will do with the proposed change. If you or they are unclear and you proceed, you will be introducing unwanted complexity into your solution.
Complexity Creates Overhead
More complex products, systems, or processes require more overhead, which requires more abstraction. Most likely, a majority of your company is supporting abstractions. All developers, product managers, and analysts are responsible for simplifying business complexity.
Managing Complexity
- Manage Boundaries — If the boundaries of your application/process are not transparent or if you start trying to be all things to all people, you are introducing complexity.
- Iterate Consciously — Make small changes and implement them fully. Then evaluate and reassess your next steps. For example, the founders of Youtube thought it would be a dating site and quickly realized that their future was in cat videos.
Keep it simple and abstract wisely, and you will have less complexity to manage. Your mental health and scalability will thank you.
