Archive for the ‘programming’ Category
Programming Language Popularity – Part Twelve
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 | |------+-------------+------------+-------+-------|
Programming Language Popularity – Part Eleven
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 | | |------+-------------+------------+-------+-------|
Programming Language Popularity – Part Ten
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)
Upgrading to Emacs 24.5
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:
- Go here and click on a mirror link
- Download the appropriate file, e.g. emacs-24.5.tar.gz
- tar xzf emacs-24.5.tar.gz
- cd emacs-24.5
- ./configure –with-ns
- make install
- drag nextstep/Emacs.app to the Applications directory
Emacs is still awesome!
How to Write a Spelling Corrector in Racket
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))))
DSL Embedding in Racket
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:
Programming Language Popularity – Part Nine
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
The Three R’s
I’ve read that ten years is a common “lifetime” for a technology. Whether that’s true, or not, it seems to be the case with me. After beginning with BASIC & S/360 Assembler, I programmed in C/C++ from ~ 1985 until 1995, then in Java until 2006, and since then I’ve been programming primarily in Ruby/Rails.
For a number of years, I’ve felt the need to consider what my next primary language should be, and after experimenting with various lisps, Haskell and OCaml, I found that Racket is the best fit for me. I’m still very much in learning mode now, but I hope to be using Racket professionally in 2016.
Despite the fact that Racket is significantly faster than Ruby, I do occasionally have compute-intensive tasks that require more raw speed, so for a high performance language to maximize all the cores at my disposal, I’ve recently settled on Rust. I expect I will mostly be developing in Racket with the occasional performance hungry lib/program in Rust.
A current interest of mine is statistical programming, big data, data science, etc. Both R and Python are on the short list here with Julia trailing behind. I really like what I’ve seen in Julia, and I wouldn’t at all be surprised if I end up there; however, as a newbie learning the field, I think I’ll find much better support (educational info, existing libraries, community support, etc.) with R, so I’m starting with that until I’m convinced of switching.
At my stage, the language isn’t as important as becoming more educated in probability & statistics, machine learning, etc.
I didn’t plan it this way, but it appears that I’m going to be spending a lot of time with Racket, Rust and R.
Programming Language Popularity – Part Eight
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
My Top 10 Programming Languages of Interest for 2013-2014
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:
- Haskell, Racket & Common Lisp (concurrently)
- Julia
- J
- 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).
