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 past:
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.
Therefore it’s easy to imagine how important C was in the software development history, today most of the compilers are written using C/C++. If C is not productive enough for most software written nowadays, a lot of other languages make extensive use of C/C++ in their compilers and tools chains, some examples: Javascript (v8), Python, Ruby, Java, Swift and a lot more.
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.
Some notable interpreted languages are: Python, Java, PHP, Ruby, Javascript and etc. If you compare the only the language aspect of those languages with C/C++ it’s easy to argue against those. They are high level languages, which increase a lot the developer productive, no need to worry with memory management by itself is already a huge gain. So as hardware were gaining performance those languages gained a lot of popularity. Nevertheless we always have a point in the curve were it’s not a viable option to sacrifice performance for productive, and that’s why C is so important until today.
If you notice, Java does not have a lot of flexibility compared with Python, PHP, Ruby, and Javascript. It can be considered an intersection between C++ and those interpreted languages, yet it is one of the most used languages until today. Why someone would choose a less productive language? Well, language productive is not only flexibility in fact flexibility can be your enemy, but Java also has more constraint (strong interface contract, static typing and etc.) which make it a great choice for huge complex software which is harder to maintain.
The Present:
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.
The Future:
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.
Plenty of them did you notice? And you also notice that a lot of them are interpreted languages? In contrast of compiled languages are getting more sophisticated, interpreted languages are getting faster and safer (compile-time checks) javascript and PHP are great examples of how compiled and interpreted language are heading to the same direction.
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
