Shared publicly  - 
Return of the Mystery Machine Bus!  In 3D!

The inputs are in!  Everyone's had a chance to mull over my liberal/conservative distinction in the big world of programming styles and approaches to software engineering.  Lots of great feedback.

Thank you to everyone who took the time to think about this conceptual model and share your thoughts.

Here are a few things that jumped out at me, reading the feedback.

Surprise Factor

My distinction seems to have taken almost everyone by surprise.  I'd half-expected people to point me off to papers and articles that had already explored this metaphor.  But no, this appears to be a genuinely new way of looking at the programming world.

Which means, naturally, that reactions will range from hyper-enthusiasm to the Five Stages of Grief, and everything in between.  Mostly in between.  I think most of us are (justifiably) too happy with our awesome choice of career to get too riled up about this stuff.

The Unhappy Quadrant

As a rough generalization, it appears that political conservatives didn't seem to object to my taxonomy.  They're fine with being labeled either software-liberal or software-conservative.  And political liberals don't mind being software-liberal.  But political liberals HATE being labeled software-conservative.

As many commenters pointed out, though, it's pretty much inevitable at this point.  The metaphor is too useful to ignore.  The parallels to political science run deep.  I will explore more of them in today's little sequel.

Mad Marketing Rush

Some Clojure-language folks wrote a charming and possibly satirical response entitled "Clojure is not Software Conservative", in which they basically said:  "We are not sure whether this so-called liberal/conservative distinction is well-defined enough to be considered valid, so we're not really going to stoop to playing that game.  But we are most definitely NOT conservative!  We are liberal!"

I think the Clojure guys, to their immense credit, were the first to deduce a critical implication for programming language evangelists:  <b>You can only market a language to half the developers in the world.</b>  You can market to the left, or the right, or the center, but ultimately you're only going to appeal to the developers clustered around your language's basic value system.  And people are going to be way more aware of that now.  Languages are no longer going to be able to get away with saying "Ideal for Everyone!"

The Clojure post was a valiant attempt at market positioning.  And you have to hand it to them -- they aimed at the "bigger half", which is to say:  distancing themselves from the decidedly unpopular crop of highly conservative languages.  There's some truth in what they're saying, since Lisp itself is amazingly expressive and composable, and Clojure's syntactic choices are, I think, a genuine advance in the field.  The other Lisps could learn a thing or three.

But the reality is that Clojure is quite conservative.  As far as I'm concerned, if you can't set the value of a memory variable without writing code to ask for a transaction, it's... it's... all I can think of is Morgan Freeman in the Shawshank Redemption, working at the grocery store, complaining "Forty years I been asking permission to piss. I can't squeeze a drop without say-so."

And it's not just variables.  I could rattle off a dozen ways that the language imposes heavyweight protective machinery and restrictions that you don't see in, say, Common Lisp.

This is just a basic (and irreconcilable) difference of opinion.  It doesn't help matters for the Clojure people tell me: "No, really, we promise we'll let you urinate any time you want!  All you've gotta do is ask someone in charge!  It's practically a rubber stamp!"  I just don't want to have to ask.  In fact I don't want an authority in charge at all.  Period.

But that's just me.  Some people love it.  Having a conservative Lisp dialect is actually a cool thing.  I think we've needed one for a long time.  I think it's a great way to attract the H-M crowd into the wonderful world of Lisp.  I think you should be able to choose from Lisps all along the political spectrum, and Clojure has helped us fill out the offerings.  So go Clojure!

False False Dichotomy

Several folks decried my taxonomy as a logical fallacy of the False Dichotomy variety, thereby hoping to have the case thrown out of court on procedural grounds before it could go to trial.

I'll bet you can guess whether they were soft-cons or soft-libs.

Unfortunately they overlooked the fact that this is a court of Public Opinion, so the harder they fight, the more likely it is to go to trial.  Their best bet would have been to ignore me.  Oopsie.

And what will the ruling be?  I think sensible people will realize that projecting a complex multi-dimensional value space onto a single axis, though lossy, still has genuine value.

Take movies, for example.  How do you tell if you're going to like a movie, assuming you can't see the trailer?  What's the first indicator you look at?  Well, there's genre, sure, and some folks have halfheartedly tried to argue that genres might be a better taxonomy.  But we already have a bunch of genres in programming:  frontend, backend, n-tier, rdbms, distributed, real-time, etc. etc.  We're all specialists nowadays.  The notion of "genre" in programming is nothing more than a classifier for the problem domain.

Once you've picked a genre, I'll venture to guess that your main yardstick when deciding whether to watch a movie these days -- assuming it's not opening day -- is the star rating.  Maybe you use IMDb's rating, or Netflix's rating, or rottentomatoes or metacritic or whatever.  But you want to see an aggregate score.  Because it matters!

Let's say you're choosing between two movies to watch tonight.

Movie 1 has great sound, decent acting, world-class cinematography, sloppy film editing, a wonderful soundtrack, inconsistent pacing, an unsatisfying ending, incredible action sequences, a memorable plot, and laughably bad special effects.

Movie 2 has exactly the same description, but the adjectives are all rotated one clause to the right.

Which one should you watch?  I don't know!  What are their IMDb ratings?

A star rating has exactly the same problem as a political axis:  it's an oversimplification.  But it also has exactly the same advantage:  it gives you an analog metric and some confidence that you know roughly what the metric means.  <b>Even if it's only useful as a relative way to rank two similar things.</b>

If you think star ratings in general (for games, movies, iTunes songs, whatever) are complete bullshit, and that we shouldn't be using them, well, you're entitled to your opinion.  You don't have to look at them.  But most of us find them pretty useful.

And despite its problems, I think most people find the political spectrum useful too.

The Money Party

Some people argued that "conservative" really means "small government", so I should be using the term "liberal" for programmers who want a big automated nanny state protecting them from errors.

But let's face it:  that's a definition of "conservative" that hasn't been truly applicable to U.S. politics since World War II, if not earlier.  Today, both parties want to spend a crapload of money.  Republicans and Democrats are both arms of the Money Party.  All the debate nowadays is strictly over how the money will be spent.

We should probably model the programming metaphor on the social political axis.  In hindsight I shouldn't have confused the model by mentioning the "fiscal conservative / social liberal" problem (which is in fact a gaping hole in the U.S. political system -- the two-party system pretty much screws this large demographic.)

I actually think the axis we're comparing to would be more accurate if it went from Libertarian to Conservative.  That's a more faithful isomorphism to the underlying distinction I'm trying to make.  But I think it might cause more confusion than benefit.  So we'll call the opposite of software-conservative "liberal", and just between you and me, we'll know what it really means.

The Introspection Problem

Various people pointed me to articles, essays and even one TED Talk from Jonathan Haidt about differences between liberals and conservatives in the real world.  They were all interesting and relevant, so thanks for the links.

