Posts Tagged ‘python’
Programming Language Popularity
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.
Digest Tag Population in Ruby
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.
Gospel Software, LLC
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? 🙂
2008 Programming Language Plan
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.
Logo, Ruby & JavaScript
I’ve been teaching my eldest daughter to program in Logo over the summer. Brian Harvey has posted PDF files for a set of excellent books on learning to program in Logo on his web site. The Berkeley version of Logo he’s produced is really excellent. It’s not just your typical turtle graphics language; it has arrays, macros, file processing, graphics, etc.
While perusing his site, I came across a tiny Logo program that demonstrates a little of its power. I was curious what it would look like in Ruby, so I ported it, then I had to see what it looked like in JavaScript.
The formatting is a little messed up due to WordPress, but each of the three choices functions is 4 lines long.
If anyone wants to add other languages, that would be great!
See the sample page for example output.
Logo
to choices :menu [:sofar []]
if emptyp :menu [print :sofar stop]
foreach first :menu [(choices butfirst :menu
sentence :sofar ?)]
end
choices [[small medium large]
[vanilla [ultra chocolate] lychee [rum raisin] ginger]
[cone cup]]
UPDATE 9/2/07: Got an even more concise solution from Brian Harvey:
to choices :menu foreach crossmap "sentence :menu "print end
Ruby
def choices menu, sofar=[]
if menu.empty?: puts sofar.join(' ')
else menu[0].each {|item| choices(menu[1..-1],
sofar + [item]) } end
end
choices [['small', 'medium', 'large'],
['vanilla', 'ultra chocolate', 'lychee', 'rum raisin', 'ginger'],
['cone', 'cup']]
JavaScript
function choices(menu, sofar) {
if (emptyp(menu)) print(sofar);
else foreach(menu[0],
function (x) {
choices(menu.slice(1), sofar.concat(x)); });
}
choices([['small', 'medium', 'large'],
['vanilla', 'ultra chocolate', 'lychee', 'rum raisin','ginger'],
['cone', 'cup']], []);
I had to create a few helpers for the JavaScript version:
function emptyp(a) {
return a.length === 0;
}
function print(list) {
foreach(list, function (x) { document.write(x + ' '); });
document.write('<br />');
}
function foreach(arr, f) {
for (var idx in arr) { f(arr[idx]); }
}
UPDATE: Use <pre> </pre> tags to allow easier formatting of code. Bummer, I just discovered that WordPress strips the <pre> tags from normal users 😦 I’ll go ahead and wrap code with it as they come in, so if your comment looks bad at first, it’ll be cleaned up shortly.
