In this day and age just about everything we use on a daily basis is powered by a coded software program. Even our cars’ mechanisms are now controlled by millions of lines of code. When you press your foot on the brake, a line (or several lines) of code communicates with the internal engine to slow the speed down. What if you pressed your foot on the break though and your car didn’t stop? This was an issue that Toyota experienced in 2007, when the code controlling acceleration caused the wrong thing to happen. The issue was not that the software malfunctioned, but that somewhere in the lines of code, the programmer had told the computer to do the wrong thing. As consumers we understand that our pieces of technology sometimes have bugs and don’t do what we expect them to, but what I learned from reading, “The Coming Software Apocalypse,” in The Atlantic, is that softwares do exactly what we tell them to do. This means that every error or malfunction that happens with a coded software only happens because what the software was told do was wrong.
When most of our technology was mechanical we could prepare for parts to break by building in the assurance of a backup engine, for example. Software programs cannot break, so a reliable program is all programmers need to produce. Unfortunately, critical systems often become too complex for us to understand. Many software developers will end up getting tangled up in their own code when trying to build on top of, or tweak other code. The complexity of the code, and the thousands or millions of lines of code make bugs “invisible”. The Toyota acceleration scandal took NASA software programmers and two other different groups of software programmers before someone found the “invisible” error in the code. With the coming advancements in technology—driverless cars for example—we will see even more complex software algorithms that will be dependent on its accuracy. Many well respected programmers are advocating for a change in the way we code to improve software developer’s understanding of complex codes.
The software programming world is beginning to make the transition to “model-based design”. Chris Granger, John Resig, Bret Victor, and Eric Bantegnie were all important names mentioned in the article, who spoke in favor of developing a “model-based design” program. The idea with this new coding tool is that programmers will be able to visualize and understand the code without the likliness of error. “Model-based design” is essentially a software programming another software. The idea is that a complex software will be developed that can interpret an outline given by the programmer of the restrictions and outcomes desired in a new software, and then produce a working code. The four programmers believe this is the route coding needs to take because programmers know what they want the code to ultimately do, but get lost in each individual line of code by having to focus on one aspect at a time—they easily lose sight of the code as a whole.
I personally hope a new program is developed to help software developers put together less complex codes and more accurate codes as we move closer to the future, and even more incredible technologies.
Original Story: “The Coming Software Apocalypse.” Somers, Sep. 26, 2017.
Image: Sourced from Google, but originally a screenshot from Khan Academy