You are currently browsing the tag archive for the ‘python’ tag.
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
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
See Part Five
I compiled some programming language popularity statistics in April 2009, October 2009 and October 2010 . Here’s an update for September 2011:
I made a number of Google searches of the forms below and summed the results (previous 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.
| Language | Total | Prev. Position | Position Delta |
|---|---|---|---|
| C | 10,360,000 | 2 | 1 |
| PHP | 10,351,000 | 1 | -1 |
| C++ | 6,495,000 | 3 | 0 |
| Python | 5,759,000 | 5 | 1 |
| C# | 5,335,000 | 4 | -1 |
| Java | 4,890,000 | 8 | 2 |
| Perl | 3,702,000 | 6 | -1 |
| JavaScript | 3,077,000 | 7 | -1 |
| Ruby | 1,654,000 | 9 | 0 |
| Lisp Family1 | 1,022,870 | 11 | 1 |
| FORTRAN | 975,600 | 10 | -1 |
| Tcl | 594,500 | 12 | 0 |
| Lisp | 486,000 | 14 | 1 |
| Haskell | 450,500 | 16 | 2 |
| Erlang | 419,700 | 13 | -2 |
| Lua | 367,100 | 18 | 2 |
| ML Family2 | 348,400 | 17 | 0 |
| COBOL | 308,270 | 15 | -3 |
| Common Lisp | 254,900 | 19 | 0 |
| OCaml | 240,300 | 21 | 1 |
| Prolog | 224,000 | 20 | -1 |
| Scala | 203,400 | 23 | 1 |
| Scheme | 184,700 | 22 | -1 |
| Smalltalk | 129,700 | 24 | 0 |
| Clojure | 84,600 | 27 | 2 |
| (S)ML3 | 83,630 | 25 | -1 |
| Forth | 69,980 | 26 | -1 |
| Caml | 24,470 | 28 | 0 |
| Io | 17,700 | 30 | 1 |
| Arc | 12,670 | 29 | -1 |
1 combines Lisp, Scheme, Common Lisp, Arc & Clojure
2 combines OCaml, (S)ML, Caml
3 summed separate searches for sml and ml
See Part Five
I compiled some programming language popularity statistics in April 2009 and October 2009 . Here’s an update for October 2010:
I made a number of Google searches of the forms below and 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 one column since the number of results Google returns can vary greatly over time.
| Language | Apr 2009 | Oct 2009 | Oct 2010 | Position Delta |
|---|---|---|---|---|
| PHP | 680,000 | 5,083,500 | 14,096,000 | +3 |
| C | 1,905,500 | 16,975,000 | 9,675,000 | -1 |
| C++ | 699,000 | 6,270,000 | 6,510,000 | -1 |
| C# | 349,700 | 2,125,000 | 5,132,000 | +4 |
| Python | 396,000 | 3,407,000 | 5,114,500 | +1 |
| Perl | 365,500 | 3,132,500 | 4,675,000 | +1 |
| JavaScript | 102,700 | 1,163,000 | 2,120,000 | +4 |
| Java | 850,000 | 5,118,000 | 1,495,500 | -5 |
| Ruby | 99,650 | 227,000 | 1,426,000 | +13 |
| FORTRAN | 1,621,000 | 770,850 | 0 | |
| Lisp Family1 | 176,507 | 3,489,650 | 399,685 | -6 |
| Tcl | 44,800 | 382,000 | 313,400 | +5 |
| Erlang | 22,285 | 161,700 | 188,800 | +12 |
| Lisp | 61,900 | 486,500 | 174,050 | +1 |
| COBOL | 247,300 | 166,435 | +6 | |
| Haskell | 22,550 | 280,500 | 157,150 | +4 |
| ML Family2 | 29,062 | 1,003,800 | 149,005 | -5 |
| Lua | 13,065 | 131,800 | 128,150 | +9 |
| Common Lisp | 20,600 | 554,500 | 112,750 | -5 |
| Prolog | 17,750 | 390,500 | 100,000 | -4 |
| OCaml | 22,000 | 343,500 | 99,050 | -3 |
| Scheme | 86,450 | 2,100,000 | 82,650 | -13 |
| Scala | 3,570 | 66,250 | 65,950 | +6 |
| Smalltalk | 9,105 | 187,500 | 56,950 | 0 |
| (S)ML3 | 5,173 | 590,700 | 42,130 | -12 |
| Forth | 6,465 | 146,450 | 25,880 | 0 |
| Clojure | 782 | 62,200 | 23,525 | +3 |
| Caml | 1,889 | 69,600 | 7,825 | 0 |
| Arc | 6,775 | 286,500 | 6,710 | -10 |
| Io | 1,760 | 198,500 | 3,025 | -7 |
1 combines Lisp, Scheme, Common Lisp, Arc & Clojure
2 combines OCaml, (S)ML, Caml
3 summed separate searches for sml and ml
See Part Five
I compiled some programming language popularity statistics in April and mentioned I’d update the results in 6 months, so here they are:
I made a number of Google searches of the forms below and averaged the results:
"implemented in <language>" "written in <language>"
| Language | # Results Apr 09 |
# Results Oct 09 |
Position Delta |
|---|---|---|---|
| C | 1,905,500 | 16,975,000 | 0 |
| C++ | 699,000 | 6,270,000 | +1 |
| Java | 850,000 | 5,118,000 | -1 |
| PHP | 680,000 | 5,083,500 | 0 |
| Lisp Family1 | 176,507 | 3,489,650 | +3 |
| Python | 396,000 | 3,407,000 | -1 |
| Perl | 365,500 | 3,132,500 | -1 |
| C# | 349,700 | 2,125,000 | -1 |
| Scheme | 86,450 | 2,100,000 | +2 |
| FORTRAN | 1,621,000 | N/A | |
| JavaScript | 102,700 | 1,163,000 | -1 |
| ML Family2 | 29,062 | 1,003,800 | +3 |
| (S)ML3 | 5,173 | 590,700 | +12 |
| Common Lisp | 20,600 | 554,500 | +5 |
| Lisp | 61,900 | 486,500 | -2 |
| Prolog | 17,750 | 390,500 | +4 |
| Tcl | 44,800 | 382,000 | -3 |
| OCaml | 22,000 | 343,500 | 0 |
| Arc | 6,775 | 286,500 | +4 |
| Haskell | 22,550 | 280,500 | -4 |
| COBOL | 247,300 | N/A | |
| Ruby | 99,650 | 227,000 | -10 |
| Io | 1,760 | 198,500 | +6 |
| Smalltalk | 9,105 | 187,500 | -1 |
| Erlang | 22,285 | 161,700 | -7 |
| Forth | 6,465 | 146,450 | -1 |
| Lua | 13,065 | 131,800 | -5 |
| Caml | 1,889 | 69,600 | 0 |
| Scala | 3,570 | 66,250 | -2 |
| Clojure | 782 | 62,200 | 0 |
1 combines Lisp, Scheme, Common Lisp, Arc & Clojure
2 combines OCaml, (S)ML, Caml
3 summed separate searches for sml and ml
I first became interested in functional programming when I was exposed to Python, Ruby & JavaScript a number of years ago. Since then I’ve looked into Arc, Clojure, Common Lisp, Haskell, Logo, ML & Scheme. I haven’t yet determined whether I’ll be more productive in any of them than I am with Ruby for developing web applications, but I do find them quite interesting.
After bumping into a number of local programmers who expressed an interest in functional programming, I thought it might be a good time to start a local group that focused on functional programming languages, so I did a couple days ago.
TriFunc.org is a group for programmers who are interested in functional programming languages and live near the Research Triangle area of North Carolina.
If you live in the area and have an interest in functional programming languages, feel free to dive in and start participating in the Google Group discussions. Once we reach a critical mass, I expect we’ll produce a meeting schedule, etc., but that will depend on where the group wants to take this.
See Part Five
Despite the numerous ways in existence to quantify programming language popularity, I thought I’d throw yet another one into the mix. I made a number of Google searches of the forms below and averaged the results:
"implemented in <language>" "written in <language>"
I’m very curious to see how these stats change over time, so I’ve added a calendar item to recompute them in six months. Leave a comment if you’d like to add a programming language to the list, and I’ll update this article and it will be included in the recomputation six months from now.
| Language | # Results |
|---|---|
| C | 1,905,500 |
| Java | 850,000 |
| C++ | 699,000 |
| PHP | 680,000 |
| Python | 396,000 |
| Perl | 365,500 |
| C# | 349,700 |
| Lisp Family1 | 176,507 |
| JavaScript | 102,700 |
| Ruby | 99,650 |
| Scheme | 86,450 |
| Lisp | 61,900 |
| Tcl | 44,800 |
| ML Family2 | 29,062 |
| Haskell | 22,550 |
| Erlang | 22,285 |
| OCaml | 22,000 |
| Common Lisp | 20,600 |
| Prolog | 17,750 |
| Lua | 13,065 |
| Smalltalk | 9,105 |
| Arc | 6,775 |
| Forth | 6,465 |
| (S)ML3 | 5,173 |
| Scala | 3,570 |
| Caml | 1,889 |
| Io | 1,760 |
| Clojure | 782 |
1 combines Lisp, Scheme, Common Lisp, Arc & Clojure
2 combines OCaml, (S)ML, Caml
3 summed separate searches for sml and ml
Update 4/23/09 added C#, Tcl per comment requests.
I saw a post on comp.lang.lisp demonstrating the suitability of Common Lisp for functional programming. The poster asked to see versions in other languages including Ruby, so I thought I’d whip something up. Here’s the original post with description of the problem:
This one was too much fun for words in re how cool it is programming
with Lisp. I would like to see this in Ruby, Clojure, Qi, and
Scheme. The precise fun part tho is typing it all in in the final form
versus dividing the thing up into steps to get intermediate results,
ie, a test of one's mastery of one's language. Non-functional
languages I guess have no choice but to stop and assign temporaries.
Given:
(defparameter *pets*
'((dog ((blab 12)(glab 17)(cbret 82)(dober 42)(gshep 25)))
(cat ((pers 22)(siam 7)(tibet 52)(russ 92)(meow 35)))
(snake ((garter 10)(cobra 37)(python 77)(adder 24)(rattle 40)))
(cow ((jersey 200)(heiffer 300)(moo 400)))))
Write:
(defun digest-tag-population (tag-population pick-tags count)...)
Such that:
(digest-tag-population *pets* '(dog cat snake) 5)
=> ((DOG CBRET 82) (DOG DOBER 42) (CAT RUSS 92) (CAT TIBET 52) (SNAKE
PYTHON 77))
...the rules being:
- consider only the populations of tags (the first symbol in each
sublist) found in the parameter pick-tags, a list
- take only the most populous of the union of the populations
- return (tag name population) of the most populous in this order:
firstly, by position of the tag in pick-tags
second, ie within a tag, in descending order of population
(defun subseq-ex (st e s)
(subseq s st (min e (length s))))
(defun digest-tag-population (tag-population pick-tags count)
(flet ((tagpos (tag) (position tag pick-tags)))
(stable-sort (subseq-ex 0 count
(sort (loop for (tag population) in tag-population
when (tagpos tag)
append (loop for pop in population
collecting (list* tag pop)))
'> :key (lambda (x)
(caddr x))))
'< :key (lambda (x) (tagpos (car x))))))
(defparameter *pets*
'((dog ((blab 12)(glab 17)(cbret 82)(dober 42)(gshep 25)))
(cat ((pers 22)(siam 7)(tibet 52)(russ 92)(meow 35)))
(snake ((garter 10)(cobra 37)(python 77)(adder 24)(rattle 40)))
(cow ((jersey 200)(heiffer 300)(moo 400)))))
#+test
(digest-tag-population *pets* '(dog cat snake) 5)
And here is my Ruby version:
PETS = [
[:dog, [[:blab, 12], [:glab, 17], [:cbret, 82], [:dober, 42], [:gshep, 25]]],
[:cat, [[:pers, 22], [:siam, 7], [:tibet, 52], [:russ, 92], [:meow, 35]]],
[:snake, [[:garter, 10], [:cobra, 37], [:python, 77], [:adder, 24], [:rattle, 40]]],
[:cow, [[:jersey, 200], [:heiffer, 300], [:moo, 400]]]
]
def digest_tag_population tag_population, pick_tags, count
tag_population.select {|e| pick_tags.include?(e[0]) }.
inject([]) {|memo,obj| obj[1].each {|e| memo << [obj[0], e[0], e[1]] }; memo }.
sort {|a,b| b[2] <=> a[2] }[0,count].
sort_by {|e| [ tag_population.map{|p| p[0]}.rindex(e[0]), e[2] * -1] }
end
digest_tag_population(PETS, [:dog, :cat, :snake], 5)
Within the function:
Line 1: select elements that match the pick tags
Line 2: map to a list of tuples of the form [:dog, :blab, 12]
Line 3: sort the list of tuples by population and select the first count of them
Line 4: sort by tag position, population
Output:
[[:dog, :cbret, 82],
[:dog, :dober, 42],
[:cat, :russ, 92],
[:cat, :tibet, 52],
[:snake, :python, 77]]
I think Ruby compares very favorably. What do you think? Feel free to submit a version in another language.
Almost a year ago, I formed Gospel Software, LLC with two friends from my church. Our mission for the company is to develop web applications to help churches administratively.
It’s been a joy to work with Jordan and Scott over the last year and we’re now to the point of beginning to heavily promote our three web applications to churches. These are two men I can learn a lot from – both technically and spiritually. I would be hard pressed to find better business partners.
Gospel Software currently has three web applications.
Directory:
I just released a new version of the Gospel Software Directory a few minutes ago – there are some new screen shots to show some of the features. I had wanted a nice online photo directory for our church for quite a while. I finally wrote a simple bare bones version a few years ago and ended up using it all the time, so I thought there might be a market for the product.
Over the last year, I wrote a completely new version, and now each church member can edit their own information, upload new photos, etc., so the information is more current and the church administrative staff has less work to do. I still think one of the best features is simply being able to match the faces of people I’ve met with their names. It’s now available for churches to try out and purchase.
This new version is just the beginning. I have a long list of enhancements I’ll begin rolling out over the next few months.
GuestView:
Scott’s GuestView program is something I use regularly as I follow up with visitors to our church. It’s so handy and easy to use. I get an email when I need to call a visitor, then I can enter notes about our conversation, and if they’d like information from another leader in the church, I can notify the appropriate people.
SongBook:
I had thought about developing a program to manage worship songs back in the mid-eighties, but I was never motivated enough to do anything about it. When Jordan showed me his SongBook application, I was blown away – it did everything I had thought of and much more. And of course it was web based since the internet had been invented since I began thinking of a similar program
I’m excited about seeing what will be happening with Gospel Software, LLC this coming year.
We do have an affiliate program that rewards both the affiliate and any church they refer. Contact me for details if you’re interested.
The technical experiences we’ve had over the last year should provide for some interesting and informative blog posts in the future. When we came together to form the company, we had three products written in three different languages / frameworks. Integrating the three products together with a common infrastructure has been very educational
We now have a robust infrastructure that will support any future applications very well.
- Server configuration, backup & light disaster recovery
- Ecommerce – credit card processing, subscription management, invoicing, etc.
- Auditing and event logging
- Easy deployment of new releases
- User management, authentication, authorization & accounting
- And more…
As I mentioned, there are three languages / frameworks involved, but there is quite a bit of Ruby and Rails, and there will likely be more in the future. Each of the three languages / frameworks have their pros & cons, but I do feel that Ruby and Rails does very well in the evaluation.
The following are some things that I have been particularly pleased with:
- My Macbook Pro with OSX and Emacs as a development environment
- Ruby & Rails
- nginx web server
- mongrel application server
- Postgres relational database
- Trac issue tracker & wiki
- Subversion source code control (possibly moving to git in the future, but for our purposes, svn has worked out very well)
- Slicehost.com – being able to restart a VM on another server if hardware fails is awesome
- Ubuntu Linux
- istockphoto.com and fotolia.com for inexpensive stock photos
- jQuery – it might not satisfy comp.lang.javascript, but it’s been great
- Did I mention Emacs?
I’ve learned a number of programming languages since I began programming 25 years ago. Earlier in my career, my choice of which programming language to learn was largely driven by external factors such as a class or job requirement, or the expectation of job demand in the future.
More recently I’ve enjoyed learning new programming languages both for the joy of learning something new, and for an increase in productivity.
While it’s true that no programming language is a silver bullet, I’ve found that the choice of programming language can provide a dramatic increase in productivity – much more so than many have asserted. The benefit can be direct, by allowing the creation of a solution to a particular problem with less time and effort than it would take using another language, or it can be an indirect by providing new ways to think about a solution.
Do you think language affects how we think?
The Past
In 1982, I spotted a Radio Shack Color Computer in a store window and immediately applied for a Radio Shack credit card which had a credit limit ($500) sufficient to purchase the computer which had 4K of RAM (I later upgraded to 16K) and no external storage (unless you count the ability to hook up a cassette recorder). Contrast the 16K RAM of that early machine with my current 2,097,152K RAM
That was the beginning of a life long interest in programming.
In the language list below, bold indicates a more significant professional involvement, and the year indicates when I first learned the language. I’ve also likely forgotten a few:
- 1982 – Radio Shack Extended Color BASIC
- 1983 – 6809e Assembler
- 1983 – Pascal
- 1984 – HP 48SX RPL
- 1984 – S/360 Assembler
- 1985 – COBOL
- 1985 – dBase III / Metafile
- 1985 – C
- 1985 – 8088/8086 Assembler
- 1986 – C++
- 1996 – Java
- 1997 – Perl
- 2002 – C#
- 2004 – Python
- 2005 – JavaScript
- 2006 – Ruby
- 2007 – PHP
The Present
Currently, I program primarily in Ruby, followed by JavaScript and the occasional PHP script. Ruby is the most productive programming language I’ve used thus far. The combination of power, pragmatism & pleasure in programming is hard to beat. If it also had performance, it would be a truly great language.
I’ve also begun learning Logo as I teach my daughter how to program. Logo is a great introduction to the Lisp family, so I hope to leverage it as I learn Scheme and Common Lisp later this year.
The Future
After completing the Logo course with my daughter, I plan on moving on to Scheme as I go through Structure and Interpretation of Computer Programs which some have called the greatest computer science text ever written.
After Scheme I plan on learning Common Lisp which has the potential to replace Ruby as my primary programming language.
Beyond Logo/Scheme/Common Lisp, the following languages are of interest:
- Haskell
- Erlang
- Lua
- ML
- OCaml
If you know of candidates for a future programming language, feel free to add it in a comment.
You may notice that Smalltalk is lacking from the lists above. Despite its prominence in programming language history, I currently don’t feel that Smalltalk is sufficiently better/different than Ruby to warrant an investment in learning it.
After focusing on object oriented for twenty years, I have more of an interest in the functional world of programming languages (and multiple dispatch is cool ).
Update: I was just over at Hacker News and saw something I’ve seen many times before. In a nutshell, some guy was stating that Paul Graham’s success with ViaWeb had little to do with his choice of programming language (Lisp) and more to do with him just being a good hacker. In other words, he could’ve written it in any language. I’m so glad Paul responded because his response confirms my thoughts on the matter:
What a weird situation. I keep trying to tell people Lisp is great, and they say, no, no, you guys were just really good programmers. But if I’m such a good programmer, why don’t they believe me?
Paul Graham has written a lot on Lisp and is one of the main factors in me becoming interested in Lisp (along with the fact that Ruby pulled a lot of good ideas from it), but the simple quote above communicates volumes IMO.
Recent Comments