Javascript	147 points
  Python	116 points
  Ruby		 81 points
  C		 72 points
  Java		 71 points
  PHP		 64 points
  C++		 44 points
  C#		 37 points
  Perl		 27 points
  Clojure	 26 points
  Haskell	 18 points
  Lisp		 18 points
  Scheme	 16 points
  Erlang	 11 points
  Lua		  7 points
  Ocaml		  7 points
  Coldfusion	  2 points
  Go		  2 points
  Arc		  1 point
  Fortran	  1 point
  Smalltalk	  1 point
  D		  0 points
  Other		 43 points

I'm relieved to see that C narrowly beat Java for 4th place, but I'm a bit disappointed by the performance of Scheme, Erlang, and Arc -- even though I don't use them myself, I figured that more people here would.

It's a natural consequence.

    Javascript            372 (17.72%)
    Python                315 (15.01%)
    Ruby                  221 (10.53%)
    C                     191 (9.10%)
    Java                  182 (8.67%)
    PHP                   167 (7.96%)
    C++                   124 (5.91%)
    Other                 121 (5.76%)
    C#                     82 (3.91%)
    Perl                   70 (3.33%)
    Clojure                53 (2.53%)
    Lisp                   42 (2.00%)
    Haskell                37 (1.76%)
    Scheme                 34 (1.62%)
    Erlang                 31 (1.48%)
    Lua                    16 (0.76%)
    Ocaml                  11 (0.52%)
    Go                      7 (0.33%)
    Arc                     7 (0.33%)
    Fortran                 5 (0.24%)
    Smalltalk               5 (0.24%)
    Coldfusion              4 (0.19%)
    D                       2 (0.10%)
    2099 points over 23 options

    Javascript            372 (17.72%)  [  3.515%]
    Python                315 (15.01%)  [  5.185%]
    Ruby                  221 (10.53%)  [  2.653%]
    C                     191 (9.10%)   [ 16.285%]
    Java                  182 (8.67%)   [ 17.061%]
    PHP                   167 (7.96%)   [  9.770%]
    C++                   124 (5.91%)   [  9.175%]
    Other                 121 (5.76%)    --
    C#                     82 (3.91%)   [  6.258%]
    Perl                   70 (3.33%)   [  2.692%]
    Clojure                53 (2.53%)   [  0.881% / 3?]
    Lisp                   42 (2.00%)   [  0.881% / 3?]
    Haskell                37 (1.76%)   [  0.190%]
    Scheme                 34 (1.62%)   [  0.881% / 3?]
    Erlang                 31 (1.48%)   [  0.277%]
    Lua                    16 (0.76%)   [  0.585%]
    Ocaml                  11 (0.52%)   [ < 0.15%]
    Go                      7 (0.33%)   [      ??]
    Arc                     7 (0.33%)   [ < 0.15%]
    Fortran                 5 (0.24%)   [  0.425%]
    Smalltalk               5 (0.24%)   [  0.150%]
    Coldfusion              4 (0.19%)   [      ??]
    D                       2 (0.10%)   [  0.587%]

I use bash as an interactive shell, but for scripts I can't imagine why anyone would want to use bash unless they simply didn't realize how non-standard it is.

For specialized tasks such as simple pipes, invoking a sequence of commands (for a more involved tasks I prefer Python) what else would you use other than your interactive shell?

A POSIX shell. There is actually a --posix option to bash which makes it more closely approximate POSIX-standard behaviour, but last time I checked it wasn't perfect.

This is what's called a Linux-ism: "The Linux distro I use does it this way, so it must be the standard, right?" It's very annoying when porting things to BSD or elsewhere.

(I mean, I'd just patch it in the port, but it's annoying in the same way as people sending e-mail wrapped inside a Word file for no reason.)

   #!/usr/local/bin/bash
   prog_name some_argument

Okay, yeah, there has never been a shell on which that wouldn't work. WTF bonus points for requring /usr/local/bin, which is almost certainly not where the OS maintainers package it.

Although it wouldn't have been my first choice (I was put on an already existing project), I came to like some parts of it.

http://neilconway.org/docs/boom-20091023.pdf http://neilconway.org/docs/netdb2009_paxos.pdf

The basic idea is to write distributed systems in a high-level logic language; essentially, to treat writing a distributed algorithm as a distributed data management problem ("data" being the state of the computation).

Are there any plans to open source any of the work (either the JVM implementation, the C implementation or some of the products, e.g. hot-standby NN)?

The Java-based implementation can be found here: https://svn.declarativity.com/lincoln/java/trunk/ . The old C++ implementation (P2) is https://svn.declarativity.com/p2/trunk/ .

We haven't been polishing the JOL/BoomFS work, because we're currently working on a brand-new language ("Bloom") that should be much more programmer-friendly; as part of that, I'm writing an efficient C-based dataflow engine. If you have any more questions, feel free to drop me an email.

Surprised no one has listed Verilog or VHDL.

We have code in C++, Java, Ruby, Perl, Python, Javascript and PHP, but there's a high concentration around the first three.

Also, voted for python. Loving it for all my randoming glueing and bit moving needs on my windows machine at work.

I wonder what prompts others to stick with scheme.

I do a mix of both, though I don't spend all day, every day doing CF.

I voted for Ocaml, which is a close cousin, but with all the libraries available, F# is really another kind of thing entirely.

That said, it does have high-level-assembler features, like being able to directly declare and modify registers. Pl/X also features a way to directly insert assembly code using a GENERATE macro, in which you have to specifically declare which registers/variables are either modified or referenced.

All-in-all, it's not a bad language; I prefer it to C.

http://www.newlisp.com