Lojic Technologies

Posts Tagged ‘javascript

Programming Language Popularity ‚Äď Part Ten

with one comment

I made a number of Google searches of the forms below and summed the results:

"implemented in <language>"
"written in <language>"
"developed in <language>"
"programmed in <language>"

See Part Nine for prior results 4 months ago.

I’ve divided the table into sections based on percentage increases of more than 50% from one language to the next. To compute the rank delta, I excluded the newly added languages.

|------+-------------+------------+-------+-------|
| Rank | Language    | # Search   | Prev. |  Rank |
|      |             | Results    |  Rank | Delta |
|------+-------------+------------+-------+-------|
|    1 | C           | 30,370,000 |     1 |       |
|------+-------------+------------+-------+-------|
|    2 | R           |  4,101,600 |     2 |       |
|------+-------------+------------+-------+-------|
|    3 | C++         |  1,406,100 |     4 |     1 |
|    4 | Java        |  1,394,000 |     3 |    -1 |
|------+-------------+------------+-------+-------|
|    5 | Python      |    868,000 |     6 |     1 |
|    6 | C#          |    844,800 |     5 |    -1 |
|    7 | Javascript  |    632,600 |     7 |       |
|    8 | FORTRAN     |    548,500 |     8 |       |
|    9 | Perl        |    489,600 |     9 |       |
|   10 | Ruby        |    399,200 |    10 |       |
|   11 | Scheme      |    362,500 |    11 |       |
|   12 | Go          |    333,800 |    12 |       |
|------+-------------+------------+-------+-------|
|   13 | Lua         |    170,940 |    17 |     4 |
|   14 | Haskell     |    151,190 |    15 |     1 |
|   15 | Lisp        |    141,880 |    13 |    -2 |
|   16 | Prolog      |    139,890 |    16 |       |
|   17 | Scala       |    124,450 |    14 |    -3 |
|   18 | Common Lisp |    113,510 |    20 |     2 |
|   19 | COBOL       |    113,000 |    18 |    -1 |
|   20 | Erlang      |     80,060 |    19 |    -1 |
|   21 | Rust        |     79,650 |    21 |       |
|   22 | Smalltalk   |     73,120 |    23 |     1 |
|   23 | OCaml       |     59,970 |    24 |     1 |
|   24 | Forth       |     58,300 |    26 |     2 |
|   25 | Clojure     |     51,690 |    22 |    -3 |
|   26 | Julia       |     45,210 |    25 |    -1 |
|------+-------------+------------+-------+-------|
|   27 | Pony        |     16,927 |   N/A |   N/A |
|   28 | Racket      |     16,150 |    28 |       |
|   29 | Elixir      |     12,723 |    29 |       |
|------+-------------+------------+-------+-------|

The raw data is here:

