On one of my archive readings, I stumbled upon Paul's Graham articles, "The hundred year language". We all know paul graham is a massive fan of functional programming, so as I started reading his post, I initially forecasted: "this is going to be another tirade about functional" But I was pleasantly surprised, I like how he exposes the two branches that eventually programs are going to be developed for. Especially, because in 2018, it has become partially true.
This year, we have seen the born of Rust, a language, similar to C++ that promises speed and memory safety. This allows people who want to fiddle with concurrency and low latency, to program effortlessly compared to the memory antics you have to do in C++. Furthermore, there is also another subset of the language (as mentioned by paul graham) which is entirely to make the programmer more comfortable with the code itself. THEN he does refer to Lisp, his old friend.
What is more insightful about the article is that he is accurately predicting the two main branches of computers, nevertheless I would add another property that is making languages evolve. The ability of a language to stop the user from making mistakes. Specially, in the language which I have observed this property, is in C#. In order to screw up references, you have to use the unsafe keyword. Just looking at unsafe, makes you uneasy, so you really have to know what you are doing to do the corresponding task. I'll pose an example. Imagine you have an organization of a 100 developers. You could either choose for them to code in C++, or for them to code in C#. Now, they are going to be making mistakes. Let's say that 5 out of a 100 times, you introduce a memory leak in C++. Now, lets say that only in 1 of a 100 you introduce a memory leak in C#. The amount of debugging you've saved your developers is incredible.
[1] Graham, Paul. “The Hundred-Year Language”. Retrieved from: http://www.paulgraham.com/hundred.html April 2003
Retrival Date: Feb 1st, 2018