Lojic Technologies

Posts Tagged ‘ruby

Programming Language Popularity – Part Twelve

leave a comment »

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

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

 
See Part Eleven for prior results.

I’ve divided the table into sections based on percentage increases of more than 50% from one language to the next.

|------+-------------+------------+-------+-------|
| Rank | Language    | # Search   | Prev. |  Rank |
|      |             | Results    |  Rank | Delta |
|------+-------------+------------+-------+-------|
|    1 | C           | 27,828,000 |     1 |       |
|------+-------------+------------+-------+-------|
|    2 | R           | 17,276,800 |     2 |       |
|------+-------------+------------+-------+-------|
|    3 | Java        |  6,459,000 |     3 |       |
|------+-------------+------------+-------+-------|
|    4 | Python      |  3,132,500 |     5 |     1 |
|    5 | C++         |  2,793,400 |     4 |    -1 |
|------+-------------+------------+-------+-------|
|    6 | C#          |    944,000 |     6 |       |
|    7 | JavaScript  |    903,900 |     6 |    -1 |
|    8 | FORTRAN     |    746,200 |    10 |     2 |
|    9 | Go          |    604,300 |    15 |     6 |
|   10 | Lisp Family |    479,182 |       |       |
|   11 | Ruby        |    409,600 |    12 |     1 |
|   12 | Perl        |    392,100 |    11 |    -1 |
|------+-------------+------------+-------+-------|
|   13 | Haskell     |    207,500 |    15 |     2 |
|   14 | Scheme      |    202,390 |     8 |    -6 |
|   15 | Scala       |    197,220 |    17 |     2 |
|   16 | Prolog      |    163,200 |    20 |     4 |
|   17 | Rust        |    150,273 |    14 |    -3 |
|   18 | Lisp        |    137,620 |    13 |    -5 |
|   19 | Erlang      |    111,090 |    23 |     4 |
|   20 | Lua         |    104,300 |    23 |     3 |
|   21 | COBOL       |     87,330 |    22 |     1 |
|   22 | Common Lisp |     77,204 |    24 |     2 |
|   23 | OCaml       |     66,640 |    26 |     3 |
|   24 | Smalltalk   |     66,050 |    21 |    -3 |
|   25 | Julia       |     52,095 |    16 |    -9 |
|   26 | Forth       |     42,358 |    31 |     5 |
|   27 | Clojure     |     40,720 |    26 |    -1 |
|   28 | Elixir      |     29,396 |    33 |     5 |
|   29 | Racket      |     21,248 |    28 |    -1 |
|------+-------------+------------+-------+-------|
|   30 | Pony        |      7,926 |    27 |    -3 |
|------+-------------+------------+-------+-------|

Written by Brian Adkins

August 23, 2018 at 5:42 pm

Programming Language Popularity – Part Eleven

with one comment

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

"implemented in "
"written in "
"developed in "
"programmed in "

See Part Ten for prior results.

I’ve divided the table into sections based on percentage increases of more than 50% from one language to the next.

|------+-------------+------------+-------+-------|
| Rank | Language    |   # Search | Prev. |  Rank |
|      |             |    Results |  Rank | Delta |
|------+-------------+------------+-------+-------|
|    1 | C           | 22,403,000 |     1 |       |
|------+-------------+------------+-------+-------|
|    2 | R           |  2,089,000 |     2 |       |
|    3 | Java        |  1,684,000 |     4 |     1 |
|    4 | C++         |  1,404,500 |     3 |    -1 |
|    5 | Python      |  1,154,100 |     5 |       |
|    6 | JavaScript  |    850,500 |     7 |     1 |
|    7 | C#          |    829,600 |     6 |    -1 |
|    8 | Scheme      |    744,600 |    11 |     3 |
|    9 | Go          |    645,700 |    12 |     3 |
|   10 | FORTRAN     |    618,700 |     8 |    -2 |
|   11 | Perl        |    480,000 |     9 |    -2 |
|   12 | Ruby        |    461,660 |    10 |    -2 |
|------+-------------+------------+-------+-------|
|   13 | Lisp        |    228,370 |    15 |     2 |
|   14 | Rust        |    216,440 |    21 |     7 |
|   15 | Haskell     |    210,600 |    14 |    -1 |
|   16 | Julia       |    204,370 |    26 |    10 |
|   17 | Scala       |    188,500 |    17 |       |
|   18 | COBOL       |    181,100 |    19 |     1 |
|   19 | Common Lisp |    177,700 |    18 |    -1 |
|   20 | Prolog      |    166,100 |    16 |    -4 |
|   21 | Smalltalk   |    130,000 |    22 |     1 |
|   22 | Forth       |    114,100 |    24 |     2 |
|   23 | Lua         |    109,180 |    13 |   -10 |
|   24 | Erlang      |     78,050 |    20 |    -4 |
|   25 | Clojure     |     62,900 |    25 |       |
|   26 | OCaml       |     60,690 |    23 |    -3 |
|------+-------------+------------+-------+-------|
|   27 | Pony        |     41,129 |    27 |       |
|   28 | Racket      |     30,160 |    28 |       |
|   29 | Elixir      |     24,466 |    29 |       |
|   30 | Kotlin      |     19,077 |   N/A |       |
|------+-------------+------------+-------+-------|

