Around 2000 the computer power was greatly increased and interpreted languages became popular.
In compiled languages (as FORTRAN or C) the program is translated into the binary language of the machine as a whole, then executed; in interpreted languages it is instead translated during the run, statement by statement.
There is no compilation phase and the developing is faster: you can immediately see what the program produces, but the run is slower. If you have loops, each statement of the loop have to be translated at each step. You have to avoid lengthy loops. In the 80s I could have a factor of 10 for the run time of an interpreted language compared to a compiled one; but, since then, interpreters made great progresses and in 2019 I could plot a file with two million lines in minutes, using Python.
Interpreted languages has always been used to give short command to the computer. The IBM mainframe had JCL; the first CDC had also control cards to run batch jobs.
When the computers became interactive these commands become real languages, with loops, conditional statements etc. Dec VMS had DCL, the DIGITAL Command Language, and Unix had the shells; each Unix flavor its own shell: we have the Korn shell (default for IBM Risc), the C shell and also the tcsh, Bourne, Z shell etc.. All these languages where similar, with many features, and even subroutines and arrays. Linux has, among others, the bash shell, mainly used for system operations and management. I occasionally used Unix shells, as Korn shell, C-shell, Burne shell, for Unix system maintenance. and also tested TCL and Perl. I currently use the Bash shell for Linux maintenance.
When computer speed increased, people began to write more powerful interpreted languages; we had Perl, by Larry Wall (around 1985). Perl is an enhanced shell with a lot of features to deal with strings and text and a very compact syntax.
Another interpreted language was Tcl, created in 1988 by John Ousterhout at the University of California. Tcl, coupled to the Tk toolkit, was used to write simple graphical interfaces, and to glue together application written using compiled languages.
In the late eighties some powerful interpreted languages where developed, one of these is Python. Python is a very popular interpreted language, developed by Van Rossum in 1989, it has been used for one of the first open source CMS: Plone [1], which gave to the language a great visibility.
Phyton has a large library associated and a lot of auxiliary tools are produced each year. There is also a complete tool to built web applications: Django.
Python has, built into the language, complex structures as lists: sequences of items identified by an integer index, or dictionaries: collection of items with an identifier which can be anything. These structures can be nested in an arbitrary way: the management of data with a complex organization become easier.
In the following image a simple python program is shown: two strings are defined, then separated into words with the "split" function. Then a dictionary of lists is built. Al least two nested loops print the obtained dictionary.
The output produced by the program is in the following image:
Doing the same in C++ would be much longer and some external libraries where needed.
Python is also object oriented, and has many function to deal with strings, regular expressions, complex numbers, and auxiliary modules to do anything as: database access, plotting, file management, system interaction, network etc. etc. But the main advantage of Python is that it is easy, and programs can be written quickly.
There is a lot of Python documentation on in the net, many simple examples of Phyton usage can be found in my notes for a Python course (in Italian).
Another interesting interpreted language is Ruby. Ruby was developed by Yukihiro "Matz" Matsumoto, in Japan, around 1995, but remained confined to Japan for some years, only around 2000 the first English books on Ruby appeared.
Ruby is a very object oriented language, everything is an object, also primitive types, as integers float etc. It has a different philosophy than Python: there are always more ways to do the same things, it gives more choices to the developer, but sometimes there is some confusion. Rails, developed around 2005, is a successful tool, based on Ruby, to build web applications. It is similar to Django, but even easier.
Except for Japan, Python is far more popular than Ruby, which is younger and still evolving in a fast way. Python has more tools and libraries than Ruby, specially for science, data analysis and plotting.
I have also some raw notes for a Ruby course
I use today C++ for heavy computation, but Python or Ruby for everything else, as data management, plotting, data analysis, file management, database access etc. etc. I used also Rails and Django for small web application. Working with these languages is fast and easy, much easier than writing C++ or Java code.
Python and Ruby are very high-level languages, having structures and algorithms inside the language, not, as C++ or Java, implemented in external libraries. This was a main trend of computer languages in all these years: at the beginning we where writing algorithms, then we used auxiliary libraries and now algorithms are built into the languages which have a lot of features which make programming easier and faster. We have seen that simple syntax and easy of use always wins over more complex tools.
Other changes are due to the usage of big amount of data, with complex structure; the focus moved from algorithms to data structure.
Programs also became bigger and the design of graphical and user-friend interfaces added additional complexity. The solution is the use of different tools and packages to assemble complex projects, but this cause many compatibility problems, because the different tools have a different evolution and always new features which don't work with older versions.
All this fast and chaotic grow in computer programming gave us a lot: I can write in an hour a program that, forty hears ago, needed many days. But there are also many problems, because software is developed too fast, not well debugged, barely maintained and poorly documented. We can produce more complex and interesting programs than forty hears ago, but this didn't made the programmer life much easier.
| This text is released under the "Creative Commons" license. |
|