I found it noteworthy that all the attempts to model the fundamental nature of the disagreement between liberals and conservatives seemed to come from liberals.  Conservatives, rather than coming up with their own alternate models, simply dismiss the liberal models as irrelevant or off-base.

I'd love to see some pointers to essays from deep-thinking political conservatives that attempt to provide any metaphors, any thought experiments or conceptual models for the liberal/conservative spectrum itself, without reference to any particular issues.  Because what I've been seeing in my brief survey of political science is the same thing I've been seeing in the programming world -- namely, that many conservatives don't want to admit there are other valid viewpoints.

Some conservatives apparently just want to be "right", and anyone who thinks differently is just "wrong" -- but without going so far as to inadvertently legitimize the opposing position by giving it first-class citizenship on a smooth spectrum.  They just want there to be no spectrum at all.

That's obviously not true for all conservatives, so like I said, I'd love to see some pointers to conservative metaphors for the difference in world-view along the political axis.

The "Look and Feel" Problem

I think a lot of people took umbrage to being labeled "conservative", even when they clearly understood and more or less agreed with what I meant by the term.  Because they don't feel conservative.  On the contrary, many (maybe most) software conservatives feel quite liberal.  They're out to change the world too!  They don't think of themselves as stodgy or over-cautious or engaging in Security Theater or any of that other stuff I accused them of.  I've got it all wrong!  They're super liberal!  I'm just thinking about it wrong!

But here's the thing:  almost nobody feels conservative.  If you actually feel conservative, you're probably way off in the deep end in the conservative pool.  Middle-of-the road conservatives and slightly right-leaning moderates are going to feel liberal and open-minded and embracing of change and willing to take on "acceptable" risks.

I can tell you from personal experience:  just because I'm 43 years old doesn't mean I feel old.  I don't feel old at all.  I feel young!  In fact, I am young!  You're just thinking about it all wrong!  This whole "age" thing is a False Dichotomy!

Everyone feels young.  It's a fact of life.  How people label me, though, has nothing to do with how I feel.  If I look old, people are going to label me old.  And they're not wrong, because the term is relative.

I think a lot of the people who tried on the political-axis suit and found it didn't fit comfortably are missing a key point.  The labeling isn't based on how it feels to them.  The reason I'm drawing this whole political-axis distinction, and the reason I'm going to continue using this model as a didactic tool, is that liberals needed a way to label conservatives.

Why?  Because we don't want to work that way.  But software conservatives have increasingly been acting like a Moral Majority, where their way is the One True Way, and everyone who I'm now calling "more liberal" is just lazy and ignorant.

It's clearly all a matter of degree, since C++ programmers (moderates, by and large) are considered lazy and ignorant by hardcore Hindley-Milner folks.  Those C++ programmers are too lazy to learn a "truly" safe language, and they're ignorant in thinking that C++ is by any definition at all "type-safe".  Now the H-M crowd has to use the politically-correct term "liberal", and the C++ crowd has to use the politically-correct term "bear-shooter".

Oh yeah, and some folks thought this was just about types.  Not so.  Not even close.  It's much, much broader than that.

Just look at the hardcore relational data modelers vs. NoSQL folks.  They have historically denounced NoSQL approaches as naive, undisciplined and doomed to failure.  It wasn't until the NoSQL people rallied together and actually started marketing their views (including the catchy name, "NoSQL") that the data modelers had to back off even a teeny bit.  It was a case of marketing legitimizing a perfectly valid world-view that had been around forever but suppressed in a fairly ghastly fashion by the intellectual aristocracy.

So yes.  This distinction is phenomenally important, because it is finally giving programmers with a perfectly valid, proven world-view -- proven again and again in the marketplace -- a seat at the table.

Are you talking about Marketing again?

Ah, marketing.  Conservatives have always been really effective at marketing, because fear and uncertainty are incredible motivators.  Conservatives have made tremendous inroads in getting programmers to feel afraid of their code.  All they need is FUD, and they can get almost any crazy bureaucracy approved -- institutional, procedural, technological, you name it.

I've been fighting this marketing battle for a decade.  I'm not exaggerating in the slightest.  Ten long years.  I've written hundreds and hundreds of pages on the subject.  I've written articles, essays, rants, fictional works.  I'd have written limericks if I'd thought it would help.

But all that time I was making the mistake of trying to change the way software-conservatives think.  And of course that's not a tractable problem.  In fact the TED Talk I mentioned argues that it's a bad idea, and that we need diversity of opinion in order to keep looking at new problems (collectively) with a fresh perspective.  Seems plausible to me, although according to the talk, it's also precisely the kind of conclusion that only a true liberal could arrive at.

Now, though... now, after all these years, I think I've finally caught a break.  I found a marketing concept that actually solves the problem I've been fighting with, and it does so far more elegantly than I'd ever have hoped.  I've stumbled on a way to force the legitimization of the liberal viewpoint, simply by drawing the distinction as a political one rather than a religious one.

So let's wrap up the rebuttal and get on with solving mysteries and catching bad guys and stuff.

Do You Respect Your Code?

Time for an all-new generalization!  _Note: generalization._

I think there is a vast and fundamental divide in the way liberals and conservatives view their code.  Conservatives like their code, while liberals view their code as a necessary evil.

Political scientists have observed that U.S. Conservatives basically think of the United States as a force for Good.  They think the U.S. should go out and "fix" the rest of the world, so they can be just like the U.S.  They look at countries where people are suffering in any way at all and they think, "Gosh, why can't those good people have picket fences and credit unions and McDonalds and Wal Mart and all the other wonderful goodness of the U S of A?"

Whereas U.S. Liberals basically think of the United States itself as the primary problem that needs fixing.  They think of the U.S. as an evil military-industrial complex run by a corporate hegemony, and that it is well down the path of destroying the Constitution, abandoning its people, and turning, eventually, into something resembling North Korea.

It's an oversimplification, but it's at least partly true.  The Right, in general, thinks the U.S. is Awesome, and the Left thinks it's Broken.

And with that in mind, let's go back and look at your code.  How do you feel about it?

Wel, one way to look at your code is that it's going to last a long time.  Code has a long lifespan.  It's going to grow and grow, especially if it's successful, and eventually it will become so large, so many millions upon millions of lines of code, that no one human being could ever understand how all of it works.  So we need to take steps right now to make sure it's going to be extremely well-organized, and make sure we have automated tools that can help us understand and globally modify the code, and so on.

Another way to look at your code is that it's going to die -- and probably soon, at that.  You look back at all the projects you've ever been on, and you can't think of a single piece of code that wasn't rewritten at least once, maybe half a dozen times, over the years.  Hell, a lot of the projects you were on never even launched, or the launch was a dismal failure and the code was quickly retired.  Or maybe the launch was a smash success!  But then other engineers came along, and they brought new frameworks and updated designs to match the new biz requirements, and gradually, a piece at a time, they threw all the old code away and replaced it with new code.

