Almost 5 years ago I had a blog post with the same title. That one was based on a simple survey about the programming language preferences of a small group of people, and comparing it to the TIOBE Index.
First, it is worth just taking a look at how TIOBE Index itself has changed in the last 5 years. Back then, C was on the first place ahead of Java by a very narrow margin, probably thanks to the maker movement (Arduinos and the like) being at its peek of popularity. Since then, Java got back to #1 quite a while ago, but C is still a very close 2nd.
The winners (considering how many positions they have improved in this period) are Python (coming up from 7th to 3rd) and Visual Basic .NET (from 9th to 5th). While the former is clearly understood (big data + data science, machine learning and education using Python recently big time), the latter keeps being a mystery to me. There may be some industry segment or technology domain somewhere I’m completely unaware of that is using a lot of VB.NET, or this is just some kind of (unintentional or not) anomaly in the algorithm creating the TIOBE Index.
The group being quite stable over time consists of C++ (#3-4), C# (#5-6), PHP (#7-8) and JavaScript (#7-9). The one clearly losing ground (slipping from #3 to #10) is Objective-C, objectiviously because Swift, being the new programming language favored by Apple has divided the iOS / macOS developer camp.
Now the subjective part: my ranking of programming languages, both generally and in a special context.
Recently I had the opportunity of being a speaker at a developer event of the company I work for (SAP). The goal of the session was (and you can find the full presentation on prezi.com) to provide a comparison of various programming models for creating microservices on the Cloud Foundry platform and its special incarnation: SAP Cloud Platform, and thus also show the power of Cloud Foundry build packs.
The selection of the languages participating in this comparison exercise was consequently very simple: Anything being able to run on top of Cloud Foundry was a good candidate. As Java, node.js, Python, Ruby, Go and C# are built-in, they were obviously there, as well as further JVM-based languages such as Groovy and Kotlin, both of which can produce WAR files that can be run by the Java buildpack of Cloud Foundry in a straightforward way. Plus, Scala (although probably possible to run with the JVM trick) has an own community buildpack, as well as Swift, being supported by IBM for server-side usage, could be added. I excluded only one built-in language: PHP, as I tried it (again) recently and concluded that it is not worth bothering with (although it’s still somewhat popular, I found it very hard to write well readable and maintainable code with it).
What I did more precisely to compare these languages and buildpacks, was that I implemented a moderately complex algorithm processing some data in CSV files, with just a command line interface (just to compare purely the programming languages themselves). Then with each language, I picked the simplest possible framework for creating a RESTful web service (preferably using the OData [short for Open Data] protocol where possible) that did nothing more than just query data from a single table in a PostgreSQL database, and provide it through its API. For example, in case of Ruby, I chose Sinatra over Rails, as the former is a simpler framework. I worked with a thing called Pyslet for Python instead of Flask or Django, as it is an OData-based framework. For Java, I’ve also considered only frameworks based on the OData protocol (thus the lack of Spring for example).
Back to just the languages themselves for a moment: I used 3 categories for scoring, popularity, syntax (capabilities of standard built-in libraries included here) and features (anything else from availability of good documentation to runtime performance).
The popularity score came from TIOBE based on a very simple algorithm: being in the top 10 meant 5 stars, having a position between 11 and 20 meant 4 stars, and between positions 21 and 50 meant 3 stars.
The winners of the syntax category were clearly the modern scripting languages Python, Ruby and Groovy. They are quite similarly excellent in both producing super-readable (and writable), well structured code and having extremely convenient features in basic categories like handling strings, collections, files etc. Swift, Kotlin and Scala got 4 stars, as though having quite modern and easy-to-use syntax (having been invented as “better Objective-C” and “better Java”), they had some small glitches. In Swift I didn’t really like string handling, in Kotlin I found some of the collection handling features a bit odd, and Scala is a bit hard to learn, as most of its documentation is full of academic functional programming mumbo jumbo (also contributing to its only 3 stars in the features category). Java and C# got 3 stars, being a bit over-complicated languages in 2019’s terms, although they keep being modernized, so they are quite OK. The only 2 stars of JavaScript can be attributed to it’s very strange ways of supporting object orientation, as well as some other unpopular or controversial language features. Go also got 2 stars for its syntax from me, as it is probably intending to be too much C++-like (being targeted for high performance applications), which results in (a bit bluntly speaking) ugly code.
I would not like to go into more details regarding the features category, I think you can easily guess most of it.
Then there was a 2nd group of categories, more specific to Cloud Foundry and implementing microservices. The 1st category here was about how easy it was to configure and start using the given language + framework with Cloud Foundry (with a very simple Hello World program just showing this world famous 2-word sentence as static text on a web page). The next category was how easy it was to connect to a PostgreSQL database, and the 3rd one was about RESTful services (here I was heavily favoring OData, so any language + framework combination that could produce “only” a service like a simple GET request with a JSON returned containing the data, got only maximum 2 stars out of the 5).
Skipping the summary of this group, here I jump to the final ranking. This was calculated simply by summing up the scores of the 6 categories (3 for the language, 3 for the framework + Cloud Foundry integration).
As you can see from this table, the clear winner is Java, even if it lost 2 stars in the language syntax category. Considering that the framework I mention here is a quite new one, even if you replace it with Apache Olingo for example (which is I think the most popular OData framework out there) and thus lose 1 or 2 stars for Java with this change, this language would still be the clear leader. Even further, if we leave OData out of the equation, using Spring for implementing less standardized RESTful services, Java would be a clear leader.
C# came in as second but not very close. I think the main reason is that the effects of Conway’s law are still very strong at Microsoft, and thus their complex set of libraries are very hard to set up in a way that each of them is “willing” to work with all the others needed.
Then there is a tie on the 3rd place: Ruby and node.js would be also good suspects as being among the leaders, being long-time favorite web languages. Kotlin may sound a bit like a surprise. but as it is JVM-based, it brings with it a lot of Java’s advantages, and combining it with a modern syntax may end up being a good choice for you even on the server side (for Android, it is already being favored and highly recommended by Google).
Python is only on the 6th place, mostly because it got low score for Cloud Foundry setup, as it is not very well documented, and I needed quite a bit of experimentation to make it work. My comments in the table above for the rest of the languages speak for themselves I think.
In summary: you have quite a few great choices if you intend to create web apps or microservices with REST APIs nowadays. Which one you choose may depend on your circumstances (special use case, skill set in your team or the whole company), or if you are less constrained, you can choose based on your personal taste.
About my preferences in particular: the last 2 languages I’ve been using for creating application backends were Ruby and Java, I think they are both great.