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 Amazon.com, 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.
Shared publiclyView activity