Liberals view code itself as a problem: nothing more than reified technical debt.  Conservatives will often refer to their huge code base as an "asset" that has to be managed and protected, just like any other asset.  And liberals tend to think of their code base as a genuine liability, one that becomes increasingly problematic as it grows.

Conservatives say: "We need to plan ahead for millions of lines of code, to ensure we can manage it!"

Liberals say:  "Here is a loaded shotgun.  Keep it there in your drawer.  If we ever wind up with millions of lines of code, I want you to shoot me."

So their planning stages are incredibly different.  Liberals set out to minimize the amount of code they have to write.  All their decision-making revolves around how to keep the code base tiny and manageable.  If you can avoid code by using a helper binary, or by writing a script, do it!  If you see a DSL emerging from the bloat, embrace it!  (And at least to this extent, Clojure is a lot more liberal even than Java.)

Whereas conservatives immediately get to work start building huge bunkers for the oncoming storm.  And they never write scripts.  Conservatives hate scripts.  It's a dirty word to them.  Scripts don't have APIs and monitoring ports and stuff, and they're usually written in dirty hateful liberal typeless languages, and they're notoriously slow so why would you ever ever use one, etc.  Lot of hating on scripts in the conservative world, especially as you head farther right.

A lot of this difference in attitude comes down to basic respect for the code.  Conservatives respect their code like you might respect, oh, the Eiffel Tower.  It's an impressive achievement, even a beautiful one.  Conservatives always want to build the next Eiffel Tower, the next Louvre, the next Markarth.

In contrast, liberals "respect" their code in exactly the way that you respect a power outlet, a moving vehicle, a loaded gun, a box of dynamite.  They see code as a dangerous tool that you need in order to do an important job.  A programmer is like a lion tamer, and a big lion is a dangerous lion.  Liberals do whatever it takes to keep their code base as small as they can.  Right off the bat, the most important decision you can make in this dimension is your choice of programming language, because some languages are naturally and necessarily verbose.

I wrote about this in my essay "Code's Worst Enemy".  And many of the responses were just plain bafflement.  I had argued that code size is not just a problem, it is in fact the most serious problem you will ever face as a programmer.  And yet many programmers remain convinced that not only is it not a problem, it is one of the biggest non-problems!  It's, like, totally solved with refactoring tools and APIs and stuff.

Well, now we know why they they're baffled.  They feel like I'm saying that Rome is just too goddamned big.  I point at this huge, thriving, beautiful, astonishing, millenia-old architectural marvel of a city -- their software project, that is -- and I declare that the thing is more bloated than one of Yegge's blog posts.  And they're shocked and a little hurt.

But I'm not really saying Rome's too big.  What I'm saying is that that you can't build it, even if you're dead-set on trying.  You'll wind up building Detroit, or, God help you, the Adwords Frontend.

My highly liberal view is that it's always best to build something small and organic, and let it evolve naturally.  Liberals like me believe that this trumps everything.  And any liberal who spends enough time really researching the problem -- no fair if you give up before you've tried everything -- will eventually realize that the best way to do this, the timeless way, is by using Lisp.

