Lojic Technologies

Archive for the ‘programming’ Category

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

Upgrading to Emacs 24.5

leave a comment »

I previously wrote a post about switching from Carbon Emacs to Gnu Emacs. Upgrading is pretty simple now, so I thought I’d record the procedure for installing Emacs from source on OSX for future reference:

  1. Go here and click on a mirror link
  2. Download the appropriate file, e.g. emacs-24.5.tar.gz
  3. tar xzf emacs-24.5.tar.gz
  4. cd emacs-24.5
  5. ./configure –with-ns
  6. make install
  7. drag nextstep/Emacs.app to the Applications directory

Emacs is still awesome!

Written by Brian Adkins

January 27, 2016 at 9:40 pm

Posted in programming

Tagged with

How to Write a Spelling Corrector in Racket

with one comment

In September, 2008, I translated Peter Norvig’s spelling corrector into Ruby. My current favorite language is Racket, so I thought it would be a good exercise to port it to Racket. After some helpful tips by Vincent St-Amour and Sam Tobin-Hochstadt in the #racket IRC channel, I came up with the following. I’ll show it two different ways, the first minimizes the line count (without sacrificing too much stylistically) to 27 lines, and the second is closer to how I’d normally format it:

#lang racket

(define (words text) (regexp-match* #rx"[a-z]+" (string-downcase text)))

(define (train features)
  (define model (make-hash))
  (for ([f features]) (hash-update! model f add1 1)) model)

(define nwords (train (words (file->string "big.txt"))))

(define (edits1 word)
  (let* ([alphabet "abcdefghijklmnopqrstuvwxyz"]
         [splits (for/list ([i (in-range (+ (string-length word) 1))])
                   (cons (substring word 0 i) (substring word i)))]
         [deletes (for/set ([(a b) (in-dict splits)] #:when (> (string-length b) 0))
                    (string-append a (substring b 1)))]
         [transposes (for/set ([(a b) (in-dict splits)] #:when (> (string-length b) 1))
                       (string-append a (substring b 1 2) (substring b 0 1) (substring b 2)))]
         [replaces (for/set ([(a b) (in-dict splits)] #:when (> (string-length b) 0) [c alphabet])
                     (string-append a (string c) (substring b 1)))]
         [inserts (for*/set ([(a b) (in-dict splits)] [c alphabet])
                    (string-append a (string c) b))])
    (set-union deletes transposes replaces inserts)))

(define (known-edits2 word)
  (for*/set ([e1 (edits1 word)] [e2 (edits1 e1)] #:when (hash-has-key? nwords e2)) e2))

(define (known words) (for/set ([w words] #:when (hash-has-key? nwords w)) w))

(define (nes set) (if (set-empty? set) #f set))

(define (correct word)
  (let ([candidates (or (nes (known (list word))) (nes (known (edits1 word)))
                        (nes (known-edits2 word)) (set word))])
    (argmax (λ (x) (hash-ref nwords x 1)) (set->list candidates))))

 

And here is a more aesthetically pleasing format:

 

#lang racket

(define (words text)
  (regexp-match* #rx"[a-z]+" (string-downcase text)))

(define (train features)
  (define model (make-hash))
  (for ([f features])
    (hash-update! model f add1 1))
  model)

(define nwords
  (train (words (file->string "big.txt"))))

(define (edits1 word)
  (let* ([alphabet "abcdefghijklmnopqrstuvwxyz"]
         [splits (for/list ([i (in-range (+ (string-length word) 1))])
                   (cons (substring word 0 i) (substring word i)))]
         [deletes (for/set ([(a b) (in-dict splits)]
                            #:when (> (string-length b) 0))
                    (string-append a (substring b 1)))]
         [transposes (for/set ([(a b) (in-dict splits)]
                               #:when (> (string-length b) 1))
                       (string-append a
                                      (substring b 1 2)
                                      (substring b 0 1)
                                      (substring b 2)))]
         [replaces (for/set ([(a b) (in-dict splits)]
                             #:when (> (string-length b) 0)
                             [c alphabet])
                     (string-append a (string c) (substring b 1)))]
         [inserts (for*/set ([(a b) (in-dict splits)]
                             [c alphabet])
                    (string-append a (string c) b))])
    (set-union deletes transposes replaces inserts)))

(define (known-edits2 word)
  (for*/set ([e1 (edits1 word)]
             [e2 (edits1 e1)]
             #:when (hash-has-key? nwords e2))
    e2))

(define (known words)
  (for/set ([w words] #:when (hash-has-key? nwords w))
    w))

(define (nes set)
  (if (set-empty? set)
      #f
      set))

(define (correct word)
  (let ([candidates (or (nes (known (list word)))
                        (nes (known (edits1 word)))
                        (nes (known-edits2 word))
                        (set word))])
    (argmax (λ (x) (hash-ref nwords x 1)) (set->list candidates))))

Written by Brian Adkins

October 16, 2015 at 12:36 am

Posted in programming

Tagged with

DSL Embedding in Racket

leave a comment »

Here’s a great, two part, video by Matthew Flatt about embedding DSLs in Racket. Being able to hack the language is one of Racket’s/Lisp’s killer features:

Written by Brian Adkins

October 15, 2015 at 6:39 pm

Posted in programming

Tagged with ,

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