The Push Needed for Simplicity in Code

From Assembly to Python, computing languages have evolved in complexity and depth. Programming languages have been moving in the direction from esoteric and unreadable to extremely user friendly; however, this movement has compromised on efficiency and has added many extra layers between the programmer and the hardware.

When the first electronic computers were invented the 1920’s, machine code was invented simultaneously. Machine code is the most basic and direct interaction between human and computer. Machine code handles with individual bits and requires a deep knowledge of hardware to learn. It also uses an obscure mathematical syntax that looks like complete gibberish to most people - even to programmers using a higher-level language. Nowadays, machine code is rarely handled manually, but is generated by compilers and assemblers that translate source code from other languages into machine code.

The first layer above machine code was invented in the 1940’s when the Assembly language was implemented. This was the first language that wasn’t just comprised of hexadecimals and binary numbers but was more easily comprehensible. This added a layer of complexity to the code and made it easier for programmers to change and develop. This marked the first step in the long evolution towards accessibility and readability.

The movement started by the invention of Assembly is still active today. The higher-level programming languages such as Python, C++, C# and JavaScript, which are built on top of many other languages. For example, C++ is built on top of C which is built on top of Assembly. The prevalence of prioritization of user-friendliness is continuously growing in many different languages. Frameworks, APIs and Libraries are incredibly common and simplify the workload of the programmer by a great margin.

Although the prioritization of user-friendliness and accessibility in coding simplifies the code and reduces the workload of the programmer, it makes the code internally more complex as well. Code Simplicity: The Fundamentals in Software published by Max Kanat-Alexander calls for a push in internal simplicity in code. In his book, Kanat-Alexander emphasizes simplicity as the easiest way to solve problems in code. Breaking down code into more simple “machines” is better than creating a single complex machine with many layers to solve a complex problem. Many aficionados of code are stressing and emphasizing the idea of internal simplicity and efficiency.

The general reduction of workload and complex logic on the programmer has made programming a more welcoming and accessible endeavor; however, it has compromised on the internal simplicity of many coding languages. A single programmer is rarely able to understand the entire piece of software they even wrote themselves due to the compromise made. The idea of internal simplicity in code should be more focused and prioritized. Further simplifying code internally will eventually lead to more efficient code where the programmer is in direct control and understanding of what they are writing.