But hell, even Perl works a hell of a lot better than Java.  I dislike Perl immensely because (I've come to realize) they're way more liberal than even I am.  Well that, and I eventually found that Ruby gives me all the benefits without the irregularity.  But I watched Perl programmers kick Java's ass in one of the most apples-to-apples showdowns that may have ever gone down in the industry.  I wrote about it in my old essay "Is Weak Typing Strong Enough?"

Now, years later, I see that the answer is pretty clear:  it depends on YOU.  The choice comes down to your own personal values, beliefs and preferences as a programmer.

Applications as Cities

When conservative programmers set out to build a system, they think of it a little like building a city.  They do their city planning, and the design their little scale models and artist's visualizations of the city, and they plan ahead to contain sprawl and to keep stuff organized.

When liberal programmers set out to build a system, the think of it more like building a military encampment.  Get the thing built fast.  Make sure you can tear it down or reorganize it fast.  Don't waste a bunch of time on building it to last.  You're going to have it for a month or a year or a few years, but it's just there to get the job done, and at some point it's almost guaranteed to move.

Only after a LONG time, after they've proven that the military really needs a base there, do liberal programmers start talking about making it a more formal thing.  By then they'll know exactly how it interacts with the surroundings, and how the logistics and supply lines need to work, and where it needs to be defensible, and so on.  And even then, they just build a bare-bones base, because anything fancier than that is just gonna hurt your feelings if it gets blown up.

Order and Chaos

We're almost done with this episode's blatant stereotyping of liberal vs. conservative software developers.  I think we needed this sequel to finish the job properly.  I think I almost could have gotten away with it last week, if it weren't for you meddling kids!

Conservative programmers want to write beautiful code.  They want to write orderly code.  Early on in the comment threads, I joked that conservatives should be happy that I didn't use the Dungeons and Dragons alignment dual-axis of Law/Chaos and Good/Evil as my metaphor.

But then several commenters observed that this debate really seems to center around the desire for order.  If we assume this isn't due to OCD, then it's really just another way of saying that it centers around risk management, because orderliness can yield -- well, if not safety, then at least the comfortable feeling that you always know what's going on.

So the D&D scale isn't actually so far removed as you might think.  In my many debates with conservative programmers over the years, they have often wound up saying:  "But your position is inviting chaos!  It's going to be pure chaos!"  And true chaos, of course, leads to lots of uncertainty and risk.

But there's "chaos" and then there's "natural order", which can appear quite chaotic from the outside.  Christopher Alexander spent a lifetime examining the curious phenomenon that he called "Quality Without A Name" (QWAN), in which he noticed that organically-evolved architectures and habitations were often far more beautiful, functional and ultimately livable than their orderly, organized top-down-designed counterparts.

If these places are more livable and functional, then surely we're not looking at chaos so much as a natural, domain-specific set of underlying forces governing the growth of the system.  They may not all be controlled by some central planning authority, but every single individual decision is made by a thoughtful person who does what is best for that particular situation.  And the result is beautiful.

So yes, we are talking (also) about Law and Order vs. Organic Evolution.  To a conservative, organic evolution is chaos, and they can always point to some big code base or system that they claim everyone hates because it's "weird" or "messy".

Oddly enough, those systems they point to are usually in massive use.  I'm not much into channeling Stroustroup, but his point about there being two kinds of systems, "the kind nobody uses and the kind everyone bitches about", seems pretty relevant here.

I mean, how often can you point to any big legacy code base, and say, "Oh, everyone loves that code base.  It was so well designed!  It's just wonderful.  We love working in that big beautiful beast."

The fact is, one person's beautiful code base is another person's nightmare.  Every code base on earth is a code base that someone is just itching to rewrite.  Hell, I wanted to rewrite Emacs at one fairly junior point in my career (in Java, no less), because in my juniorosity I craved the orderliness that Java promised me.  Nowadays I feel like the Emacs code base is a turd that smells... not so bad.  Better than most code bases, even.  Although the lack of unit tests is creating an awful reek.  Jeez, guys!

Action at a Distance

Last topic, very related to the Law/Chaos angle.  I promise:  it's the last topic.

Conservative programmers HATE action at a distance.  Actually that term is way too generic for the small set of ideas I have in mind here, but it's the term conservatives use.

"Action at a Distance" refers to anything that can change the behavior of YOUR code behind YOUR back.  In other words: general extensibility.

This is a pretty serious philosophical divide.  In one camp, we have Emacs, which provides so dizzyingly many ways to conduct action at a distance that you can never, ever be sure how your code is going to work on someone else's system when multiple plugins get together.  Not unlike JavaScript in browsers, really, except Emacs is even more over-the-top in providing a playground for layered, interleaved plugins that all smack each other around as they see fit.

Conservatives frigging hate that idea.  They are extremely attached to their code, since (as we noted before) they want it to be beautiful and orderly and last a long long time.  So anything that allows users to come in and change the private parts of the code puts conservatives into Fight or Flight mode.

Back when I was at, Gregor Kiczales, inventor of Aspect-Oriented Programming (AOP) and Liberale Academique Extraordinaire, came and gave a jaw-droppingly awesome talk about how AOP could allow people to write code that modifies the runtime behavior of other code.

The Amazon Java engineers understood the idea, but not why you'd want to do it.  They asked why, and Gregor said, in a nutshell, "Because sometimes code is Broken, and this gives your users a way to fix it without bothering you."

And the Amazon Java engineers said:  "But Sir, you are mistaken.  Our code is Awesome, and keep your filthy grubby paws off it."

Then I went to Google, and the same thing happened there.

There are all sorts of ways to provide action at a distance.  Classic OOP subclassing is one such way.  If you've so much as glanced around lately, you'll have noticed that subclassing has fallen into extreme disfavor with Java programmers, as they have gradually realized that it lets people do shit that the authors really didn't want them to do, and this makes them very uncomfortable.

In languages where everything is public by default (e.g., Ruby, Python), and especially in languages that have metaprogramming hooks (e.g., Ruby, Python), action at a distance is pretty easy and pretty normal.  Although Pythonistas kind of frown on it, being stodgier than the usual liberal.  They're still liberal, very liberal.  But they're stodgy-liberal.  If you want to use lambdas and metaprogramming and eval and stuff, be prepared to get the Frowny Face from them.  Followed by:  "Well, we're all adults here, so do whatever you want.  Just be warned:  you're inviting chaos!"

Python really straddles the line.  Liberal-ish language, conservative-ish community.  I ranked them as middle-of-the-road "Liberal" in my now-infamous lineup last week.  But I love 'em all the same.

In Java and to some extent C++, the idea of everything being public is side-splittingly comical.  They'd have your head for it.  Not in some allegorical sense, either.  They'd cut your goddamned head off and post it on youtube.

I wrote about this lovely cultural phenomenon in my academic research publication, "Wikileaks To Leak 5000 Open Source Java Projects With All That Private/Final Bullshit Removed".  And oh man, did the Java community ever flip their shit over it.  Search for "steve yegge pile of fetid dingo kidneys" or "steve yegge is an idiot" if you want to see some of the reactions.

At the end of that post, I compared Python's attitude with Java's, with respect to open-source software.  In the Python world, when they open-source something, they recognize that they're basically giving it to you.  If it doesn't meet your needs, but it's close, then hopefully you'll find a hack that forces it to work the way you want.

Whereas in Java-land, they DO NOT want you doing stuff "behind the code's back", even if it's open source!  Even if they're dead and gone!  It doesn't matter to them.  They defined the way it should work, and they carved it in stone, and Tough Shit if you don't like it.  They'd rather have you fork the code base than make it generically extensible (as opposed to narrowly extensible through predefined and probably-wrong channels).

And Java people are moderates!  Well, moderately conservative, anyway.  In strongly-typed languages, they've built protections into the language syntax (and in Clojure's case, into the runtime) to prevent you from EVER accessing something outside its intended scope or purview.  At least in Java you have Reflection as a back-door, if you really need it.

And that's all OK.  Every programmer out there is entitled to their opinion on these issues.

Me, though -- I want to work with programmers who don't need the software equivalents of "Baby on Board" signs on everything.  And nowadays I would rather build throwaway military encampments than cities of stone.

Or put another way, as I once argued in my essay "The Pinocchio Problem", I would rather build living systems than dead ones.  Yes, living systems are scary and unpredictable and they can sometimes bite you.  That's why you want a tiny lion rather than a big one.  But I'll take a real one over a stuffed one any day of the week.

Your mileage may vary!  Stuffed lions are nice too.  Rawr.
Andrew Pennebaker's profile photoSpencer Clark's profile photoHugo Schmitt's profile photoPhillip Johnson's profile photo
While in real life politics you have a choice of being conservative, liberal, anarchist, green, whatever - that's not the case with the current languages, runtimes and environments. Imagine Mars Curiosity Software written with liberal languages, and most of the unix shell scripts with conservative?

So the problem is that there is no choice, even if you want one. The current state of programming is like back in my old Bulgaria - you can vote, as long as you vote for the Red Party :) the difference here is that the "Red Party" is the project/target you are working for.. If it's your DESKTOP - then you can be liberal/conservative, but if it's a console video game - better be conservative....
"Why?  Because we don't want to work that way." Ah, now the cat's out of the bag. You want an excuse to avoid software engineering practices that you don't personally enjoy, and do so by saying "I'm just not that kind of person!"

