Bazaar is conspicuously missing. My guess is that "other" is mostly Bazaar.

Aside: would've been neat to see a "version control by OS" pie chart for GNU/Linux.

That's because it was conspicuously missing as an answer from our respondents.

We got exactly four responses for Bazaar and one for Fossil out of nearly a thousand. They are just tiny in comparison to the rest.

given that 'others' does not seem to be 0.5% of the chart: what else is in there?

clear case, and source gear are the only two I can think of that might make the list.

I keep seeing posts about large organisations (off the top of my head, python and mozilla) consider bzr, and then discount it.

This mostly seems to be because of its performance.

Having used git and bzr extensively (and a bit of mercurial), I've found it's performance to be perfectly fine for general use on reasonably sized projects, and the ease-of-use to be far superior. Figuring out how to get Bazaar to do something you haven't done before is much easier than trying to track down a Git feature. Although I will admit that Git is improving in this regard, while Bazaar continues to improve it's performance and focus on interoperability.

Anyway, in summary: I really don't get why more people aren't using Bazaar.

I'm not so sure. All but one of the Bazaar users I know uses it only because Canonical and/or GNU* require it.

* Emacs uses Bazaar for "branding" reasons IIRC.

There's also ClearCase, which I believe is popular in Big Iron Enterprise shops.

If the survey was done properly, then 'other' consists of lots of different things and bzr is just a small chunk of it not worth dealing with separately.

If the survey was done badly, with an 'other' option with no way to write in what you use, then potentially all of the 'other' block could be bzr. It would just be left out by the survey writer not having heard of it.

Don't forget Fossil

Racket and Common Lisp seem way more difficult than Python. I learned Python in a very short amount of time, and it was very easy (it's just functions, classes, C-like syntax, and boom, you're writing programs in Python).

Tried learning Scheme and Lisp a couple times and just ran out of steam. (While I'm here: any advice on making it stick?)

> in such a way that you can apply it to any language

After working through some of SICP, would you recommend then using Scheme for practical projects?

Pandoc lets you write in a slightly (and tastefully) enhanced Markdown, but also lets you drop down to write LaTeX macros if you like.

You might just use Pandoc. It happens to use LaTeX behind the scenes to create pdf's, but there's nothing that says it must do so in the future.

> Its darwinian

I think you're correct, but that there are trade-offs. Take Python, for example. They have "batteries included", and when modules make it into the std lib, they pretty much stop evolving. However, on the up-side, Python gains users who like having everything packaged up nice and neat so they don't need to go looking for modules quite as much.

Perl takes the popularity hit of not having too many batteries included, but benefits from the darwinian element that works to make the 3rd-party modules better. So, perlers need to spend more time asking around (or checking cpanratings), and also dealing with it when there's turnover (the module that they chose a few years ago is eclipsed by a competitor, or stops being maintained, and now they need to rewrite some of their code).

In the end, I think Perl has better modules.

Yes i've touched briefly on CPAN vs stdlib approach before (http://news.ycombinator.com/item?id=2088040). They're just different approaches and neither is better or worse than the other.

BTW... I believe all language repos will have darwinism acting upon it. I see it in Ruby & Python as well as on CPAN. Its Perl philosophy and CPAN size that just stirs the pot a bit more!

In what ways is Guile different from other Schemes, such as Gambit and Chicken?

Is Guile a good Scheme to start off with when first learning Scheme?

It's easy to embed, it also has (had?) a Javascript-syntax mode.

Racket is what most people recommend for learning.

Like many folks, I'd reckon, I've really meant to learn Lisp or Scheme better, but it just seems like -- with the lack of syntax -- it would be tedious to write out every single operation as a function/procedure call.

Is Lisp/Scheme as tedious as I'm assuming? I'm not talking about readability -- surely one can get used to the parens and indenting and read (and write) it just fine -- I'm talking about tedium of everything having to be a procedure call.

There's no tedium of writing everything out with parentheses, so you don't need to worry about that. You aren't writing everything "as a procedure call," or at least I wouldn't put it that way. For example, if you write babby's first recursive function in Scheme,

    (define (factorial n)
      (if (= n 0)
          1
          (* n (factorial (- n 1)))))

There, the procedure calls are (= n 0), (* n (factorial (- n 1))), (factorial (- n 1)), and (- n 1). You are not writing "(define ...)" as if it were a procedure call. You are writing it as if it were a special form (because it is one). That's a description of how it psychologically feels. Writing the (if ...) special form feels no different than writing if (...) { } else { } in Java.

Lisp and Scheme are not tedious at all. I'd say Common Lisp is one of the least tedious languages.

Thanks for the reply, Sam.

To provide some small examples, I often use Perl, and it gives me some syntax that saves me typing, such as:

* `my @other_list = @a_list[3, 1, 4]` to return just those items from a list (item 3, item 1, and item 4)

* `$str =~ s/$foo/BAR/g` to do string replacements (in string $str, replace all ocurrences of contents of variable $foo with "BAR")

* `my $thing = $colored_objects{red}->[2]` to get item 2 in the list of red-colored objects ($colored_objects is a mapping of color names to lists of items of that color)

* `my $error_msg = "Sorry, but $thing1 doesn't work with $thing2."` to interpolate the values of those 2 variables into the string

* `for (reverse(1 .. 10)) { say "Counting down: $_"; }` (counts down from 10 to 1)

I suppose I've always just guessed that operations like those in a Lisp language would require multiple lines and procedure calls, which would become tedious to write after a while. Is that the case?

Oh, Perl. In some cases, Lisp would certainly be more verbose. It's probably more tedious than Perl for some things. It also depends on which language you use. Scheme is more tedious than Common Lisp, which is sometimes more tedious than Clojure.

Here are the Clojure equivalents, omitting the act of assigning stuff to variables.

    (map #(a-list %) '(3 1 4))

    ; I'm not modifying x in-place because unfortunately Clojure
    ; doesn't like that.  Common Lisp is more imperative.
     (.replaceAll x foo "BAR")

    ((colored-objects :red) 2)

    (str "Sorry, but " thing1 " doesn't work with " thing2 ".")

    (doseq [i (reverse (range 1 11))]
      (println "Counting down: " i))

If you took the first example and assigned it to a variable other-list, it would typically be in a let expression, with a body.

    (let [other-list (map #(a-list %) '(3 1 4))]
      (subsequent statements that use other-list))

Thanks for those equivalents, Sam! Informative.

That first `(map #...)` is particularly interesting. Looks like you're applying the item lookup operation across the list of indices. Neat.

The first example could actually have been

    (map a-list [3 1 4])