I have used Python, Java, JavaScript, PHP, and C/C++ quite a bit. What follows are my thoughts.
1. There is a general trend towards high-level interpretive languages (Python, JavaScript, PHP, Perl, etc.), and away from compiled languages (Java, C/C++, etc.). The key driver has been and remains the declining cost of hardware. Basically programmers can get a lot more work done, in less time, using interpretive languages. Of course, interpretive languages are massively slower than compiled languages. However, they doesn’t always matter a lot. Say a program would take 4 hours to write in C++, but only one hour in Python. If the Python program runs for 10 seconds on a PC, does it really matter that the C++ program would run in less than one second? Basically, cheap hardware make programmer productivity, the key issue, which favors interpretive languages.
2. These days JavaScript is actually a very good, very powerful language. Perhaps better than Python even. However, JavaScript only really works in a browser. Yes, you can use node.js. However, in my experience node.js is painful at best. For better or worse, the link between the browser and JavaScript remains firmly intact. The reverse is also true, running Python in a browser is painful at best.
3. PHP is also a rather good language these days. However, it tends to be viewed as a website tool and not as a general purpose programming language. That might not be fair, but appears to be true. PHP also suffers from a few quirks (all those dollar signs).
4. The Python 2->3 transition was hard for many folks (not me, I started with Python 3). However, it is mostly over by now. The transition did bring one rather large benefit. Python 3 fully supports Unicode. The same can not be said for a rather long list of languages.
5. As the author pointed out, Ruby has always been handicapped by its origins in Japan. That may not be fair. However, it still appears to be true.
6. Perl is just a relic from the past. Essentially nobody takes it seriously these days.
What this amounts to is that Python is the “last man standing”. Hence, the rising popularity of Python (outside of the browser).
Hello Peter, Gregory (author) here, thank you for your comment! I agree with all your points, especially the first one - I think there's no way to reverse this trend. Lower level languages will always have some share of the market, but it will shrink over time.
What I'm not sure about is why other languages did not leverage the issue with Python's migration - because that migration took really a decade, during which time Ruby became very popular thanks to Rails, and JavaScript evolved to a really solid language. Yet neither of them became popular outside of webdev. It seems that a lot of people were really attached to Python and decided that it was more beneficial to stay as long as possible on Python 2.7 and later migrate than to pick another language.
A language that has not received your attention is "REXX", and the reason is probably because you are not IBM Mainframe oriented… ...and/or because of some Microsoft actions in the past, you probably have not been exposed to the language.
While Microsoft did distribute and support REXX under the later releases of DOS and early versions of Windows, a highly confrontational series of conversations between Microsoft and IBM (while the two were working on a joint project involving OS/2) lead to Microsoft eventually removing the REXX language from the Windows operating system distribution. (A classic case of “If you don’t play by my rules, I’ll take my marbles and go home...”)
I have been told, that part of the reason for the removal, is that Microsoft wanted to make syntactical changes to the REXX language and IBM would not allow it, because it would have affected the ability of REXX to operate under a variety of different Operating System Environments, and would also affect its ability to be used as an application scripting language while also being used as an Operating System scripting language.
I have personally been using the language since the late 1980’s, and have found it’s capabilities more than adequate for the development of application systems (including the modeling of proposed designs), and for System Level utilities – not to mention it’s original design concept of being an interactive operating system scripting language (i.e. A command line “shell” processing language).
REXX was adopted by IBM to be its standardized scripting language across all of its computing platforms, (and there are many more than you can imagine!) and as a result, REXX has replaced many other operating system specific languages – end result, due to the standardization, programmers can create scripts that will run on multiple platforms “without having to make local changes” first.
There have been a number of implementations of the REXX Language ranging from the larger IBM mainframe systems (System/360, System/370, System/390, and the current System Z hardware running operating systems like: VM, MVS, OS/390, Z/OS, Z/VM, etc ) to IBM mid-range systems like the AS-400 and OS-2, and many non-IBM systems like Linux, FreeBSD, Solaris, AIX, HP-UX, DOS, Windows/2k/XP/Vista/7/8/8.1/10, MacOS X, Amiga, eCS, AROS, QNX4.x, QNX6.x, BeOS, EPOC32, AtheOS, OpenVMS, SkyOS, OpenEdition. and a host of others.
For the most part you will find two potential variations of REXX, (1) a flavor of REXX which supports the original “Classic” REXX syntax and (2) a second flavor that supports a more Object Oriented variation of REXX. You will also find versions of REXX which have been enhanced to
support specialized areas like Music and sound processing.
In the “Classic” arena you will find the IBM versions of REXX as found in the VM/CMS and MVS/TSO, and Z/OS/TSO environments. One of the first implementations of REXX outside the IBM universe was Charles Manfield’s Personal Rexx and also his KEDIT text editor that used REXX as an internal macro language. Quercus Systems produced a Terminal program that used REXX as it’s internal Macro language. Many other commercial and freeware products have also incorporated REXX as their internal Macro Language.
The 1996 American National Standard (ANSI Standard) for Rexx is called "Programming Language - REXX", and its number is X3.274-1996, which basically defines the “classic” or procedural form of the language.
A CLASSIC version of REXX known as REGINA is available on several LINUX distributions, and is downloadable from sourceforge.net Another classic version of REXX is REGINALD by Jeff Glantt
which also supports Windows GUI operations.
In the Object Oriented world, there are also several versions of REXX available. Personally I use ooRexx (downloadable from sourceforge.net) for two reasons: (1) it is fully maintained and supported by the Rexx Language Association (RexxLA) and (2) it is the only version of REXX that allows both “Classic” style coding and “Object Oriented” coding in the SAME PROGRAM.
Classic style programs (and application systems) that I wrote in REXX years ago still function in ooRexx on a variety of platforms, and I can experiment with Object Oriented style programming while still making use of a classic style programming.
OoRexx has interfaces to many other languages, for example, a programmer can create new functions in C/C++.
Java programmers can directly use ooREXX facilities, and ooRexx programmers can make use of JAVA facilities – all thru the use of an addon product called BSF4ooRexx by Rony G. Flatscher.
Windows programmers can create and maintain “application windows” via “ooDialog” facilities;
“RexxGTK” can be used to interface to GTK, and therefore build “application windows” on other platforms; “Mod_Rexx” can be used to add REXX as a CGI language to an Apache webserver;
Databases such as MySQL, SQLlite, etc., can be accessed from REXX using routines originally written for REGINA REXX;
On-line Tutorials are available by the hundreds for REXX; Excellent quality documentation is packaged with ooRexx, as both HTML files and as PDF books.
Many hardbound books are available on REXX such as M.F. Cowlishaw’s “A practical approach to Programming, The REXX language” (M.F. Cowlishaw is the language creator) and Howard Fosdick’s “REXX Programmer Reference “ (which covers some of the popular implementations of REXX.)
Some of the major features in REXX that I make heavy use of are:
• REXX does not use the concept of “DATA TYPING”...
(Character strings -vs- fixed point numbers -vs- floating point numbers, etc.) All variables are treated as character strings, and are processed as numeric values or as character strings – as appropriate in the context of the processing statement.
• The “PARSE” statement which allows the extraction and assignment of text to a series of variables based upon a “template”. The PARSE statement provides a handful of special built-in mechanisms – For example, a program can determine:
◦ from “SOURCE” a three word system-dependent information:
▪ (1) “the-name-of-the-operating- system”,
▪ (2) “how-the-script-was-invoked”,
▪ (3) the “filename-of-the-script-being executed”.
◦ or from “VERSION” five words of system-dependent “version” information:
▪ (1) Language
▪ (2) Level
▪ (3) day
▪ (4) month
▪ (5) year
◦ Or from “VALUE expression WITH” the expression can be evaluated, which will then be parsed according to the supplied template.
◦ Or PARSE can be used to take apart text on a word by word basis, or...
• The “ADDRESS” statement which directs commands to the proper external environments for execution, including to the operating system, or to a controlling application.
• The loop controls of “DO”, “WHILE”, “UNTIL”, “FOREVER”, “LEAVE”, “ITERATE”, “SIGNAL”, “RETURN”, “EXIT”.
• Logical control “IF”, “THEN”, “ELSE” and “SELECT”, “WHEN” and “OTHERWISE” statements.
• The unusual option of being able to set various aspects of numeric calculations…
all calculations are done in decimal arithmetic, both fixed point and floating point calculations are supported, SCIENTIFIC and ENGINEERING formats are supported. FUZZ controls how many digits will be ignored during comparisions. “DIGITS” sets the number of significant digits (default is 9), there is no MAX (other than the limits of physical memory).
• Array like mechanism (STEMS) that can have textual subscripts (instead of only supporting numeric subscripts). - thus allowing the construction of sparsely populated arrays, and the rough equivalent of an associative arrays.
• There are more than 70 very useful built-in functions in the classical versions of Rexx, and no limit to the number of Subroutines or functions that a programmer can create within their program.
• Open Object Rexx is compatible with earlier Rexx versions, both non-object based Rexx and IBM's Object Rexx. OoRexx also supports a full complement of Object Oriented mechanisms such as data encapsulation, polymorphism, an object class hierarchy, class-based inheritance of methods, and concurrency. It also includes a number of useful base classes and allows you create new object classes of your own. (In other words, the sky is the limit!)
All in all, REXX is a very powerful language, and yet is very simplistic in its design, and easy to learn, even for non-programmers – after all, it was designed for PEOPLE rather than for COMPUTERS.
Why, then, do we not see REXX mentioned in the media very often?
Probably because the folks who use it are employed to complete projects on time, without errors, and most are not interested in becoming writers. I also suspect that some of the work done in REXX, is considered proprietary, so of course, we wouldn’t see it published.
I have used Python, Java, JavaScript, PHP, and C/C++ quite a bit. What follows are my thoughts.
1. There is a general trend towards high-level interpretive languages (Python, JavaScript, PHP, Perl, etc.), and away from compiled languages (Java, C/C++, etc.). The key driver has been and remains the declining cost of hardware. Basically programmers can get a lot more work done, in less time, using interpretive languages. Of course, interpretive languages are massively slower than compiled languages. However, they doesn’t always matter a lot. Say a program would take 4 hours to write in C++, but only one hour in Python. If the Python program runs for 10 seconds on a PC, does it really matter that the C++ program would run in less than one second? Basically, cheap hardware make programmer productivity, the key issue, which favors interpretive languages.
2. These days JavaScript is actually a very good, very powerful language. Perhaps better than Python even. However, JavaScript only really works in a browser. Yes, you can use node.js. However, in my experience node.js is painful at best. For better or worse, the link between the browser and JavaScript remains firmly intact. The reverse is also true, running Python in a browser is painful at best.
3. PHP is also a rather good language these days. However, it tends to be viewed as a website tool and not as a general purpose programming language. That might not be fair, but appears to be true. PHP also suffers from a few quirks (all those dollar signs).
4. The Python 2->3 transition was hard for many folks (not me, I started with Python 3). However, it is mostly over by now. The transition did bring one rather large benefit. Python 3 fully supports Unicode. The same can not be said for a rather long list of languages.
5. As the author pointed out, Ruby has always been handicapped by its origins in Japan. That may not be fair. However, it still appears to be true.
6. Perl is just a relic from the past. Essentially nobody takes it seriously these days.
What this amounts to is that Python is the “last man standing”. Hence, the rising popularity of Python (outside of the browser).