Go, NodeJS & Python microservices in 2017

At Moddix we spend the last week researching what platform would be the best approach for a new high load microservice we will design in the upcoming months. We thought it would be interesting to share our process in determining the platform we would use. In order to determine which platform we prefer, we decided to compare the three to four competing languages on three dimensions. Speed, Learning curve & compatibility with our development team and future readiness. We will address these dimensions in that order. However one thing should be mentioned at this point. Up until now, we did not conclude any tests ourselves, but instead decided to crawl the web in order to find tests and experiences from developers all over the world. This article will probably be followed up with some real tests with the two or three most interesting platforms for our organisation.

There were some other meta comparisons but I felt they lacked some backlinks to stake their claims:

Speed

Looking at the speed of languages one thing should stand out. For now we did not do any tests ourselves. We decided to round up some tests and see what we can learn from those. Some interesting results we found were:

All of these results are comprised of different tests. As is the case with all programming tests they are based on a specific program and therefor on a set of assumptions on what a developer wants to achieve. Still I feel we can distill a general overview of the situation.

I deliberately did not include any speed resources for PHP and NodeJS because it is notoriously difficult to compare them in a straightforward way. If you need more information about why I chose to leave it out you can check the last resource of the compatibility section.

Finally it boils down to the following list:

  • Go +++
  • NodeJS ++
  • Python +
  • PHP 7 +

Learning Curve & Compatibility

Currently most of our in house team members are experienced PHP or JavaScript developers. Additionally there is some experience with python. From that perspective sticking with PHP or adopting NodeJS for the new service clearly seems the way to progress. However then I came across the following two articles:

In which the author discusses disillusionment after using NodeJS in production for a whole year period. Based on the extensive explanation of the author we assume that the learning curve of NodeJS might be more steep than that of Go. Finally one of the nice features of Go is the fact that it comes with a standardized formatter. As the creators of Go mention themselves it makes sure developers spend less time on ‘religious wars’ on what the correct syntax for code is.

Taking their experiences into consideration the short list from a learning curve and compatibility standpoint looks something like this:

  • PHP 7 +++
  • Python +
  • NodeJS +
  • Go +

Future readiness

Looking at the future readiness of each of these platforms it looks like Go is a clear contender. Tiobe shows the huge increase in popularity Go had in the last year or so. On the other hand NodeJS looks like it is here to stay. While Python and PHP have a legacy of at least twenty years.

  • Go +++
  • NodeJS ++
  • Python ++
  • PHP 7 +

Conclusion

For now our conclusion is that we will probably prefer Go or NodeJS for the API of the service we will design in the upcoming months. The next step is that we will do some tests to determine which language suits our needs the best. Since we are looking to develop a high load API it seems it would be best to design a test that revolves around fetching from and inserting things into a database under pressure.