As Yegge mentioned in his post, this is a bit of an oversimplification. As a simple illustration, choosing a statically typed language like Java over Python is certainly a conservative trait. But then choosing Python over Haskell is exactly the same, just with the whole difference translated towards the liberal end of the spectrum.

Put another way, it's the political liberals who came up with OSHA (I hope--I'm somewhat ignorant of the actual history :P). A liberal or conservative outlook is not characterized by some particular processes or tools--it's characterized in an entirely relative way. The conservative approach is in choosing the familiar over the novel and in avoiding change. The familiar could be safer--Java vs Python--or it could be less safe--Java vs Haskell. I've talked to some ardent Java adherents, and they have lucid cases for not going over to Python or Ruby or Clojure or what have you. But--critically--these cases are virtually identical to their cases against going over to Haskell or Scala. There are differences in details, of course, but it's a difference in degree rather than kind.

Another even more extreme example is TDD. In particular, the arguments people have against adopting TDD are essentially exactly the same as I've seen from TDD supporters against using formal methods. Once again, some details differ, but the core idea seems to remain: some people are inherently wary of change.

It's also interesting to note how Yegge categorizes certain concepts in multiple "buckets". Either he's just being inconsistent (which is plausible) or he's making a deeper point: it's not about the particular concept, it's about the philosophy behind it. If he wasn't making that point, I've made it for him :).

That is, anything called "something calculus" is conservative, but lambdas (e.g. lambda calculus) aren't. Type-based functions overloading (like type classes, I guess) is conservative, but Scala implicits are liberal.

In my view, the languages that are the most conservative (at least in my part of the world) are Java and Python. Why? Simple: they are the default language for almost everyone I know. You're at an enterprisey company? You're probably using Java. You're at a startup? You're probably using Python. You're using C or Scheme or Haskell or Erlang? You're crazy. (I should note that I don't know very many people in systems or embedded programming, so my view is obviously rather biased.)

All this rambling (I certainly see why Yegge always writes long posts) has left me with a fairly concise conclusion. Namely, mapping programmer attitudes to a spectrum vaguely inspired by politics is a reasonable idea. Sure, the reality is that there is no total ordering so a one-dimensional representation is fundamentally lacking. However, it's good enough to give some insight.

But I would not map technologies there based on the technologies' innate traits. Rather, I would map them there based on the thinking behind the people who use them. This is similar to how--if you don't know the background--it's hard to guess which political party supports which regulation. Gun control is the opposite of liberal, but it's exclusively heralded by liberals; deregulation seems liberal but, of course, isn't. Yet, on other issues, people on either end of the spectrum behave as expected!

This is why I think languages like Java and Python are fairly conservative. Not because they try to offer some sort of safety but because they are safe choices. This is also why I would probably place C# as significantly more "liberal" than Java--it may be the most "conservative" .NET language, but it is far less afraid of embracing new ideas than Java. So that end is simple: at least for enterprisey companies and startups, it's populated with Python and Java. But what about the other end? I think this is where the languages that most people consider too crazy to use go. Haskell, Scheme, Erlang and so on. Only very brave--very liberal--companies are going to use Haskell or Scheme in actual production. Too many weird features. Even the sentence "Scheme in production" just sounds weird.

So it's not a matter of wanting handrails (Haskell) or not even wearing a helmet (Scheme); rather, it's a matter of being willing to choose something more advanced over something more understood.