Path=/search?q=%22written%20in%20c%22 Num=23200000
Path=/search?q=%22programmed%20in%20c%22 Num=180000
Path=/search?q=%22developed%20in%20c%22 Num=3320000
Path=/search?q=%22implemented%20in%20c%22 Num=3670000
(c 30370000)
Path=/search?q=%22written%20in%20c%23%22 Num=396000
Path=/search?q=%22programmed%20in%20c%23%22 Num=40800
Path=/search?q=%22developed%20in%20c%23%22 Num=215000
Path=/search?q=%22implemented%20in%20c%23%22 Num=193000
(c# 844800)
Path=/search?q=%22written%20in%20c%2B%2B%22 Num=477000
Path=/search?q=%22programmed%20in%20c%2B%2B%22 Num=80100
Path=/search?q=%22developed%20in%20c%2B%2B%22 Num=270000
Path=/search?q=%22implemented%20in%20c%2B%2B%22 Num=579000
(c++ 1406100)
Path=/search?q=%22written%20in%20clojure%22 Num=26300
Path=/search?q=%22programmed%20in%20clojure%22 Num=4730
Path=/search?q=%22developed%20in%20clojure%22 Num=11800
Path=/search?q=%22implemented%20in%20clojure%22 Num=8860
(clojure 51690)
Path=/search?q=%22written%20in%20cobol%22 Num=57600
Path=/search?q=%22programmed%20in%20cobol%22 Num=20900
Path=/search?q=%22developed%20in%20cobol%22 Num=18200
Path=/search?q=%22implemented%20in%20cobol%22 Num=16300
(cobol 113000)
Path=/search?q=%22written%20in%20coffeescript%22 Num=26900
Path=/search?q=%22programmed%20in%20coffeescript%22 Num=1250
Path=/search?q=%22developed%20in%20coffeescript%22 Num=4330
Path=/search?q=%22implemented%20in%20coffeescript%22 Num=2510
(coffeescript 34990)
Path=/search?q=%22written%20in%20common%20lisp%22 Num=49600
Path=/search?q=%22programmed%20in%20common%20lisp%22 Num=8110
Path=/search?q=%22developed%20in%20common%20lisp%22 Num=31500
Path=/search?q=%22implemented%20in%20common%20lisp%22 Num=24300
(common lisp 113510)
Path=/search?q=%22written%20in%20elixir%22 Num=6000
Path=/search?q=%22programmed%20in%20elixir%22 Num=3
Path=/search?q=%22developed%20in%20elixir%22 Num=2480
Path=/search?q=%22implemented%20in%20elixir%22 Num=4240
(elixir 12723)
Path=/search?q=%22written%20in%20erlang%22 Num=49300
Path=/search?q=%22programmed%20in%20erlang%22 Num=7460
Path=/search?q=%22developed%20in%20erlang%22 Num=6400
Path=/search?q=%22implemented%20in%20erlang%22 Num=16900
(erlang 80060)
Path=/search?q=%22written%20in%20forth%22 Num=21800
Path=/search?q=%22programmed%20in%20forth%22 Num=2650
Path=/search?q=%22developed%20in%20forth%22 Num=25600
Path=/search?q=%22implemented%20in%20forth%22 Num=8250
(forth 58300)
Path=/search?q=%22written%20in%20fortran%22 Num=289000
Path=/search?q=%22programmed%20in%20fortran%22 Num=29500
Path=/search?q=%22developed%20in%20fortran%22 Num=107000
Path=/search?q=%22implemented%20in%20fortran%22 Num=123000
(fortran 548500)
Path=/search?q=%22written%20in%20go%22 Num=196000
Path=/search?q=%22programmed%20in%20go%22 Num=14900
Path=/search?q=%22developed%20in%20go%22 Num=67700
Path=/search?q=%22implemented%20in%20go%22 Num=55200
(go 333800)
Path=/search?q=%22written%20in%20haskell%22 Num=85800
Path=/search?q=%22programmed%20in%20haskell%22 Num=4690
Path=/search?q=%22developed%20in%20haskell%22 Num=19500
Path=/search?q=%22implemented%20in%20haskell%22 Num=41200
(haskell 151190)
Path=/search?q=%22written%20in%20java%22 Num=535000
Path=/search?q=%22programmed%20in%20java%22 Num=112000
Path=/search?q=%22developed%20in%20java%22 Num=352000
Path=/search?q=%22implemented%20in%20java%22 Num=395000
(java 1394000)
Path=/search?q=%22written%20in%20javascript%22 Num=370000
Path=/search?q=%22programmed%20in%20javascript%22 Num=19900
Path=/search?q=%22developed%20in%20javascript%22 Num=75700
Path=/search?q=%22implemented%20in%20javascript%22 Num=167000
(javascript 632600)
Path=/search?q=%22written%20in%20julia%22 Num=23000
Path=/search?q=%22programmed%20in%20julia%22 Num=1090
Path=/search?q=%22developed%20in%20julia%22 Num=15900
Path=/search?q=%22implemented%20in%20julia%22 Num=5220
(julia 45210)
Path=/search?q=%22written%20in%20lisp%22 Num=71800
Path=/search?q=%22programmed%20in%20lisp%22 Num=7980
Path=/search?q=%22developed%20in%20lisp%22 Num=20600
Path=/search?q=%22implemented%20in%20lisp%22 Num=41500
(lisp 141880)
Path=/search?q=%22written%20in%20lua%22 Num=54800
Path=/search?q=%22programmed%20in%20lua%22 Num=3720
Path=/search?q=%22developed%20in%20lua%22 Num=5420
Path=/search?q=%22implemented%20in%20lua%22 Num=107000
(lua 170940)
Path=/search?q=%22written%20in%20ml%22 Num=77200
Path=/search?q=%22programmed%20in%20ml%22 Num=10700
Path=/search?q=%22developed%20in%20ml%22 Num=154000
Path=/search?q=%22implemented%20in%20ml%22 Num=61000
(ml 302900)
Path=/search?q=%22written%20in%20ocaml%22 Num=28300
Path=/search?q=%22programmed%20in%20ocaml%22 Num=5070
Path=/search?q=%22developed%20in%20ocaml%22 Num=12800
Path=/search?q=%22implemented%20in%20ocaml%22 Num=13800
(ocaml 59970)
Path=/search?q=%22written%20in%20perl%22 Num=342000
Path=/search?q=%22programmed%20in%20perl%22 Num=13400
Path=/search?q=%22developed%20in%20perl%22 Num=42100
Path=/search?q=%22implemented%20in%20perl%22 Num=92100
(perl 489600)
Path=/search?q=%22written%20in%20php%22 Num=461000
Path=/search?q=%22programmed%20in%20php%22 Num=36000
Path=/search?q=%22developed%20in%20php%22 Num=202000
Path=/search?q=%22implemented%20in%20php%22 Num=143000
(php 842000)
Path=/search?q=%22written%20in%20pony%22 Num=15200
Path=/search?q=%22programmed%20in%20pony%22 Num=2
Path=/search?q=%22developed%20in%20pony%22 Num=5
Path=/search?q=%22implemented%20in%20pony%22 Num=1720
(pony 16927)
Path=/search?q=%22written%20in%20prolog%22 Num=57200
Path=/search?q=%22programmed%20in%20prolog%22 Num=5090
Path=/search?q=%22developed%20in%20prolog%22 Num=27400
Path=/search?q=%22implemented%20in%20prolog%22 Num=50200
(prolog 139890)
Path=/search?q=%22written%20in%20python%22 Num=449000
Path=/search?q=%22programmed%20in%20python%22 Num=36000
Path=/search?q=%22developed%20in%20python%22 Num=131000
Path=/search?q=%22implemented%20in%20python%22 Num=252000
(python 868000)
Path=/search?q=%22written%20in%20r%22 Num=1740000
Path=/search?q=%22programmed%20in%20r%22 Num=43600
Path=/search?q=%22developed%20in%20r%22 Num=1740000
Path=/search?q=%22implemented%20in%20r%22 Num=578000
(r 4101600)
Path=/search?q=%22written%20in%20racket%22 Num=6210
Path=/search?q=%22programmed%20in%20racket%22 Num=1520
Path=/search?q=%22developed%20in%20racket%22 Num=5090
Path=/search?q=%22implemented%20in%20racket%22 Num=3330
(racket 16150)
Path=/search?q=%22written%20in%20ruby%22 Num=248000
Path=/search?q=%22programmed%20in%20ruby%22 Num=49800
Path=/search?q=%22developed%20in%20ruby%22 Num=37100
Path=/search?q=%22implemented%20in%20ruby%22 Num=64300
(ruby 399200)
Path=/search?q=%22written%20in%20rust%22 Num=39200
Path=/search?q=%22programmed%20in%20rust%22 Num=2120
Path=/search?q=%22developed%20in%20rust%22 Num=28800
Path=/search?q=%22implemented%20in%20rust%22 Num=9530
(rust 79650)
Path=/search?q=%22written%20in%20scala%22 Num=77300
Path=/search?q=%22programmed%20in%20scala%22 Num=2550
Path=/search?q=%22developed%20in%20scala%22 Num=15500
Path=/search?q=%22implemented%20in%20scala%22 Num=29100
(scala 124450)
Path=/search?q=%22written%20in%20scheme%22 Num=58000
Path=/search?q=%22programmed%20in%20scheme%22 Num=11200
Path=/search?q=%22developed%20in%20scheme%22 Num=213000
Path=/search?q=%22implemented%20in%20scheme%22 Num=80300
(scheme 362500)
Path=/search?q=%22written%20in%20smalltalk%22 Num=27200
Path=/search?q=%22programmed%20in%20smalltalk%22 Num=9920
Path=/search?q=%22developed%20in%20smalltalk%22 Num=13200
Path=/search?q=%22implemented%20in%20smalltalk%22 Num=22800
(smalltalk 73120)
Path=/search?q=%22written%20in%20sml%22 Num=7430
Path=/search?q=%22programmed%20in%20sml%22 Num=2200
Path=/search?q=%22developed%20in%20sml%22 Num=6370
Path=/search?q=%22implemented%20in%20sml%22 Num=15300
(sml 31300)
Path=/search?q=%22written%20in%20standard%20ml%22 Num=9820
Path=/search?q=%22programmed%20in%20standard%20ml%22 Num=2060
Path=/search?q=%22developed%20in%20standard%20ml%22 Num=9
Path=/search?q=%22implemented%20in%20standard%20ml%22 Num=15700
(standard ml 27589)

Written by Brian Adkins

February 24, 2016 at 4:35 pm

Programming Language Popularity – Part Nine

with one comment

I made a number of Google searches of the forms below and summed the results:

"implemented in <language>"
"written in <language>"
"developed in <language>"
"programmed in <language>"

See Part Eight for prior results 17 months ago. I finally got around to writing a program (in Racket) to automate the collection of the search results, so it was much easier!

I’ve divided the table into sections based on percentage increases of more than 50% from one language to the next. To compute the rank delta, I excluded the newly added languages.

|------+-----------------+------------+-------+-------|
| Rank | Language        | # Search   | Prev. |  Rank |
|      |                 | Results    |  Rank | Delta |
|------+-----------------+------------+-------+-------|
|    1 | C               | 54,696,000 |     2 |     1 |
|------+-----------------+------------+-------+-------|
|    2 | R               | 22,784,600 |    12 |    10 |
|------+-----------------+------------+-------+-------|
|    3 | Java            |  1,490,000 |     6 |     3 |
|    4 | C++             |  1,256,600 |     3 |    -1 |
|    5 | PHP             |  1,082,000 |     1 |    -4 |
|    6 | C#              |  1,065,900 |     5 |    -1 |
|    7 | Python          |  1,016,500 |     4 |    -3 |
|    8 | Lisp Family (1) |    951,300 |    11 |     3 |
|    9 | JavaScript      |    764,100 |     8 |    -1 |
|   10 | FORTRAN         |    565,000 |     9 |    -1 |
|   11 | Perl            |    541,700 |     7 |    -4 |
|   12 | Ruby            |    509,900 |    10 |    -2 |
|   13 | ML Family (2)   |    445,716 |    13 |       |
|   14 | Scheme          |    381,200 |    19 |     5 |
|   15 | Go              |    378,200 |    16 |     1 |
|   16 | (S)ML (3)       |    376,116 |    21 |     5 |
|   17 | Lisp            |    357,900 |    15 |    -2 |
|------+-----------------+------------+-------+-------|
|   18 | Scala           |    236,770 |    23 |     5 |
|   19 | Haskell         |    220,580 |    17 |    -2 |
|   20 | Prolog          |    152,450 |    20 |       |
|   21 | Lua             |    133,360 |    22 |     1 |
|   22 | COBOL           |    113,700 |    14 |    -8 |
|   23 | Erlang          |    101,840 |    18 |    -5 |
|   24 | Common Lisp     |    100,580 |    25 |     1 |
|   25 | Rust            |     90,860 |   N/A |   N/A |
|   26 | Clojure         |     85,930 |    27 |     2 |
|   27 | Smalltalk       |     75,000 |    24 |    -2 |
|   28 | OCaml           |     69,600 |    26 |    -1 |
|   29 | Coffeescript    |     60,420 |    29 |     1 |
|   30 | Julia           |     51,315 |   N/A |   N/A |
|   31 | Forth           |     50,920 |    28 |    -1 |
|------+-----------------+------------+-------+-------|
|   32 | Racket          |     25,660 |    30 |       |
|------+-----------------+------------+-------+-------|
|   33 | Elixir          |      8,112 |   N/A |   N/A |
|------+-----------------+------------+-------+-------|

Update Oct. 6: I added Bing search results, and they’re significantly different. For a while Elixir was #2 because one of the four phrases resulted in no results, so Bing automatically switched to an unquoted search which skewed the results. I caught that and looked over the raw data and didn’t see anything similar for other languages. It’s interesting that C# came out #1 on Bing ūüôā

|------+-----------------+----------|
| Rank | Language        | # Search |
|      |                 |  Results |
|------+-----------------+----------|
|    1 | C#              | 32100000 |
|    2 | C++             | 31900000 |
|------+-----------------+----------|
|    3 | C               |  4845000 |
|    4 | Java            |  3319000 |
|------+-----------------+----------|
|    5 | R               |  1219310 |
|    6 | Python          |  1123700 |
|    7 | Php             |  1093800 |
|    8 | Javascript      |   945200 |
|------+-----------------+----------|
|    9 | Lisp Family (1) |   525530 |
|   10 | Perl            |   460360 |
|   11 | Common Lisp     |   398039 |
|   12 | Ruby            |   301740 |
|   13 | Go              |   270593 |
|   14 | FORTRAN         |   245500 |
|   15 | Lua             |   214200 |
|   16 | Scala           |   188570 |
|   17 | Haskell         |   188520 |
|   18 | Lisp            |   160930 |
|   19 | COBOL           |   140910 |
|   20 | Scheme          |    98012 |
|   21 | ML Family (2)   |    97425 |
|   22 | Prolog          |    75740 |
|   23 | Erlang          |    63270 |
|   24 | (S)ML (3)       |    56375 |
|   25 | OCaml           |    41050 |
|   26 | Smalltalk       |    27960 |
|   27 | Julia           |    25319 |
|   28 | Clojure         |    23091 |
|   29 | Coffeescript    |    20322 |
|   30 | Forth           |    17529 |
|   31 | Rust            |    17086 |
|------+-----------------+----------|
|   32 | Racket          |     6388 |
|------+-----------------+----------|
|   33 | Elixir          |     2542 |
|------+-----------------+----------|

Here is the delta difference between Google and Bing:

|--------+------+-------+-----------------|
| Google | Bing | Delta | Language        |
|   Rank | Rank | G - B |                 |
|--------+------+-------+-----------------|
|      1 |    3 |    -2 | C               |
|      2 |    5 |    -3 | R               |
|      3 |    4 |    -1 | Java            |
|      4 |    2 |     2 | C++             |
|      5 |    7 |    -2 | Php             |
|      6 |    1 |     5 | C#              |
|      7 |    6 |     1 | Python          |
|      8 |    9 |    -1 | Lisp Family (1) |
|      9 |    8 |     1 | Javascript      |
|     10 |   14 |    -4 | FORTRAN         |
|     11 |   10 |     1 | Perl            |
|     12 |   12 |       | Ruby            |
|     13 |   21 |    -8 | ML Family (2)   |
|     14 |   20 |    -6 | Scheme          |
|     15 |   13 |     2 | Go              |
|     16 |   24 |    -8 | (S)ML (3)       |
|     17 |   18 |    -1 | Lisp            |
|     18 |   16 |     2 | Scala           |
|     19 |   17 |     2 | Haskell         |
|     20 |   22 |    -2 | Prolog          |
|     21 |   15 |     6 | Lua             |
|     22 |   19 |     3 | COBOL           |
|     23 |   23 |       | Erlang          |
|     24 |   11 |    13 | Common Lisp     |
|     25 |   31 |    -6 | Rust            |
|     26 |   28 |    -2 | Clojure         |
|     27 |   26 |     1 | Smalltalk       |
|     28 |   25 |     3 | OCaml           |
|     29 |   29 |       | Coffeescript    |
|     30 |   27 |     3 | Julia           |
|     31 |   30 |     1 | Forth           |
|     32 |   32 |       | Racket          |
|     33 |   33 |       | Elixir          |
|--------+------+-------+-----------------|

(1) combines Lisp, Common Lisp, Scheme, Clojure & Racket
(2) combines (S)ML & OCaml
(3) summed separate searches for standard ml, sml & ml

Written by Brian Adkins

October 6, 2015 at 3:53 am

Programming Language Popularity – Part Eight

with 2 comments

I compiled some programming language popularity statistics in¬†April 2009,¬†October 2009,¬†October 2010,¬†September 2011,¬†August 2012, Februrary 2013 and September 2013. Here’s an update for May 2014:

I made a number of Google searches of the forms below and summed the results:

"implemented in <language>"
"written in <language>"
"developed in <language>"
"programmed in <language>"

I’ve divided the table into sections based on large percentage drops from one language to the next.

|------+-----------------+------------+-------+-------|
| Rank | Language        | # Search   | Prev. |  Rank |
|      |                 | Results    |  Rank | Delta |
|------+-----------------+------------+-------+-------|
|    1 | PHP             | 41,418,000 |     1 |       |
|------+-----------------+------------+-------+-------|
|    2 | C               | 22,892,000 |     2 |       |
|    3 | C++             | 15,498,000 |     4 |     1 |
|    4 | Python          | 13,313,000 |     3 |    -1 |
|    5 | C#              | 12,279,000 |     5 |       |
|------+-----------------+------------+-------+-------|
|    6 | Java            |  6,997,000 |     6 |       |
|    7 | Perl            |  5,857,000 |     7 |       |
|    8 | JavaScript      |  4,917,000 |     8 |       |
|------+-----------------+------------+-------+-------|
|    9 | FORTRAN         |  3,124,000 |    10 |     1 |
|   10 | Ruby            |  3,066,000 |     9 |    -1 |
|   11 | Lisp Family (1) |  2,106,580 |    11 |       |
|------+-----------------+------------+-------+-------|
|   12 | R               |  1,267,000 |    16 |     4 |
|   13 | ML Family (2)   |    874,760 |    12 |    -1 |
|   14 | COBOL           |    731,600 |    17 |     3 |
|   15 | Lisp            |    711,300 |    18 |     3 |
|   16 | Go              |    650,970 |    23 |     7 |
|   17 | Haskell         |    629,700 |    20 |     3 |
|   18 | Erlang          |    594,900 |    19 |     1 |
|   19 | Scheme          |    580,800 |    24 |     5 |
|   20 | Prolog          |    542,200 |    14 |    -6 |
|   21 | (S)ML (3)       |    505,160 |    21 |       |
|   22 | Lua             |    490,700 |    13 |    -9 |
|   23 | Scala           |    472,300 |    25 |     2 |
|   24 | Smalltalk       |    407,400 |    15 |    -9 |
|   25 | Common Lisp     |    396,380 |    22 |    -3 |
|   26 | OCaml           |    369,600 |    26 |       |
|   27 | Clojure         |    302,220 |    27 |       |
|------+-----------------+------------+-------+-------|
|   28 | Forth           |    199,730 |    28 |       |
|   29 | CoffeeScript    |    192,366 |    30 |     1 |
|------+-----------------+------------+-------+-------|
|   30 | Racket          |    115,880 |    29 |    -1 |
|------+-----------------+------------+-------+-------|

(1) combines Lisp, Common Lisp, Scheme, Clojure & Racket
(2) combines (S)ML & OCaml
(3) summed separate searches for standard ml, sml & ml

Written by Brian Adkins

May 20, 2014 at 8:31 pm

My Top 10 Programming Languages of Interest for 2013-2014

with 6 comments

The End of Moore’s Law

For the last few years (since 2009), I’ve been pitching the idea to
my peers that language speed & concurrency/parallel capabilities
will become more important as CPU clock speeds plateau and
manufacturers add more CPU cores instead of advancing clock
rates. My 2+ year old Macbook Pro has 4 cores and
8 hyperthreads.

I, and many of my peers, program primarily in Ruby which is one of
the slowest languages, but is also one of the most productive. Even
though Ruby is often on the critical path (as opposed to the
database, network, ec.), with caching provided by Rails, more server
resources, client side processing with JavaScript, etc., the
productivity of Ruby has thus far outweighed the slowness
disadvantage (enter mantra “hardware is cheaper than developers”),
so I haven’t received much (any?) buy in from the programmers I hang
with.

Programmer productivity will continue to be important, but the
question that I’ve been considering has been, “What if a language
provides the same productivity as Ruby, but much better resource
efficiency?”

The minimum bar for efficiency is fuzzy & variable, but I’ve
nonetheless discounted any language below that bar. Except for R
which would be a special purpose language for me, I’m not
considering any language below the Racket/Clojure level of
efficiency for the future, and ideally the language has a good
concurrency/parallelism story.

Clojure

“A Lisp for Functional Programming symbiotic with an established
Platform designed for Concurrency.”

Reasons for interest:

  • A lisp
  • Macros
  • Functional programming
  • Concurrency
  • Efficiency
  • Concision
  • Clojurescript
  • Community

Common Lisp

“Common Lisp is a general-purpose, multi-paradigm programming
language. It supports a combination of procedural, functional, and
object-oriented programming paradigms. As a dynamic programming
language, it facilitates evolutionary and incremental software
development, with iterative compilation into efficient run-time
programs.”

Reasons for interest:

  • A lisp
  • Macros
  • Multi-paradigm
  • Efficiency
  • Huge standard library

Go

“Go is an open source programming environment that makes it easy to
build simple, reliable, and efficient software.”

Reasons for interest:

  • C replacement
  • Efficiency
  • Concurrency
  • Systems programming
  • Concision

Haskell

“Haskell is an advanced purely-functional programming language. An
open-source product of more than twenty years of cutting-edge
research, it allows rapid development of robust, concise, correct
software. With strong support for integration with other languages,
built-in concurrency and parallelism, debuggers, profilers, rich
libraries and an active community, Haskell makes it easier to
produce flexible, maintainable, high-quality software.”

Reasons for interest:

  • Functional programming
  • Concision
  • Purity
  • Advanced type system
  • Parallelism & concurrency
  • Efficiency
  • Monads
  • Community

J

“J is a modern, high-level, general-purpose, high-performance
programming language. J is particularly strong in the mathematical,
statistical, and logical analysis of data.”

Reasons for interest:

  • APL-like power with a normal keyboard
  • Array language
  • Concision
  • Big data

JavaScript

The language of the web.

Reasons for interest:

  • Only game in town for browsers
  • Compilation target for browsers

Prolog

“Prolog is a high-level programming language based on formal
logic. Unlike traditional programming languages that are based on
performing sequences of commands, Prolog is based on defining and
then solving logical formulas. Prolog is sometimes called a
declarative language or a rule-based language because its programs
consist of a list of facts and rules. Prolog is used widely for
artificial intelligence applications, particularly expert systems.”

Reasons for interest:

  • Logic language
  • A new paradigm
  • AI

R

“R is a language and environment for statistical computing and
graphics. It is a GNU project which is similar to the S language and
environment which was developed at Bell Laboratories (formerly AT&T,
now Lucent Technologies) by John Chambers and colleagues. R can be
considered as a different implementation of S. There are some
important differences, but much code written for S runs unaltered
under R.”

Reasons for interest:

  • Statistics
  • Big data
  • Extensive statistical/numerical library

Racket

“Racket (formerly named PLT Scheme) is a general purpose,
multi-paradigm programming language in the Lisp/Scheme family. One
of its design goals is to serve as a platform for language creation,
design, and implementation. The language is used in a variety of
contexts such as scripting, general-purpose programming, computer
science education, and research.”

Reasons for interest:

  • A lisp
  • Functional programming
  • Continuations
  • Hygienic macros
  • Concurrency
  • Efficiency
  • Built-in web server
  • Concision
  • Can be small & clean
  • pg used it to implement Arc

Ruby

“Ruby is a language of careful balance. Its creator, Yukihiro ‚ÄúMatz‚ÄĚ
Matsumoto, blended parts of his favorite languages (Perl, Smalltalk,
Eiffel, Ada, and Lisp) to form a new language that balanced
functional programming with imperative programming.”

Reasons for interest:

  • Joy to program
  • Concision
  • Rails
  • Community
  • Primary revenue generating language currently
  • Dead slow, but lovable

Summary

I hope to decide on which of the three lisps I want to pursue,
determine if J can supplant R, and see if Go can be replaced with
one of the others, so that would leave six.

  • Haskell
  • J
  • JavaScript
  • A lisp
  • Prolog
  • Ruby

I’ve briefly researched Erlang, Factor, Lua, OCaml, Scala, Smalltalk
& Standard ML. At the moment, I don’t feel they should replace any
of the languages on the above list for subjective, practical and/or
technical reasons, but if you’re excited about those languages, or
others, comments are welcome.

Standard ML came close to bumping Haskell from the list, but despite
the nicety of SML and the advocacy of Robert Harper, I felt the
platforms (compilers, runtimes, libraries, etc.) were antiquated and
dividing/conquering themselves, so I couldn’t trust them to advance
quickly enough – particularly in the area of parallelism &
concurrency.

Update 1/17/2014:
For a lower level language, I think the D language is a candidate to replace Go. For numerical & statistical computing, I think Julia is a candidate to replace R. Lastly, I think other Scheme languages that are candidates to replace Racket include Gambit, Bigloo and Chicken.

Update 5/27/2014:
My final list of languages to spend time in, in order of priority is:

  1. Haskell, Racket & Common Lisp (concurrently)
  2. Julia
  3. J
  4. Prolog

Notably absent are Clojure (replaced by Racket and Common Lisp), Go (other languages on the list are efficient enough), R (replaced by Julia), JavaScript & Ruby (I currently use them in my work).

Written by Brian Adkins

September 27, 2013 at 2:21 am

Programming Language Popularity – Part Seven

with 2 comments

I compiled some programming language popularity statistics in¬†April 2009,¬†October 2009,¬†October 2010,¬†September 2011,¬†August 2012¬†and Februrary 2013. Here’s an update for September 2013:

I made a number of Google searches of the forms below and summed the results:

"implemented in <language>"
"written in <language>"
"developed in <language>"
"programmed in <language>"

I’ve divided the table into sections based on large percentage drops from one language to the next.

|------+-----------------+------------+----------+-------|
| Rank | Language        | # Results  | Previous |  Rank |
|      |                 |            |     Rank | Delta |
|------+-----------------+------------+----------+-------|
|    1 | PHP             | 54,516,000 |        1 |       |
|------+-----------------+------------+----------+-------|
|    2 | C               | 31,536,000 |        2 |       |
|    3 | Python          | 24,700,000 |        4 |     1 |
|    4 | C++             | 22,697,000 |        3 |    -1 |
|    5 | C#              | 20,309,000 |        5 |       |
|------+-----------------+------------+----------+-------|
|    6 | Java            | 13,314,000 |        7 |     1 |
|    7 | Perl            | 11,588,000 |        6 |    -1 |
|------+-----------------+------------+----------+-------|
|    8 | JavaScript      |  6,389,000 |        8 |       |
|    9 | Ruby            |  4,710,000 |        9 |       |
|   10 | FORTRAN         |  4,167,000 |       11 |     1 |
|------+-----------------+------------+----------+-------|
|   11 | Lisp Family (1) |  2,444,860 |       10 |    -1 |
|   12 | ML Family (2)   |  1,787,586 |       16 |     4 |
|   13 | Lua             |  1,653,100 |       15 |     2 |
|   14 | Prolog          |  1,389,900 |       22 |     8 |
|   15 | Smalltalk       |  1,003,200 |       27 |    12 |
|   16 | R               |  1,000,700 |       13 |    -3 |
|   17 | COBOL           |    856,500 |       18 |     1 |
|   18 | Lisp            |    835,600 |       12 |    -6 |
|   19 | Erlang          |    808,400 |       17 |    -2 |
|   20 | Haskell         |    798,700 |       19 |    -1 |
|------+-----------------+------------+----------+-------|
|   21 | (S)ML (3)       |    559,186 |       23 |     2 |
|   22 | Common Lisp     |    548,100 |       20 |    -2 |
|   23 | Go              |    490,230 |       28 |     5 |
|   24 | Scheme          |    487,100 |       25 |     1 |
|   25 | Scala           |    481,100 |       24 |    -1 |
|   26 | OCaml           |    429,700 |       21 |    -5 |
|   27 | Clojure         |    352,000 |       30 |     3 |
|------+-----------------+------------+----------+-------|
|   28 | Forth           |    230,630 |       31 |     3 |
|   29 | Racket          |    222,060 |       33 |     4 |
|   30 | CoffeeScript    |    205,809 |       29 |    -1 |
|------+-----------------+------------+----------+-------|

(1) combines Lisp, Common Lisp, Scheme, Clojure & Racket
(2) combines Haskell, (S)ML & OCaml
(3) summed separate searches for standard ml, sml & ml

Written by Brian Adkins

September 12, 2013 at 2:30 am

Programming Language Popularity – Part Six

with 3 comments

I compiled some programming language popularity statistics in April 2009, October 2009, October 2010, September 2011 and August 2012 . Here’s an update for February 2013:

I made a number of Google searches of the forms below and summed the results:

"implemented in <language>"
  "written in <language>"

Naturally this is of very limited utility, and the numbers are only useful when comparing relatively within the same search since the number of results Google returns can vary greatly over time.

I’ve divided the table into sections based on large percentage drops from one language to the next.

|------+-----------------+------------+----------+-------+------------|
| Rank | Language        |    # Search| Previous |  Rank | Delta from |
|      |                 |     Results|     Rank | Delta |    Apr '09 |
|------+-----------------+------------+----------+-------+------------|
|    1 | PHP             |  52,699,000|        1 |       |          3 |
|    2 | C               |  39,330,000|        2 |       |         -1 |
|    3 | C++             |  26,490,000|        4 |     1 |            |
|    4 | Python          |  22,410,000|        3 |    -1 |          1 |
|    5 | C#              |  21,474,000|        5 |       |          2 |
|------+-----------------+------------+----------+-------+------------|
|    6 | Perl            |  11,013,000|        8 |     2 |            |
|    7 | Java            |  10,150,000|        6 |    -1 |         -5 |
|    8 | JavaScript      |   7,340,000|        9 |     1 |          1 |
|------+-----------------+------------+----------+-------+------------|
|    9 | Ruby            |   3,456,000|        7 |    -2 |          1 |
|   10 | Lisp Family (1) |   2,955,000|       10 |       |         -2 |
|   11 | FORTRAN         |   2,256,000|       11 |       |        N/A |
|   12 | Lisp            |   1,708,000|       17 |     5 |            |
|   13 | R               |   1,305,000|       21 |     8 |        N/A |
|   14 | Tcl             |   1,072,100|       13 |    -1 |         -1 |
|   15 | Lua             |   1,011,000|       19 |     4 |          5 |
|   16 | ML Family (2)   |     988,400|       16 |       |         -2 |
|   17 | Erlang          |     842,000|       18 |     1 |         -1 |
|   18 | COBOL           |     729,200|       23 |     5 |        N/A |
|   19 | Haskell         |     707,000|       12 |    -7 |         -4 |
|   20 | Common Lisp     |     557,000|       20 |       |         -2 |
|   21 | OCaml           |     528,000|       24 |     3 |         -4 |
|   22 | Prolog          |     521,000|       25 |     3 |         -3 |
|   23 | (S)ML (3)       |     496,800|       27 |     4 |          1 |
|   24 | Scala           |     426,100|       22 |    -2 |          1 |
|   25 | Scheme          |     347,000|       28 |     3 |        -14 |
|   26 | Groovy          |     320,000|       14 |   -12 |        N/A |
|------+-----------------+------------+----------+-------+------------|
|   27 | Smalltalk       |     201,400|       29 |     2 |         -6 |
|   28 | Go              |     201,200|       15 |   -13 |        N/A |
|   29 | CoffeeScript    |     182,800|       31 |     2 |        N/A |
|   30 | Clojure         |     173,100|       30 |       |         -2 |
|   31 | Forth           |     128,800|       26 |    -5 |         -8 |
|   32 | Caml            |     102,600|       34 |     2 |         -6 |
|   33 | Racket          |      93,500|       33 |       |        N/A |
|   34 | Arc             |      76,400|       32 |    -2 |        -12 |
|   35 | Io              |      60,200|       35 |       |         -8 |
|------+-----------------+------------+----------+-------+------------|

(1) combines Lisp, Scheme, Common Lisp, Racket, Arc & Clojure
(2) combines OCaml, (S)ML, Caml
(3) summed separate searches for standard ml, sml & ml

Written by Brian Adkins

February 23, 2013 at 2:59 pm

Programming Language Popularity ‚Äď Part Five

with 5 comments

I compiled some programming language popularity statistics in April 2009, October 2009, October 2010 and September 2011 . Here’s an update for August 2012:

I made a number of Google searches of the forms below and summed the results (some earlier posts averaged the results):

"implemented in <language>"
  "written in <language>"

Naturally this is of very limited utility, and the numbers are only useful when comparing relatively within the same search since the number of results Google returns can vary greatly over time.

While formatting the table, I noticed there was a fairly natural break into three sections. Languages more popular than FORTRAN, languages between FORTRAN and COBOL and languages less popular than COBOL, so I highlighted the three sections :). I’m curious to see if any languages jump into a higher or lower section next time.

