As others have mentioned, it can be a bit of a false dichotomy -- particularly if you stick within a particular class of related languages. It's pretty easy to move between most of the several C-like languages, for instance, if you become an expert in one. In those cases, it's mostly just about noting the syntax differences and learning your way around the standard libraries but you'll hit the ground running, already better than half the people who claim to program in that language. Moving from there to something like OCaml or Scala is a more challenging. I think that learning several paradigms is more important than multiple languages as it makes you a better programmer no matter which you are using. It's all about having the right tool for the job but that doesn't necessarily mean switching languages since most paradigms can at least be faked in a useful way in most languages. Several modern languages let you play outside a single core paradigm and I personally think it's good to start with one of them. C# is probably one of the better examples of a broad multi-paradigm language. To be a true expert in it, you've had to learn imperative, declarative, object oriented, generic, reflective, dynamic, event driven, parallel, concurrent, cooperative (coroutines), functional (lambda calculus), relational (tuple relational calculus, like SQL), object-relational, expression oriented, generators and likely others I'm leaving out. If you branch out from the first-class language features you can get several more esoteric things like actor model and flow based (dataflow and reactive) as common add-on libraries. The broad base makes it easy to add things that feel like first class features -- for instance, I recently created a library using the aforementioned dynamic and expression functionality to add prototype-based programming just so I could better interface with scripts written in JavaScript. The point is, if you've learned all that then moving to OCaml won't be radically harder than moving to C++. Whether you'll ever need to is another question.

Another reason might be due to the prevalence of semantic code highlighting in modern IDEs. Dark backgrounds have a bit of an advantage if you are looking for several discernibly different and readable foreground colors. Also, the common reason given may not be the whole explanation even if it is technically correct. Yes, dark backgrounds are easier on the eyes in a dark room but that doesn't explain why so many devs seem to prefer coding in the dark. My hypothesis? Attention Deficit Disorder (dark room focuses you on the screen) and Autism Spectrum Disorders (light sensitivity is a common symptom) are pretty common in techies. Also, a higher proportion of us are likely night owls -- partly because statistically night owls have higher IQs than early birds but also, again, because ADD and ASD favors working in isolation after everyone else calls it a day.