5.7 KiB
| img | title | author | pdate | desc |
|---|---|---|---|---|
| /img/complexity.jpg | Complexity | Jeff Russo | March 28,2020 | What is complexity as it relates to software? |
The most relevant definition of complexity for this blog post is: (adj) "Not easy to analyze or understand; complicated or intricate." Intuition of complexity is important if you are designing, writing, or reading software. If you are purchasing software, it is important to prioritize simpler options; it will be cheaper in the long run. In this blog post, I will discuss identifying complexity, why it's bad, why simple is good, and how software engineers manage complexity.
Identifying Complexity
Before being able to manage complexity, it must be identified. In addition to the definition, it is helpful to know indicators and examples. Seasoned engineers sometimes call these smells; complexity is not black and white, but more of an intuition. Some things that are simple now will become complex in the future.
Indicators
- Incomprehensible: Something complex is difficult to comprehend or articulate. It may have too many parts, or the interaction between the parts is complicated.
- Fragile to change: Complex things are not easily modified. An internal combustion engine is complex. If one was to modify the bore of the cylinders, special machining and new parts are required.
- Multi-purpose: A tool that can, "do it all," usually does nothing well due to its complexity.
Examples
- Run on sentences: Sentences that have too many clauses become complex because they are trying to express too many independent, but possibly related, although sometimes unrelated thoughts, and they take more mental energy to comprehend, causing the now frustrated reader to reread it until they can ascertain the author's meaning.
- Chess: At a glance, chess is straightforward. There are only six types of pieces, and the board is 8x8. The complexity comes from the permutation of games. It generally takes a dedicated decade to become a grand master.
- Humans: No two humans are the same. DNA on its own is complex; factoring in the expression of DNA is beyond the understanding of any single person.
Complex Software is Undesirable
All software is complex; it is one of the most complex man-made things. Physical creations such as space ships, submarines, and skyscrapers may be complex, but they are limited by the laws of physics. Software has no such limit. Using scc, a tool to estimate the size of codebases, it is shown to take about 16 years with 500 people to recreate FreeBSD.
Considering the global communication they have to do, the complexity goes up exponentially.
While some complexity is unavoidable, it is best minimized. Left unchecked, it will become unmanageable and will have to be scrapped to begin again. Complex software is difficult to reason about and therefore difficult to rule out problems. This is code that an adversary would enjoy combing through, trying to find an exploit.
Software engineers program, but programmers do not engineer
A programmer understands software languages and can program a computer to accomplish tasks. A software engineer will do the same, with the addition of minimizing the program's complexity. In fact the act of minimizing the complexity may take up almost all the time of a software engineer. Many other tasks such as designing, testing, documenting, refactoring, and code reviews are much more time intensive -- and important -- than the actual programming. Software engineers must create programs that are simple enough to be understood by other engineers. This enables others to work on the project and create something greater than the sum of the engineers' abilities.
Simple is difficult, but effective
An antonym of complexity is simplicity. Although it is easy to express what a simple system is, it is not easy to create one. Simplicity is so effective to software, there are many books, blogs, and principles written on the topic -- even if not explicitly. A few examples of principles:
- Encapsulation: This is a very powerful idea, especially when some complexity cannot be mitigated. It can still be encapsulated.
- UNIX philosophy: "Make each program do one thing well." This can save software from becoming an indominable mess. Constantly adding features to the same program will eventually make it collapse in on itself.
- Composition: Software should be composed of interchangable modules. The boundaries between modules and modules responsibilities must be well defined.
None of these principles are easy to carry out. There is both a science and art aspect of designing and building something in a simple manner. Once a system becomes simple, the benefits are exponential. One important benefit for teams to think about is number of engineers who can work on a project. If a system becomes an interconnected mess, usually only 1 or 2 people can work on it simultaneously. If a system is well designed, especially using modularity, the number of engineers who can work on it simultaneously is practically unlimited, because each module is independent.