How programming language is evolving- Past, Present and Future
Today I saw some devs arguing about Java in twitter, which lead me to write this Article. The programming language is one of the most important parts in the architecture of software development, but each day, which language you choose is less relevant.
Most people use the technical aspect of the language to argue, today I will focus in the history to learn about the past, understand what is happening in the present and what to expect for the future. Programming languages are in constant development, and all of them are created basically with a sole propose: increase development productivity.
I will talk about some outstanding language from the past and the importance they have in the software development, languages and projects that are changing the way we code and finally what to expect from the future.
The first language I will talk is C, it’s a language create in 1972 and still is one of the most relevant languages nowadays, probably the most relevant programming language in the history (this may change in the future). Before C, software development was done using assembly, which is a very low-level programming language (language that provides very little abstraction from the computer Instruction set architecture). The Unix Operation System was being developed in assembly, with a very low abstraction between ISA and the language itself, which is a huge productive killer when you are developing an universal operating system (have to support a lot of ISA). In order to make development easier Dennis Ritchie and Ken Thompson created B and furthermore C. The C compiler was original written in assembly, but today most of the GCC and LVVM compilers (C & C++ compilers) are written using C, C++or another language instead of assembly itself.
In the 80s C++ gained a lot of popularity because of the object-oriented programming and the compatibility with C without sacrificing speed or low-level functionality. C++ was not the first, but for sure it was the one responsible to spread the POC concept. Although POC was very dominating in the 80s, some important functional languages were born in this decade like Erlang.
Late in the 80s and in the 90s, the computational power increased a lot, making interpreted languages viable. Interpreted languages are executed without the need to be compiled into ISA (instruction set architecture). In practice this lead to more flexibility: platform independence, reflection, dynamic typing and etc in exchange for performance.
I said that the language you choose is not so relevant anymore as, in the past, one of the aspects is not about the language itself. Thus, how software development has evolved: Clean Code, POC, Design Patterns, TDD, BDD, DRY, SCRUM and etc. are all language agnostic. Those practices lead to consistent software development and better products, that’s why Java has been so criticized lately. If you follow the best practices you will not have so much gain of those languages constraints but that flexibility will start to border you.
If the 90s was a great deal for interpreted languages, 2010s is the decade were compiled language will shine. If the flexibility was a huge drawback earlier it does not extend anymore, with the progress in the compilers, languages like Kotlin and Swift were born, which can delivery constraints checks without losing flexibility. Those 2010s languages are almost as powerful as interpreted languages with almost any drawback.
Another amazing language that is gaining popularity, however, is frequently poorly applied is Go. Go not being an object-oriented language neither functional, make it very unproductive compared with 2010s languages. Yet I see a lot of software written in Go that will not take a huge benefit from it. Go was created to be concurrency efficient (and it is). I see the value in Go, it can take a lot of space from C in compilers or some applications hotpot where performance is important, but most of the people are using it without really need it.
One of the most important projects of the last decade that is increasing popularity is LLVM. Low Level Virtual Machine (which is not a virtual machine) it’s a modular language agnostic compiler and tool-chain that’s is being used for several languages in order to compile native code. Some of those languages are ActionScript, Ada, C#, Common Lisp, Crystal, CUDA, D, Delphi, Fortran, Graphical G Programming Language, Halide, Haskell, Java bytecode, Julia, Kotlin, Lua, Objective-C, OpenGL Shading Language, Pony, Python, R, Ruby Rust, Scala Swift, and Xojo.
And not only languages are becoming homogeneous, but software has also become polyglot, we already have micro-services architecture and plenty of other protocols that allow software to be written in a lot of languages.
If this was not enough, GraalVM is making polyglot software to a whole new level. It does support developing using JS, R, Ruby, Python, Java (and any other JVM language) in the same program.
Languages are becoming homogeneous, but they always will have their differences. The technical aspect of the language still very important and probably will never be non-relevant, but those are becoming less important because we are driving into a more polyglot word. Thus, A good developer is not that one with a huge experience and specific technological skills. A good developer has solid principles that transcend any particular technology.
Liked this post? Please follow me on twitter: https://twitter.com/guitcastro