Information about the release of a new version of a particular programming language appears at regular intervals. And with each new version, its capabilities expand, new syntax constructions or other improvements are added.
And this very much resembles the development of technology, as in any other field of technology. When the created creations are improved with the next stage. Faster, higher, stronger … and at the same time much more difficult.
The April Fool’s article “Demonstrative Programming” made me think about this problem.
It is clear that the publication date of the article speaks for itself. Nevertheless, the new C ++ standards, the constantly coming out Java specifications or the new syntax in PHP 8, involuntarily make you wonder, is the development of programming languages going in the right direction? After all, most innovations add complexity to the main working tool and solve some problems, implicitly adding many others.
And what should be at the end of progress in the development of such a discipline as programming? Or at least one specific language? For the sake of achieving what ultimate “ideal” goal are new programming language standards being developed?
If you fantasize about the ideal ultimate goal of development, for example, transport, then it will be instantaneous movement at any distance with an arbitrary payload and zero energy consumption.
Or, for example, what is the ideal goal of medicine?
The poor didn’t get sick and the rich didn’t get well probably the cure of any disease and biological immortality.
Of course, the “ideal” goal is a very simplistic concept. In fact, “ideal” is synonymous with “unattainable”, since it will always be challenged by the need to maintain a compromise between different mutually exclusive boundary conditions.
But you cannot directly compare software development with the development process in other technical disciplines. Indeed, when creating a final product in any technical area, all complex production operations that require direct human participation can almost always be divided into separate, simpler parts or stages.
This is done, among other things, so that the complexity of one performed operation is not prohibitive for the performer. But how can this be done in software development?
In this case, I mean the ultimate limitation of the capabilities of one particular person, as opposed to the possibilities of dividing technological processes into separate stages, each of which can be performed by completely different people (as an example, this is a regular conveyor with its division of labor into elementary operations or a narrow specialization of doctors – specialists in one specific area).
After all, it is even difficult to imagine a fantastic organization of programmers’ work in the form of a pipeline: The first developer writes only the interfaces of functions and their calls, after which he transfers the code to the second employee. The second writes in the text of the program only test conditions and unconditional jumps and passes the text to the third. The third is responsible for writing loops and general code formatting, etc. – the result is expected to be complete nonsense.
Because of this, the software development industry is forced to follow an extensive development path (i.e. by increasing the resources used in production). Modern industrial programming languages have very rich capabilities for dividing the application code into separate functions / modules / components, which allows many employees to develop a complex software product at once.
But even this development has a natural limitation. And this limitation is the person himself, since each developer must know and be able to use his working tool, i.e. programming language.
If we take the above analogy with a conveyor belt, then every worker in it would have to thoroughly know baboutmost of the machines and tools used throughout the plant, regardless of which one he performs a specific operation at his workplace.
After all, the paradox of the development of programming languages is that by adding new features and syntactic constructions, we complicate a working tool designed for both joint and individual use!
And it turns out that simultaneously with the process of constantly increasing the capabilities of development tools, the opposite process is also going on – an increase in the complexity of code development by an individual developer. In fact, this is the very mutually exclusive, insurmountable contradiction.
Maybe that’s why it is impossible to find a “silver bullet” that would increase the productivity of one programmer? After all, the attention and capabilities of a person are not unlimited. And any innovations and improvements in the programmer’s working tool are forced to push the entire IT industry on an extensive path of development.
Perhaps we should develop fundamentally new approaches, and not chase syntactic sugar in programming languages from the last century? Or does he not care at all, continue to use what is, and the theory of Darwin’s grandfather will put everything in its place by itself?