Written by Brian Adkins

June 20, 2017 at 8:50 pm

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 2009October 2009October 2010September 2011August 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 2009October 2009October 2010September 2011August 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

Beware of YAML serialization on Linux without libyaml

leave a comment »

The Problem

I noticed some unusual behavior with respect to YAML String serialization between my Linux production system and my Mac OSX development system.

After dumping the production database via pg_dump -O –no-acl mydb | gzip > ~/mydb.sql.gz and then restoring it on my development system via rake db:drop; rake db:create; psql mydb < mydb.sql, I noticed that a particular serialized field in my Rails app that should always be an Array of String objects occasionally contained Integers.

After a little research and experimentation, I discovered that the production Linux system would occasionally omit quotations around Strings containing only numeric digits. I haven’t analyzed the pattern fully, but here are some examples where the YAML serialization did or did not use quotes:

  • “90103”
  • 000080
  • “000071”
  • “000124”
  • “000003”
  • 008397
  • 000408
  • 000009
  • 000188
  • “000021”

Further investigation revealed that the Linux production system was using Syck (a “dated C implementation of YAML 1.0”) and my Mac OSX development system was using psych (a “libyaml wrapper (in Ruby core for 1.9.2)”). libyaml is a “fast C implementation of YAML 1.1. So, either the quotation rules have changed between YAML 1.0 and YAML 1.1, or there is a bug in one of the implementations (likely Syck).

The Solution

The solution for proper “future” behavior is pretty simple. Install libyaml on the Linux system as follows:

wget http://pyyaml.org/download/libyaml/yaml-0.1.4.tar.gz
tar xzf yaml-0.1.4.tar.gz
cd yaml-0.1.4
./configure
make
make install

I think that’s enough, but I went ahead and rebuilt my Ruby 1.9.2 just in case it needed to know about the existence of libyaml at build time.

The solution for converting my database with YAML 1.0 serialization to YAML 1.1 serialization is a bit trickier. Since the “dump” and “load” operations are matched for a particular version of YAML, it seems difficult to load the data using YAML 1.0 (thereby retaining the String type when reading an unquoted 000088) and then dump the data using YAML 1.1 (to get proper quoting of ‘000088’). Further complicating this is the fact that Rails handles the serialization operations automatically.

It does appear possible to dynamically switch between syck and psyck by using the following:

YAML::ENGINE.yamler = 'syck'
YAML::ENGINE.yamler = 'psych'

So, one option is to repeatedly switch to syck, read in data, switch to psych, and then write the data. <sigh>

Update:

It appears that due to the semantics of the Rails serialize function, it’s not enough to just read the model object using syck and then immediately write with psych because that doesn’t appear to be enough to cause the field to be deserialized. I had to refer to the field for each object. This is a pain because it prevents me from doing a generic loop where I can handle all model objects easily w/o reference to their specific fields.

I’ll withhold judgment for a while, but my first inclination is to consider abandoning YAML serialization for something a little more robust and portable.

Update 2:

It appears my welcome from psych is a serious memory leak. I’ve been running long running Ruby/Rails processes for years, and this is the first time I’ve experienced a failure due to an out of memory condition. There are a number of Google hits regarding the issue. After I fix the leak, I’ll begin researching alternatives to YAML serialization in Rails.

Update 3:

The number of bug reports on psych and rubygems I’ve had to wade through recently is amazing. My current solution is to remove the psych system gem and install Ruby 1.9.3p0 which required upgrading Passenger to the latest version from source to get Ruby 1.9.3 compatibility. I still had to track down a few odd errors such as “undefined method `yaml’ for #<Psych::Nodes::Stream:…>” and “invalid date format in specification: “2011-10-02 00:00:00.000000000Z”” – all because I chose to use the default Rails serialization assuming there would be no issues. Lesson learned.

Written by Brian Adkins

November 22, 2011 at 2:44 pm

Posted in programming

Tagged with , ,