Have you every wondered about the increasing lines of code in everything that we do as developers? This is one such random musings from a fellow developer.
The actual info graphic about the number of lines of code in various everyday products is here.
It is fairly obvious that we will be hitting a critical point sometime in the future.
As any of you here know, everything starts off as a single code file with simple model structures, providing the most basic functionality imaginable. With increasing usage, assuming that the product really solves something, we might wanna start adding new features and optimizations to our app. Thus begins the journey of the downward spiral towards increasing complexity.
The are two major problems here. Increasing dependencies in proportion to increasing features and deprecation of all these dependencies.
There is no such thing as "static" code and Static Code == dead code. So it is an inevitable thing these days to build an app with less or no dependencies on external libraries. This sort of "inflation" as time passes is again the problem with current form of development.
There is also a human aspect to this as developers are at the end of the day, humans. And humans change, humans move and humans grow. Apps shift between hands, they move between companies and between use cases.
How to account for all of this?
The solution to all of this maybe be the problem itself. Change and diversity.
Ask yourself how many programming languages do you know at least by name and this number, mind you is mostly greater than the number of actual human languages that we know. Why is this?
It is imperative to state the obvious here. Certain languages were developed for certain reasons. C for instance was developed for running the most basic of programs in the most basic of hardware systems while python is not. C obviously beats python in performance, while python has the lead in readability and usability.
This may also be due to the fact that there are many more developers today than during the Unix days, when a bunch of people were dishing out computer software from a single office or their garages. We have now clearly moved to a community level phase of programming.
With more and more people involved in making one piece of code, readability takes more precedence than performance.
What would the successor of these two languages be?
Increasing human interactions with digital technology, the conversation that began in the early 1960s is only going to get much better. The AI aspect of things will also make its way into the realm of hardcore programming.
Let's take JS as an example. Every engine that your JS code uses has an optimization step in it. So for example, when declaring an object with a certain set of attributes, the JS engines (V8, SpiderMonkey etc.) compiles this into a specific object type in machine code. The more you access or call this object, the compiler marks this object as "hot" and tries to optimize on this. So as Franziska points out here it is always best to declare a type and use it consistently.
My question is but why?
If there is a neural network attached to the engine, that records and monitors my coding style, then the compiler can safely optimize based on my coding style.
Maybe I like random object declarations, but do not like function in function calls, or having tons of event listeners. The compiler could take advantage of this and make better, or faster code.
Combined with Web Assembly we could try to make this function all across the web irrespective of computer architecture.
With the advent of the new decade, I personally as a programmer can't wait to see how the next ten years will unfold. Programming has been exhilarating, empowering and most of all, really fun.
Ever improving hardware prowess and super brainy software developers will surely be taking the torch forward and reaching new heights with digital technology.
And maybe one day the whole world would be just made up of programmers! :)