Especially in the functional-academic realm of Haskell and OCaml (Clojure is still more in the java-business realm, along with Scala and F#), your dichtonomy makes very little sense. Yes, we want static typing, but we also have type inference.

IME, "conservative" or "liberal" approaches are mostly dictated by the domain. Of course people writing life critical software will use static checking and strictly enforced policies. Of course web developers (working for fickle businesses who have only the vaguest idea what they want) won't.
+Steve Yegge - Perl is too liberal for you?  So that makes me a raving lunatic liberal, I guess.  Maybe Dijkstra was right and I am "mentally mutilated" from early exposure to BASIC.
When I read your first post, it rang true. But the more I thought of it, the more I couldn't decide which side of the spectrum I'm on. I should be liberal. Bugs are not a big deal; programmers are only newbies for a little while; etc. - I support these. Indeed, I've always been the new software evangelist, pushing to use .Net when v1 was back in beta, and trying mongodb when nobody else at my company had heard of NoSQL databases.

But compile-time safety is the tool which enables me to be confident that my code is good enough to be published even without thoroughly testing it. I honestly think Haskell is a wonderful language because while it's a bit harder to get used to, it's considerably harder to have bugs in it. When I use non-typesafe languages I have to be careful, and I end up being a lot more conservative.

These are all stuff I support and want which you put in the conservative camp: Provably sound type systems. Mandatory static type annotations. Nonpublic symbol visibility modifiers (private/protected/friend/etc.). All-warnings-are-errors. Generics and templates. Build dependency restrictions. No type equivalence (i.e. no automatic conversions) for numeric types. Software Transactional Memory. Type-based function overloading. Pure-functional data structures. Lambda calculus.

That's more than half your list.

And why did you put "Continuations and CPS" in the centrist camp? Most conservatives, as I understand it, would be loathe to use those, as well as closures.

And yet I have to consider myself a liberal. Because your definitions above that make me one. So while I generally agree with your dichotomy, I must say your entire "Dividing up the Space" is causing it to look like a false dichotomy. Because whether someone likes a language feature or not doesn't make him a liberal or conservative. The ideals one supports in a more general sense do.
PS: The same goes to your examples about languages. Corporations can have ideals, and can be liberal or conservative. Languages can't.
The other day I came across this fascinating observation about mathematical Analysts versus Algebraists ( ) Unlike the soft-con versus soft-lib, basically all mathematicians seem to agree that Analysis versus Algebra is the primary axis along which mathematical style varies.

I suspect that Analysts are software liberals and Algebraists are software conservatives, but I'm not sure. so Steve, do you eat your corn on the cob typewriter style or lathe style?
+Steve Yegge     Just out of curiosity, does your political orientation match your software orientation in these terms? Mine definitely does not. Thanks for the post, I really enjoyed it. Please be sure to put up a few pictures when "they" put you in the stocks or burn you at the metaphorical stake. ;-)

You might consider that a consistent position of distrusting your "betters" ability to define your life crosses these boundaries.
"compile-time safety is the tool which enables me to be confident that my code is good enough to be published even without thoroughly testing it".  Um, no.  Just... no.
+Barry Kelly "Secondly, you impute a moral superiority to what you anoint as liberal. "

It's a valid point but one that people in the US are more accustomed to on a daily basis. The "liberal" viewpoint has a historical control of the narrative because its partisans are strongly represented in communication industries. Without worrying about whether that's a good or a bad thing, it's easy enough for Americans to discount this kind of metaphor by their divergence from the accepted narrative.
+Derek Hohls Perhaps I overstated it a bit - it's not like I'd release any code without knowing it works. But compile-time safety helps quite a bit there.
Again with this? Alexander seems to me more on the conservative side. I mean the book was Timeless Way of Building right? Notes on synthesis of form all about resolving systems of forces. Pattern languages - all this is codifying natural processes and seems more a type-safe equivalent. Again mixing too many things you LIKE (organic growth, type weak) and thinking they are on the same side of their respective spectrums.
Last week's post and this week's one are priceless gems if only because they mean I can finally give up having this conversation.

me: why oh why oh why do you want to work it all out on day one when you have no [effing] clue how it will get used in practice; can't we just try a little bit today and see how that works out?

them: we think you are wrong. we have thought long and hard about this. can you not see beauty of what we are building here? Can you not see the glory in it all?

Me: Erm, no, it looks like a LOT of stuff and I'm worried you want me to support all that crap. Isn't there some way we can write less?

Eventually I give up. You have to with zealots. They let you change unimportant details but their edifice of perfection cannot be assaulted ... by definition.
I still don't think you understand Clojure very well.  It's conservative in managing state, sure.  Anything else?  You seem to think it has all these access modifiers but it doesn't.  Yes, you can declare x ^:private but you can still easily access x by (deref #'x).  Clojure does not block anyone from changing the behavior of other people's code.  It is done all the time.
The MSL (Curiosity) has been mentioned a few times, but it really (IMHO) only enforces the point +Steve Yegge  is making. Remember "conservative" here means "risk averse" and the amount of risk you are willing to take is obviously not just a personal preference but also very much related to the cost of any failures. With a piece of technology as complex as the MSL being so far away, where just the tiniest glitch may make you lose everything, you naturally spend extraordinary amounts of effort ensuring that everything works.

I have not worked within the space industry myself, but I can assure you that nobody writes code the way NASA does for stuff that is to leave the planet. I once saw the claim that that NASA does about a page of documentation per line of code! When was the last you released a full application where every loop was formally verified to terminate?
+Dor Kleiman While it may be true that a language as such does not have ideals, one should not forget that a) languages are always designed by somebody and they most likely had lots of ideas and ideals that they have tried to engrave into the language and b) a language is only relevant when it is actually and those using a language tend to have ideals etc as well.