I also switched from HTML to using Emacs org-mode to create a textual table since the latter is so much nicer to deal with.

Update 8/5/12: Someone on the TriFunc mailing list mentioned the omission of Groovy. I don’t feel like updating the table, but I’ll record the total number of results here to allow for a comparison next time. Groovy came in at 460,300 results which puts it above Go and in the middle section.

|----+-----------------+------------+----------+----------+------------|
|    | Language        |   # Search | Previous | Position | Delta from |
|    |                 |    Results | Position |    Delta |    Apr '09 |
|----+-----------------+------------+----------+----------+------------|
|  1 | PHP             | 21,120,000 |        2 |        1 |          3 |
|  2 | C               | 15,440,000 |        1 |       -1 |         -1 |
|  3 | Python          | 11,441,000 |        4 |        1 |          2 |
|  4 | C++             |  9,788,000 |        3 |       -1 |         -1 |
|  5 | C#              |  8,319,000 |        5 |        0 |          2 |
|  6 | Java            |  6,020,000 |        6 |        0 |         -4 |
|  7 | Ruby            |  4,784,000 |        9 |        2 |          3 |
|  8 | Perl            |  4,183,000 |        7 |       -1 |         -2 |
|  9 | JavaScript      |  3,117,000 |        8 |       -1 |          0 |
| 10 | Lisp Family (1) |    898,680 |       10 |        0 |         -2 |
|----+-----------------+------------+----------+----------+------------|
| 11 | FORTRAN         |    795,500 |       11 |        0 |        N/A |
|----+-----------------+------------+----------+----------+------------|
| 12 | Haskell         |    490,000 |       14 |        2 |          3 |
| 13 | Tcl             |    476,000 |       12 |       -1 |          0 |
| 14 | Go              |    391,100 |      N/A |      N/A |        N/A |
| 15 | ML Family (2)   |    375,780 |       17 |        2 |         -1 |
| 16 | Lisp            |    352,000 |       13 |       -3 |         -4 |
| 17 | Erlang          |    334,000 |       15 |       -2 |         -1 |
| 18 | Lua             |    304,000 |       16 |       -2 |          2 |
| 19 | Common Lisp     |    256,000 |       19 |        0 |         -1 |
| 20 | R               |    221,000 |      N/A |      N/A |        N/A |
| 21 | Scala           |    219,000 |       22 |        1 |          4 |
|----+-----------------+------------+----------+----------+------------|
| 22 | COBOL           |    218,600 |       18 |       -4 |        N/A |
|----+-----------------+------------+----------+----------+------------|
| 23 | OCaml           |    181,100 |       20 |       -3 |         -6 |
| 24 | Prolog          |    176,300 |       21 |       -3 |         -5 |
| 25 | Forth           |    168,700 |       27 |        2 |         -2 |
| 26 | (S)ML (3)       |    159,700 |       26 |        0 |         -2 |
| 27 | Scheme          |    135,500 |       23 |       -4 |        -16 |
| 28 | Smalltalk       |    114,500 |       24 |       -4 |         -7 |
| 29 | Clojure         |     74,500 |       25 |       -4 |          0 |
| 30 | CoffeeScript    |     68,660 |      N/A |      N/A |        N/A |
| 31 | Arc             |     40,990 |       30 |       -1 |         -9 |
| 32 | Racket          |     39,690 |      N/A |      N/A |        N/A |
| 33 | Caml            |     34,980 |       28 |       -5 |         -7 |
| 34 | Io              |     23,110 |       29 |       -5 |         -7 |
|----+-----------------+------------+----------+----------+------------|

(1) combines Lisp, Scheme, Common Lisp, Racket, Arc & Clojure
(2) combines OCaml, (S)ML, Caml
(3) summed separate searches for standard ml, sml & ml

Written by Brian Adkins

August 4, 2012 at 12:38 pm