GOPHERSPACE.DE - P H O X Y
gophering on gopher.beastieboy.net
 ______________________

  LANGUAGES POPULARITY

     Nicolas Herry
 ______________________


       2017/03/31





1 Languages popularity
======================

  [An article posted on monday on Revolution Analytics] echoes the
  latest report published by Redmonk, which shows which programming
  languages are most popular. In this report, Python climbed to position
  #3 and R registered a slight step back, to #14. So, what does it tell
  us?  Well, not much, I'm afraid.


[An article posted on monday on Revolution Analytics]
http://blog.revolutionanalytics.com/2017/03/redmonk-jan-2017.html

1.1 Useful information
~~~~~~~~~~~~~~~~~~~~~~

  Of course, the first thing is that putting all languages in one bag
  seems a bit silly, to say the least. How often do you hesitate between
  C and Javascript? And why is the popularity contest run every six
  months by Redmonk and every month by TIOBE? How does that relate to
  anything in the real world?

  But it´s not just the methodology I have a problem with. I believe the
  value of any piece of information is directly proportional to the
  value of the decisions you can make based on it. So, what decision can
  we make based on the knowledge that [Redmonk] or [TIOBE] reports that
  some language (let's call it "wiggly") that used to be #11 is now #15,
  for example?
  - Shut down all projects written in wiggly
  - Shut down all future plans to write anything in wiggly
  - Convert all projects written in wiggly to a language in the top 10
  - Organise trainings for all wiggly people willing to evolve to
    something more fashionable and fire all those who won't

  Well, I guess we can agree all the above seems a bit over the top. But
  if you were to make such a decision, what would you do if in the next
  report, dear wiggly was to climb back to #8? And if you aren't to make
  any such decision, exactly what kind of decision can you make based on
  the report?

  Well, since this is not about the technical merits of the languages
  themselves, maybe it's about the market. So, what does it say about
  the market? Not much. We get a picture of how much activity GitHub and
  StackOverflow see for these forty languages. It doesn't say anything
  about the value of mastering these languages on the market and it
  doesn't tell anything about the value generated by these languages on
  the market either.

  So, if it's not about the technologies themselves, not about the value
  of the skills, the size of the market or what technology is right,
  then what is it about? I guess the answer is that it reflects trends
  and fashions, and I'm not sure I want to make any decision based
  solely on that.


[Redmonk] https://www.redmonk.com

[TIOBE] https://www.tiobe.com/tiobe-index/


1.2 Making decisions
~~~~~~~~~~~~~~~~~~~~

  So, if these kinds of reports aren't of any help in making decision,
  then what is?  What should we be considering? I'm not stupid enough to
  believe I hold the definitive answer to that question, but to me,
  there are a few things that you must take into account, always.


1.2.1 The team
--------------

  A project is first and foremost made up of the people involved in
  it. Besides being all sweet and cute, this sentence should act as a
  reminder that to get a project done, you need people with the right
  skills. So, whenever I need to decide on some technology, I first ask
  myself what these people know already. Especially when a project is
  about exploring new grounds, it's better to do it with a toolset you
  already master. Starting a new project, in a new domain, in a new
  language and possibly with new people seems a little risky to me. This
  is not to say that any novelty should be ruled out from the start:
  introducing new languages and technologies is healthy and useful, but
  I believe it should be done while keeping in mind a clear career path
  for the people on the team. In other words, this is long-term
  thinking, not something you revise entirely every month or even twice
  a year. As a side effect, not jumping on everything new and shiny can
  help getting a product well written, easy to maintain (or rather, not
  completely horrible to maintain, since you are less likely to discover
  unexpected shortcomings with the technology) and with a better time to
  market as a result.


1.2.2 Community and ecosystem
-----------------------------

  If the reports from Redmonk and TIOBE give some idea about the size of
  the respective communities behind the different languages, they tell
  nothing about the culture their programmers evolve in. Are they a good
  match to yours? Is there enough documentation available on your
  favourite support, be it books, forums, tutorials, mailing lists or
  IRC channels? Or are there enough open source code you can study, if
  this is how your team likes to learn about technology? Also, are there
  enough libraries available so you won't be pioneering your field in a
  language new to you? Another thing is that a large community is not
  always a good thing: as a community grows, the average skill of
  potential hires you can get from it gets lower and lower. This may or
  may not be a problem, depending on the project or the sector, but it
  is important to factor this in the equation.


1.2.3 Cost
----------

  The two considerations above already cover this item to a great
  extent, so no need to rehash everything I already said. The question
  remains the same I ask myself with any project decision: how much does
  introducing a new technology cost in short term and in the long run?
  It's not much of a surprise, but no popularity contest can provide a
  proper answer to that question.

  So, in conclusion, I really can't see the point of these reports. In
  the latest TIOBE Index for March 2017, the star is Swift, which is
  entering the top 10. Who would have guessed programming on the iPhone,
  with the technology stack actively pushed by Apple is a popular thing
  do? I certainly didn't, but I'm not losing anymore time; I already
  started rewriting all my MATLAB code in wiggly.