In that sense, I think one could defend the position that languages and corporations share the same status wrt ideals. It is of course not a corporation as such who has the ideals, but rather the CEO or the engineers, ie., the people that sits inside of the corporation that have such.
Steve, I enjoyed your post. [Actually I've totally missed the second half before writing this, which makes my reply somewhat pointless, but here we go.] It generates a lively debate. As others have pointed out, the conservative vs. liberal choices are in many cases driven by the situation you find yourself in, and a single person can be  "liberal" and "conservative" at the same time depending on the issue.

Example 1: I spend much of my life writing a mixture of C++ (conservative language) and Python (scripting, liberal language). 

Example 2: You say conservatives like to build big, beautiful things, while lion-taming liberals focus on keeping the code base small and manageable. IMHO a good goal is to strive for code that is both beautiful (i.e. you can be proud of it) and small.
"I would have written a shorter letter, but I did not have the time."
Whether you get a better bang for your buck by cutting off dead wood or polishing existing stuff to fit your story is very  context dependent.

Example 3: Consider yourself a lucky owner of a big mission critical LEGACY SYSTEM (a billing system might be a good example). It has been written long ago by people who have since left using languages and programming styles that are no longer in use.

At first, you have no clue how this thing works and what it does. Your primary goal is to keep the damn thing up and running. If you are making any changes at all, they are small, incremental, and you risk making changes only to fix the most egregious bugs. In my mind, that approach is flat out conservative. On the other hand, the legacy system is just like the big dangerous lion that liberals are supposed to be good at taming.

Over time, as you gain more insight into how the legacy system works and what the business requirements are, you start thinking about rewriting the system from scratch, with clean design, using modern languages and programming techniques. The new system's going to be beautiful and clean. Building Eiffel Towers is something you put in the conservative camp -- but then, proposing to throw out a legacy system and replace it with something written from scratch sounds pretty radical (i.e. non-conservative) to me.
+Martin Pál And when you finish rewriting your billing system using "modern languages and programming techniques", you will have built tomorrow's legacy system.
I find it ironic that someone who claims to love small code is notorious for writing long-winded rants.
I'm not sure if it's even worth responding given that the number of people who might read this far is vanishingly small, and that you've shown a propensity to totally misunderstand and misrepresent what people are saying, but here goes...

I'm not even sure you read Chris Houser's blog article. In it he used your criteria for judging a language conservative or liberal, and he showed how based on your own criteria Clojure is a "liberal" language (whatever that may mean). Your summary of his article is hand wavy and a strawman to a 't'. I find it telling that you do not link to the article, so here's a link for those who want to examine the facts.

Secondly, Clojure does not require a transaction to modify memory. You can use a number of different reference types (including the software transactional memory), but you also have the option of dropping straight down to Java's classes with all their glorious mutability, if you so choose. There's no requirement to even use Clojure's reference types.

As for the rest, I don't think the Clojure "community" reacted one way or another to your post. The Clojure community is made up of many different individuals (the vast majority not coming from "conservative" languages contrary to your belief. c.f. that form their own opinions. As for me, I'm not sure its even worth considering the rest of your thesis given how sloppy you have been in reasoning about Clojure. I don't intend that to be disrespectful. Perhaps you are still forming these ideas and I should give you some time to solidify them. In the mean time, please refrain from making baseless, fanciful statements about things that you don't fully understand.
Xah Lee
i was thinking that the first episode is a joke. But this follow up seems to indicate it's not a joke. Maybe it's a extended joke. I was thinking the first one is a marketing ploy for Google Grok.

tldr, but got a urge to share.

but mostly am humbly waiting for Steve's pen on emacs again, and parsers and compilers.
I did point to the Worse is Better paper. It is not exactly a new distinction, though the nuance is different.
"I could rattle off a dozen ways that [Clojure] imposes heavyweight protective machinery and restrictions that you don't see in, say, Common Lisp."

Please do so.

Your liberal and conservative criteria from your previous post clearly show that Clojure is on the liberal side of the spectrum. Apparently you have some more fundamental criteria that you are using but are not sharing (the new one you listed is not accurate either). Please don't keep your actual criteria a secret if they really are your core evaluation criteria.

If your original lists really are the most important criteria, then you should reconsider your evaluation since the Clojure language is clearly on the liberal side if we use your own rationale you have already shared. Did you actually read ?

Perhaps your real problem is with the Clojure community rather than the language itself. If so, then why make the distinction for python but not for Clojure? A recent Clojure community survey shows that very few in the Clojure community come from languages that you label as conservative:

Please be honest about how you are evaluating Clojure and share your real criteria (or at least be honest about your real motivations for singling out Clojure).
+Steve Yegge 
>As far as I'm concerned, if you can't set the value of a memory variable without writing code to ask for a transaction, it's... it's... all I can think of is Morgan Freeman in the Shawshank Redemption, working at the grocery store, complaining "Forty years I been asking permission to piss. I can't squeeze a drop without say-so."

If we follow this line of thought, then every language with garbage collection is necessarily conservative. Since, you don't get to decide when and how memory is allocated. I see no difference between GC and STM in that regard. When you change a variable with STM, the same thing happens from user perspective as without it, the value of the variable is changed.

What STM does happens transparently, and the only difference is the performance hit. Likewise, when we allocate things with garbage collection, we take a performance hit in favor of having to manage memory by hand.
Worrying about whether clojure is liberal or conservative misses the point. It doesn't matter whether your favorite language is your preferred leaning or not. Steve's point isn't about what leanings a language is. His point is much bigger than that.
I came out as, basically, libertarian.  Extremely conservative in several areas, conservative in others, and even in a few, liberal.  It was an interesting exercise.
+Paul Michael Bauer So, a one-dimensional topology (fuzzy or otherwise) is better than none at all?  Defining a matrix in textual form seems a bit difficult to accomplish, and probably is pointless.  He took a swipe at VB, but using it "option strict on" and "option explicit on" and using only strongly-typed variables changes that swipe just a bit.  I'm beyond claiming that one language is better than another.  Some are easier to work with, some are harder.  Some can accomplish finer-grained results, some can't.  Basically, it comes down to the syntax and semantics and which you favor best.  Or, you have to use a particular language due to stated requirements. 
This is starting to sound a lot like the debate whether software is a craft or engineering.
+Joshua Foster it isn't a craft or trade that attempts to accomplish engineering (and perhaps other) requirements?
Dave Purrington: I think you'll find that the rants are mostly 1- or 2-paragraph ideas which are kind of related and happen to be in the same package. :)
Bob Uhl
As I commented on the original post, I think 'libertarian' vice 'authoritarian' is less politically-fraught. It also has explanatory value: an authoritarian can live an ordered life in a libertarian state in the same way that he can write ordered code in a libertarian language, but the reverse is not true.

OTOH, conservative and progressive views of the world cannot coexist in the long term.
Hmm. I've generally argued that it's fine to make stuff private by default in an open source project, because if you really want to, you can fork it and make it public in your project's version, and nobody's going to stop you. It means you've decided to open the hood and tinker.
+Bob Uhl " conservative and progressive views of the world cannot coexist in the long term."

Certainly they can. Given a willingness to move to Texas or California there's no need for either side to triumph.
The spectrum goes from hard conservative to flaming lefty, and many gradations in between.  Let's not create false duopolies.  This spectrum may be different in place to place, but the spectrum has existed for a long, long time.  Define the points of agreement: the "meet points."
+Steve Yegge Dude, I've been waiting for 2 years (since I found your blog) for you to write these two articles.  

But why you'd consider yourself politically Liberal, I can't figure out.  You practically channeled Ludwig von Mises with that natural order versus chaos stuff.  
+Steve Yegge - the reason why subclassing has fallen out of my favour is that it's too tricky. e.g. and the next 2 items.

Anyway, after suitable soul-searching, I decided that I'm a liberal for my code but everyone else should behave themselves because their code sucks unless they're forced into the conservative world-view.
If the systems I code go down, people can't tune into the television stations of my customers.  Ratings go down, irate phone calls, drinks get spilled.  Unlike some, I can't afford unhappy customers.   Good MTBF starts at about 8,000 hours, with MTTR calculated in minutes.  But, that was in the initial requirements.
Regarding prior art, the "Order and Chaos" section reminded me of a presentation someone gave at Amazon quite a while back using How Buildings Learn ( for a similar analogy.  Looking at the Amazon reviews, it appears it's a popular book for such software development analogies.

It's been a while since I read the book, so I'm not sure whether the book's suggested dichotomy perfectly matches what you're getting at with your political metaphor, but it seems like a similar approach: you can either build things that are Investments intended to Last Forever, or slap something together that people feel comfortable adapting to their ever-changing needs.
Thanks +Steve Yegge, this follow up post adds good perspective to the main one. It makes your intentions very clear, and you are definitely on to something regarding the way the world works as against how we may feel it should work. 
Hope you're luck with getting Wyvern back up is going well. Looking forward to playing again soon!
I don't think this axis is a false dichotomy, I just think it's the wrong dichotomy.  I agree that there are some programmers who can be split up on your axis.  But most programmers I know are flexible on this one.  They use the right tool for the job.  I suppose there are probably people out there who will only write code in C++, or only in Python, or only in Javascript.  But I don't know anybody like that.  I for sure don't know anybody who "doesn't write scripts."  Everybody writes scripts.
Two (unrelated) things:

Firstly, I don't think it's correct to describe software-conservative
and software-liberal as purely a personal choice.  Obviously, most
programmers will prefer one or the other, but there are times when
each is the rationally correct approach.

For example, a web startup should be software-liberal because getting
stuff done and working fast is the highest priority, bugs are
generally forgivable and ugly code is not a problem because everyone
in the office knows its quirks.  However, once that startup reaches
profitability, it needs to become much more software-conservative.
Downtime is a huge cost and the codebase needs to be maintainable so
that new hires can get up to speed quickly.

Secondly, I think you shouldn't have used the terms "liberal" and
"conservative".  They have too many other connotations and that's
derailing the conversation.  "Lawful" and "chaotic" would have been

(Well, unless you deliberately chose the loaded terms to get more
attention, in which case I salute your deviousness.)
So. I disagree almost completely with almost all of this! (Including last week, because I missed last week :P)

Most importantly, I disagree with the fundamental initial assumption that documenting/giving names to this divide, if it exists, will help communication. Even if we pick less politically-charged names.

Because, once you make something about politics, about choosing a side in an (assumed-to-be) unresolvable war of ideologies, human ingroup/outgroup biases take over and make that assumption true. "Agree to disagree" is not a good thing! Or — to be more accurate, it's a warning sign of a nonfunctional discourse process.

It is, I think, entirely possible to sit down and have a rational discussion about whether Project X's maintainability requirements would be best served by type safety and/or provably sound properties and/or granular unit testing and/or rapid iteration. But if I've bought into the fiction that I'm Totes Chaotic and my Stodgy Old Team Leader Is So Lawful You Guys Look What He Did To Awesome Bob's Project, then I'm not even going to try. I'm just going to say fuck'em, either to his face (and thus have to find a new job immediately) or, more likely, to myself and my fellow Chaoticeers (and thus have a bit more time before I go find a new job).

Yegge, it seems you see this as a good thing. And while in some cases it probably is, I really don't think that decision should be based on stereotypes of other programmers reinforced via confirmation bias and affect bias based on labels you have assigned to them. Yes, sometimes you have nonfunctional discourse processes, but throwing out a terminology into the wild that will only increase their incidence seems like a bad idea!

It's possible I'm being overly optimistic; after all, you have several orders of magnitude more experience in the realities of software development than I do. Still, the number of people in these comments who are decrying it as a false dichotomy, are confused about which side they fall on, or say that it's domain-specific, make me think I'm not completely off-base here, that discussion can and does happen without breaking down because of irreconcilably different ideologies of software.

(I also think that the distinction you're painting doesn't exist, that you've got a lot of factual points wrong, and that False False Dichotomy is a false analogy that misses the point, not to mention that similar arguments exist in those fields even though they're highly different from software development. But I'm not going to get into those now. No sir. Focus on one point, that's me.)

Still, it looks like your main goal here is to fix a Marketing problem you've been facing for ten years (!), and you've found what you think is the right way to do that... which suggests that whether this terminology is valid or even useful doesn't actually matter to you :P And this was a genuinely clever (if Evil~) way to make Chaos legitimate.

And you're likely to succeed; you're goddamn Steve Yegge; a lot of people read you, and this terminology feels right to a lot of folks. The only reason it didn't suck me in is that I adore both Haskell and Ruby, but that's more a function of you misunderstanding Haskell than any flaw in your presentation

Just... you should know that I grew up as a programmer to a large degree on your posts. I found amongst them much joy, and wisdom, and learning. You had a knack for saying the kinds of things I was thinking, incisively and accurately, and never succinctly.... And when you weren't saying what I was thinking, you would convince me.

I respected you. 
your assessment of Clojure continues to be wrong. in response to not being able to set a var... the function you are looking for is called set! ... and macros are sometime eschewed because they are not flexible enough. you can use macros to do metaprogramming but its had to do metaprogramming on the result of calling a macro.
"Note - you cannot assign to function params or local bindings. Only Java fields, Vars, Refs and Agents are mutable in Clojure."
"You can only market a language to half the developers in the world." I'll stick to the half that doesn't take these analogies too seriously, then.
Is the Mystery Machine Bus going to visit New Verden ?
Clojure is a Lisp, which means they've already conceded that they will only market to the small portion of developers who are willing to work with a Lisp.
Clojure's target audience includes the less small portion of developers that where not willing to work in any of the existing lisps. Some of these people needed a lisp that worked with java library X. It is also useful to be aware of the significant differences between Clojure and other lisps (which have driven away some Lispers)
A fair point. My statement was not meant to be a knock against Clojure. I think it's a fairly uncontroversial statement that Lisp is not very popular. A lot of developers have already decided that they don't want to work with any Lisp regardless of what improvements it offers over existing Lisps, since they just don't like s-expressions. Looking at the discrepancy in uptake between Scala and Clojure seems to bear this out, if we consider the job trends graph in this post to be accurate:
Thank you very much Steve for these great posts!!! I personally pretty much sharing views you described here.
Although I still have reservations about the metaphor, I love these posts. But since you've brought it up a second time, I want to address the classification of Python. 

It kinda bothered me in the first post when you placed Python in the same stripe on the axis as Ruby. Ruby is far more liberal than Python, both as a language, and a community.

Guido wanted to remove map(), reduce(), lambdas, and a bunch of the things that make Python borderline usable from Python 3. It was only because of community outrage that they've remained. The guiding principle of Python seems to be "won't someone please think of the newbies?" rather than "let's make this awesome and elegant and fun to code."

If you want to see a real example of how much more conservative as a language Python is than Ruby, just look at the attempts to build something like RSpec in Python. Thousands of lines for a buggy half-implementation, because Python is safe and holds your hand. None of that dangerous crap like monkey-patching Object, yield, etc. that make RSpec possible.

So, I dunno... Python might be a liberal-ish language, but not because Guido is a software liberal.
+Jason Lewis I have Python not one, but TWO levels more conservative than Ruby.  That's a pretty significant difference, and I attribute it 50% to the community and 50% to the language.  Although I am tempted to bump Python one notch more conservative, and Clojure one notch more liberal (but still left and right of center, respectively).  But it's an inexact science.

Guido's more liberal than you might think.  He was ranting about the need for the JVM to have a "Get the hell out of my way and just let me invoke stuff -- I know what I'm doing!" bytecode instruction years (at least six years) before they added invokedynamic.

I think having Python halfway between Ruby and Java is fitting.  Imagine RSpec in Java. :)
+Steve Yegge Wow, went back and looked, I must have mis-recalled the listing... I could have sworn Python and Ruby were originally mentioned in the same category. My mistake.

I definitely agree with the inclination to bump Python and Clojure in those directions, respectively. Although I totally get what you're saying that Clojure is extremely conservative for a Lisp, I think it's gradually shifting in a more liberal direction... at one point, I would have just pointed to the lack of CL-style reader macros to support the argument for Clojure's conservatism... but 1.4 has an extensible reader, so I think the willingness to compromise demonstrates a certain liberality of spirit.

I also wonder whether STM and immutability are that conservative, really. When you consider the typical alternative for concurrency is mutexes... blech, I prefer implicit thread safety to explicit. And isn't that liberal? Or is the liberal alternative Actor-based concurrency? Maybe no one knows. 

Python, on the other hand... I dunno, always felt too bondage-and-discipline for a scripting language. So, yeah, looking back, Python is pretty much in a fitting place. 

Also - asking someone to "imagine RSpec in Java" might be considered assault in some parts of Palo Alto. 

If I can implement something like RSpec in Clojure (I dunno if it's even possible yet, but might be fun), will you move it up next to Objective-C and Scheme? ;-)
Please hire me Steve. I feel like I could get so much done if I didn't have to spend all day explaining to people the dangers of having tigers in the code base.

It would also be nice to not have to deal with people coming to my desk and yelling at me because I turned their Saber-tooth tiger that they took so much PRIDE in writing into a house cat.
+Steve Yegge after subsequently reading this post, I'm convinced that you have to read Zen and the Art of Motorcycle Maintenance, because the author, Robert Pirsig, comes about as close as you can come to solving the introspection problem, and arguably bases the whole novel around it.
Clojure doesn't really hold your hand and prevent you from doing stuff, it just has some sane and opinionated defaults.  You are free to blow off your foot as efficiently and expressively as you want to, but you might have to spend 5 more minutes learning how than you would if you just did what you were trying to do the right way.  See alter-var-root for an example: .
Even though "conservative programmers HATE action at a distance", we always end up with a zillion knobs and commandline flags and config files in large codebases. Whether it's conservatives or liberals in charge, nobody knows how to balance that particular budget.
Hmm, will Clojure let me override fn with a macro? Not even the 'liberal' lisps do that..
ah, well actually, fn is a macro, fn* is the special form, so yea.  Unfortunately, since clojure is compiled, overriding will only affect code that's eval'd afterwards.  A more useful thing to do would be to create a macro for use in your own code, which I suppose is 'conservative'.
That's good enough for me! I think even 'liberal' common lisp won't let you override if. There might be tricks you can play with package locks, but I could never figure them out. In any case, this is at least some evidence that the picture is richer than a simple 1D spectrum; it's just about how many degrees of freedom the creator of a project affords later hackers.

(Plug: I hack on the side on a toy dialect that lets any keyword be overridden and extended:
Yes, at some point the answer becomes 'alter the compiler' :-).  But it's open-source, and arguably easier to read and understand than a C-based Lisp implementation (I tried to find my way around MIT scheme recently with no luck).
Yeah, I've poked around the clojure sources and they're quite decent. But it has less to do with "not being C-based" and more just "being younger". There are no bad languages, only bad codebases. And we don't know how to keep old codebases from turning bad..
wow, +Steve Yegge , it's cool to hear from you again, you write so rarely, but each time it's like a new whole book 

Is there any way to get these posts into my Google Reader?  That would be cool.  "Stevey's Blog Rants" RSS feed is feeling a little abandoned lately.  
of course you can generate rss feeds of any person's public posting through a third party web app (I'm gonna research the link for you, check out for an update to this comment in a couple of minutes) here - just add the gplus id (the big number on the profile page of someone) to make it work, and feed it to the reader
+Steve Yegge , I loved this post and the last one. Definitely noticed the rift between my liberal way of thinking about things and the more conservative approach and I can now see the cause of the problem much more clearly. 

One thing I've noticed is that it would be great if there were more resources to learn about liberal software concepts. For example, metaprogramming is a hugely valuable tool for liberals but there are a way more books on design patterns for conservative languages than on metaprogramming in liberal ones. Would you have any suggestions for a liberal reading list?
You guys at Google have what could be tagged "the software sense" and can do many things with it. Your approach to software programming  is a lot different. Just keep it up.

I am a recruiter specialist at gTeam FZ LLC and would like to invite you to apply to a software engineering position US based. With a guy like you, I believe you can work 40hours in 5hours and still achieve an even greater result. You may also be able to introduce relevant professionals to me. Skype me at yolepassionsedeuc68 or email waleolowode at Gmail.     
Turns out someone said the same thing over forty years ago!

Doug McIlroy, 1969, at the first ACM SIGPLAN conference in "Extensible Languages":

"I think that not all the languages we saw today are the 'sons of Algol.' In fact, I'd very boldly classify their Designers into two categories: the anarchists and the fascists.
"We have two anarchists in Irons and Standish; anarchists in the sense that these languages, particularly Irons' language, seem to be devoid of data types, preconceptions about scope, and persistence of data. They have, in some sense, the same capabilities as a computer has naked, before it has been reined in to run as an Algol machine.
"For extensions which are trivial, but perhaps more desirable to the user, the fascists (who say "anything you want to do, as long as it's my way, is all right") probably have the edge. For interesting experiments in language, I think I should turn more to the anarchists, who don't have so many preconceptions about how we compute. It is the fascists who are the sons of Algol."

(source: )

I discovered that gem via John Shutt's blog, who characterised the difference in terms of attitude towards programmer error -- more or less what Steve's distinction boils down to.

( )
Steve, do you still blog? I'd love to see more rants!
My god, don't encourage him!  His phone is probably already tapped by a platform-less android app.
He's probably talking to some manager if he can publish his internal rants? :P
Dear Steve. Haven't finished reading this yet. But. it's wonderful. Here's the good news. Opinion biases change. Social Linguistics Programing has a Code Language too. A shared history of Meta Formal Logic has informed our species to Superior Moral Code. (Ten Commandments, etc.) A Calculus of Variability is in fact modern social coding language. Just like with computer languages, the real problem of "Readability" is cultural. All cultures are selectively encoded for exclusivities sake. Code does not exist in a social vacuum and therefore is simultaneously "common &/or elite." In translation software, the issue of "Hermeneutics" proves that you cannot recompile unrelated languages word for word. Idiomatics are vague in every language. It is perspectives that cause change. Only symbol significators invoke sentimental attachment. I know that wasn't your issue, but as a "Meta Physician," I recognize willingness to encounter barriers of popular definition. This appeals to my sense of "Complementarity." Term stolen from Niels Bohr for that contentious battle between the bad dogs of science who focus more on controversies of bias, than on results. I don't waste time arguing. Right on dude. Really fun reading.
Add a comment...