×

Welcome to the Slashdot Beta site -- learn more here. Use the link in the footer or click here to return to the Classic version of Slashdot.

Thank you!

Before you choose to head back to the Classic look of the site, we'd appreciate it if you share your thoughts on the Beta; your feedback is what drives our ongoing development.

Beta is different and we value you taking the time to try it out. Please take a look at the changes we've made in Beta and  learn more about it. Thanks for reading, and for making the site better!

Software Engineering Has Its Own Political Axis From Conservative To Liberal

Soulskill posted about a year and a half ago | from the another-thing-for-pudge-and-jamie-to-argue-about dept.

Programming 283

An anonymous reader writes "Steve Yegge is back at it again. This essay is on the notion that software engineers range from conservative to liberal in their notion of software and how it should be built. He says, 'Just as in real-world politics, software conservatism and liberalism are radically different world views. Make no mistake: they are at odds. They have opposing value systems, priorities, core beliefs and motivations. These value systems clash at design time, at implementation time, at diagnostic time, at recovery time. They get along like green eggs and ham. I think it is important for us to recognize and understand the conservative/liberal distinction in our industry. It probably won't help us agree on anything, pretty much by definition. Any particular issue only makes it onto the political axis if there is a fundamental, irreconcilable difference of opinion about it. Programmers probably won't — or maybe even can't — change their core value systems. But the political-axis framework gives us a familiar set of ideas and terms for identifying areas of fundamental disagreement. This can lead to faster problem resolution.'"

cancel ×
This is a preview of your comment

No Comment Title Entered

Anonymous Coward 1 minute ago

No Comment Entered

283 comments

"They get along like green eggs and ham" (5, Funny)

Cornwallis (1188489) | about a year and a half ago | (#40944989)

Does this mean they sit on a plate waiting to get eaten?

Re:"They get along like green eggs and ham" (-1, Offtopic)

Cornwallis (1188489) | about a year and a half ago | (#40945009)

i don't know why I keep coming back to the trainwreck that /. has become. Kinda like picking a scab...

Re:"They get along like green eggs and ham" (1, Informative)

Anonymous Coward | about a year and a half ago | (#40945169)

It's a mild bit of psychological trauma, vaguely similar to hazing effects but on a much smaller scale. Since you took the effort to create an identity here, you percieve it as a part of your actual self. Since your /id is of no value anywhere else, your options are to abandon a piece of yourself or keep coming back here and see how far the place has fallen.

Me, I keep coming back because there's a rare chance of seeing an actual sentient commenter, and then wondering how long until he gets hate-modded to -3. It's like gambling, but the only wager is how much disdain I have for those spending modpoints.

Re:"They get along like green eggs and ham" (2, Funny)

Dunbal (464142) | about a year and a half ago | (#40945371)

Me, I keep coming back because there's a rare chance of seeing an actual sentient commenter, and then wondering how long until he gets hate-modded to -3.

You would probably be better off reading only negatively modded comments. There would be a lot less to filter out.

Re:"They get along like green eggs and ham" (-1)

Anonymous Coward | about a year and a half ago | (#40945353)

If this is the case, one wonders why you occupy the top comment on this thread. One must also wonder why you comment every two to six days here at the train wreck of Slashdot.

The first step is assessing the problem, which you've done. The second, and this is where you slip up, is removing the problem.

In other words; shut up if you have nothing to contribute, ok pumpkin?.

Re:"They get along like green eggs and ham" (2)

dpilot (134227) | about a year and a half ago | (#40945469)

Better yet, it's time for a social experiment. If he really devalues his /. ID that much, the reveal it.

Make a post containing his /. id, numeric id, and password. Make it so anyone/everyone can use his id. Then watch the fireworks. Too bad he also couldn't "fix" the password, so that the first hijacker can't change it and lock all other hijacker-wannabees out.

Re:"They get along like green eggs and ham" (2)

mwvdlee (775178) | about a year and a half ago | (#40945981)

I guess you're the type of person that enjoys picking scabs and then posting about it in public.
Your twitter account must be fun!

Re:"They get along like green eggs and ham" (5, Informative)

ildon (413912) | about a year and a half ago | (#40945141)

Terrible analogy. If you actually read Green Eggs and Ham to the end it turns out they taste awesome.

Re:"They get along like green eggs and ham" (-1, Troll)

Dunbal (464142) | about a year and a half ago | (#40945409)

I read it in first grade, I believe. Or kindergarten. I really don't remember, and I don't remember how they taste. That's what happens when you read more than one book. You forget little details like that. And while I understand that Teddy Seuss is quite insightful philosophy for some people, I'll argue that there are quite a few more profound books out there too. And they also taste awesome.

Re:"They get along like green eggs and ham" (4, Informative)

ildon (413912) | about a year and a half ago | (#40945805)

I'm not really sure what you're trying to say here. I haven't read it in over 20 years (possibly 25). The reason I know that at the end of the book they taste good is because that's the entire point of the book. The protagonist refuses to consume them because they look weird, and the antagonist insists he try them. In the end, he tries them and it turns out he loves them. The moral of the story is that you should try something before making a judgment on it.

Anyway, my point was that the analogy in the summary makes no sense whatsoever. I have no idea if it was cribbed from the original article or not because I didn't read the article because the summary was so bad, but whoever wrote it either had never actually read Green Eggs and Ham or somehow failed to grasp its message when they were 5 years old (or worse, failed to grasp its message when reading it to their own children).

Re:"They get along like green eggs and ham" (0, Flamebait)

Dunbal (464142) | about a year and a half ago | (#40945977)

I'm not really sure what you're trying to say here.

Neither am I, but that should change once the medication reaches an adequate blood plasma concentration. Nah I'm just being my usual ultra-cynical self, because some people (not necessarily you) believe that insightful and cute children's books rank up there along Plato, Aristotle, Descartes, Avicenna and the like. Has nothing to do with you, I'm just a grumpy old man with too much time on my hands.

Re:"They get along like green eggs and ham" (2)

Stuarticus (1205322) | about a year and a half ago | (#40946037)

Wait till you have kids, you can read it as many times, probably several more than that, actually. Would you like me to read it to you now from memory, or in a tree or on a boat, or with a goat?

Re:"They get along like green eggs and ham" (1)

wile_e_wonka (934864) | about a year and a half ago | (#40945681)

Totally, I mean, in the book both the eggs and the ham are green. It would be hard to suggest from the text that they don't get along--the book does not anthropomorphize them. They're just green eggs and green ham being forced on someone by some dude named Sam.

A better comparison would be to the fox and Knox in Fox in Socks. They don't get along. And they disagree strongly regarding the propriety of the use of a sort of code (tongue twisters).

Re:"They get along like green eggs and ham" (0)

Anonymous Coward | about a year and a half ago | (#40945711)

It might be great and all, but really now, could you, would you, with a goat?

Wtf is this shit (-1, Troll)

Anonymous Coward | about a year and a half ago | (#40945013)

It's about as accurate as a horoscope

Re:Wtf is this shit (1)

Coisiche (2000870) | about a year and a half ago | (#40945269)

I suspect his next missive will be on how your coding style is governed by your starsign[1].

[1] Obviously starsign as per the commonly used astrological calendar rather than the sun's actual position against the ecliptic constellations at the time of your birth.

Re:Wtf is this shit (1)

Dunbal (464142) | about a year and a half ago | (#40945463)

No, they save that last part for when their "prediction" fails to match up with what actually happens. So then they say "oh well, to get an ACCURATE forecast I need to know exactly where and when you were born".

You Say "Steve Yegge" Like I Would Know... (3, Insightful)

RobotRunAmok (595286) | about a year and a half ago | (#40945029)

...who the fuck he is.

Note to Sales Department: I get that this is Yegge's slashvertisement ("anonymous reader writes..." sh'yeah, right...) but you still need the editors to set it up better than this if you want those click-throughs.

Re:You Say "Steve Yegge" Like I Would Know... (2, Insightful)

hackertourist (2202674) | about a year and a half ago | (#40945065)

And if they want clickthroughs, better make sure TFA isn't on a subscribers-only website.

Re:You Say "Steve Yegge" Like I Would Know... (1, Offtopic)

gorzek (647352) | about a year and a half ago | (#40945159)

I was able to view it without being logged in, so I don't know what you're talking about.

Re:You Say "Steve Yegge" Like I Would Know... (0)

Anonymous Coward | about a year and a half ago | (#40945567)

Same here... I am learning to disregard knee-jerk reactions from people and read the article for myself (I almost skipped it due to this negative comment).

Re:You Say "Steve Yegge" Like I Would Know... (0)

gestalt_n_pepper (991155) | about a year and a half ago | (#40945219)

Standard operating procedure on Slashdot where the obscure software project, framework, language or technology is promoted as being something you all should have known about all along.

Good Point (0)

Greyfox (87712) | about a year and a half ago | (#40945259)

Maybe I'll start a kickstarter campaign to design the ultimate slashvertisement! I figure it should cost about 10 million dollars!

Re:You Say "Steve Yegge" Like I Would Know... (0)

Dunbal (464142) | about a year and a half ago | (#40945501)

He's a blogger and he has a page on wikipedia. How DARE you doubt his credibility, hater! /sarcasm

Hey maybe I could start slashvertising too. I mean I've been posting here forever. A couple people like me. Thousands hate me. I could be a famous internet authority! Authority of BS, but an authority nonetheless.

Re:You Say "Steve Yegge" Like I Would Know... (5, Insightful)

TheMathemagician (2515102) | about a year and a half ago | (#40945953)

I've no idea who Steve Yegge is or what he's supposedly "at again" but I wish he'd stop - or that /. would just stop featuring him. This article is just claptrap from start to finish where he projects his completely artificial and false one-dimensional scale onto clearly the only political model he knows - America's. Compile-time binding is conservative and run-time binding is liberal? Oh please.

Re:You Say "Steve Yegge" Like I Would Know... (5, Funny)

mcgrew (92797) | about a year and a half ago | (#40946049)

Well, I never heard of him, but he does have a wikipedia entry so he can't be that obscure.

A is like B, except where it is not: news at 11. (0)

Anonymous Coward | about a year and a half ago | (#40945071)

tl;dr I am a second rate blogger and am thinking up the most hit-absorbing way to get people to read my effluent.

Also you can assume I am the "wants to make money selling crap" wing, whatever that is.

(cue left-wingers saying "that's the right wing" and right-wingers saying "that's the left wing")

Re:A is like B, except where it is not: news at 11 (1, Funny)

noh8rz6 (2689737) | about a year and a half ago | (#40945263)

(cue left-wingers saying "that's the right wing" and right-wingers saying "that's the right wing")

Inser ftfy meme here.

Stay tuned for tomorrow's insightful blog... (-1)

Anonymous Coward | about a year and a half ago | (#40945107)

How life in the computer industry and software development imitates the Academy Awards.

What it means if you're a software libertarian (0)

Anonymous Coward | about a year and a half ago | (#40945111)

You write your own compiler, and you don't care if your code runs for anybody else.

Re:What it means if you're a software libertarian (1, Troll)

Enry (630) | about a year and a half ago | (#40945189)

Ahh, Java developers. *ducks*

Yep (4, Insightful)

Anonymous Coward | about a year and a half ago | (#40945113)

/. has hit rock bottom.

(for the record, this left/right, liberal/conservative, tweedledum/tweedledee polarization is bullshit. When you actually talk to people, you find a range of viewpoints. Know any concealed weapon carrying liberal democrats? I do. How about social conservative republicans who buy contraceptives? Yep. Or even worse, programmers who use the Visual Studio C# .NET WPF paradigm at work, and then use a Linux desktop coding open source at home. Probably so.)

Re:Yep (5, Interesting)

JWW (79176) | about a year and a half ago | (#40945257)

The conservative/liberal dynamic applied to software development is total bullshit.

Software development has and Agile/Waterfall split, professionals in the business know this, its as simple as that. Applying conservative and liberal as tags is stupid.

Re:Yep (2, Insightful)

Jawnn (445279) | about a year and a half ago | (#40945841)

The conservative/liberal dynamic applied to software development is total bullshit.

Software development has and Agile/Waterfall split, professionals in the business know this, its as simple as that. Applying conservative and liberal as tags is stupid.

...but buzzy, and guaranteed to generate views and clicks. Brilliant.

Re:Yep (2)

CAIMLAS (41445) | about a year and a half ago | (#40945887)

I was thinking kinda the same thing, but the agile/waterfall approach does have a psychological element as a preferential 'seed', from what I've seen. However, my exposure to developers is somewhat limited. Where I'm experienced is with systems people.

Just as in real-world politics, software conservatism and liberalism are radically different world views. Make no mistake: they are at odds.

What I have noticed with sysadmin types is that there is a very significant preferential competence bias for conservatively minded people. Creative, conservative people make damn good systems/network engineers as well. For whatever reason, it seems that there's a very high likelihood that a thorough, methodical, competent systems person has right-leaning political political view as well. I don't really get it, but I've not met many people who have broken this mold.

Linked article requires Google+ signon (-1, Offtopic)

Anonymous Coward | about a year and a half ago | (#40945123)

Fail.

Re:Linked article requires Google+ signon (-1)

Anonymous Coward | about a year and a half ago | (#40945195)

wow, a new low on /.

Re:Linked article requires Google+ signon (1)

Hatta (162192) | about a year and a half ago | (#40945367)

No it doesn't. I have no account with Google and I read the article just fine.

Re:Linked article requires Google+ signon (2)

mcgrew (92797) | about a year and a half ago | (#40945893)

Fail

Yes, you did fail. I had no trouble reading it, and I'm at work and can't log in to G+. You didn't miss anything though, the article was way too long, rambling, poorly written, and didn't really say much of anything.

Entire Article (5, Informative)

Anonymous Coward | about a year and a half ago | (#40945131)

Since you have to subscribe to Googer+ to get it (WTF?):

Notes from the Mystery Machine Bus

I've spent the past eight years (starting back in June 2004) writing elaborate rants about a bunch of vaguely related software engineering issues.

I was doing all that ranting because I've been genuinely perplexed by a set of "bizarre" world-views held dear by -- as far as I can tell -- about half of all programmers I encounter, whether online or in person.

Last week, after nearly a decade of hurling myself against this problem, I've finally figured it out. I know exactly what's been bothering me.

In today's essay I'm going to present you with a new conceptual framework for thinking about software engineering. This set of ideas I present will be completely obvious to you. You will probably slap yourself for not having thought of it yourself. Or you might slap the person next to you. In fact you probably have thought of it yourself, because it is so blindingly obvious.

But in my thirty-odd years as a programmer I'm pretty sure this way of thinking about things, if it already existed, has never been mainstream. That assertion is backed by what has to be at least ten Google searches that turned up nothing. So I'm pretty confident.

I'm going to make it mainstream, right now. Watch!

And I suspect this conceptual framework I'm giving you will immediately become, and forever remain, one of the most important tools in your toolkit for talking with -- and about -- other programmers.

The punch line, a.k.a. TL;DR

I won't keep you in suspense. Here is the thesis of this looooong essay. It is the root cause that motivated over half of my ranting all these years, starting at Amazon and continuing here at Google.

(Note: I Do Not Speak For My Employer. This should be patently obvious. When employers want someone to speak for them, they hire a person like the Mouth of Sauron, to make absolutely sure everyone knows they are speaking for the Employer.)

My thesis:

  1) Software engineering has its own political axis, ranging from conservative to liberal.

(Note: Technically, you could stop reading right here and be at pretty much 90% comprehension. In case you care.)

  2) The notions of "conservative" and "liberal" on this political axis are specialized to software engineering. But they exhibit some strong similarities to their counterparts in real-world politics.

  3) Everyone in the software industry who does stuff related to programming computers falls somewhere fairly precise on this political spectrum, whether they realize it or not.

Put another way, YOU are either a liberal or a conservative software engineer. You may be more of a centrist, or maybe an extremist, but you fall somewhere on that left/right spectrum.

Just as in real-world politics, software conservatism and liberalism are radically different world views. Make no mistake: they are at odds. They have opposing value systems, priorities, core beliefs and motivations. These value systems clash at design time, at implementation time, at diagnostic time, at recovery time. They get along like green eggs and ham.

I think it is important for us to recognize and understand the conservative/liberal distinction in our industry. It probably won't help us agree on anything, pretty much by definition. Any particular issue only makes it onto the political axis if there is a fundamental, irreconcilable difference of opinion about it. Programmers probably won't -- or maybe even can't -- change their core value systems.

But the political-axis framework gives us a familiar set of ideas and terms for identifying areas of fundamental disagreement. This can lead to faster problem resolution. Being able to identify something quickly as a well-defined political issue means we can stop wasting time trying to convince the other side to change their minds, and instead move directly into the resolution phase, which (just as in politics) generally boils down to negotiation and compromise. Or, you know, Watergate.

Are real politics and software politics correlated?

Does being a political conservative make you more likely to be a software conservative? I think all we have are hunches and intuition at this point. We'd need studies for an answer with any scientific basis.

But my hunch tells me that they are only loosely correlated, if at all. I suspect that the four possible combinations of political left/right and software left/right each contain around a quarter of the programming population, plus or minus maybe 8%. But that's a totally nonscientific hunch, and I'd love to see the real numbers.

The reason I suspect they're only loosely correlated is that I think a person's software-political views are largely formed by two forces:

  1) Their personal early/formative experiences as a programmer -- in particular, what kinds of decisions either burned them or made them wildly successful.

  2) The software-political core values of their teachers, professors, mentors, role models, and coworkers.

But there are some factors that could increase correlation between political orientation and software orientation. One is geographic/regional influence -- for instance, big tech universities being located primarily in red or blue states. Another might be basic personality traits that may incline people toward traditionally liberal or conservative value systems.

Regardless of how correlated they are, there are going to be a lot of programmers out there who are mildly shocked to find that they are political conservatives but software liberals, or vice-versa.

Isn't the 2-party system a flawed model?

Well, yeah. Mapping something as nuanced as political viewpoints onto a one-dimensional axis is a well-known gross oversimplification. For instance, some U.S. voters may self-identify as fiscally conservative but socially liberal, and as a result may wind up not having a strong tie to either majority political party. These "swing votes" tend to be the reason that political moderates more often wind up winning elections, even though studies have shown that people tend to assign more credibility to extreme opinions.

The influence of centrists or moderates is just as important in the software engineering world, and we'll explore it more in a bit.

But having a single axis still allows for a wide distribution on both the right and the left. As in real politics, a moderately right-leaning viewpoint may seem dishearteningly liberal to someone who lies even further toward the extreme right. I will illustrate with some well-known real-world programming language scenarios in the examples section.

All in all, despite its oversimplifications, I think 2-party model is a good starting point for educating people about the politics of software. It'll be a good frame of reference for refining the model down the road, although that's out of scope for this essay.

So what's a Software Liberal slash Conservative?

If you ignore specific real-world issues, and just focus on the underlying traits and values of real-world conservatives and liberals, it boils down to just a few themes. I'll argue that those underlying themes are also the basis for software politics.

It's easiest to talk first about conservatives, and then define liberals in terms of what conservatives are not. This is because conservatives tend to have a unified and easily-articulated value system, whereas liberals tend to be more weakly organized and band together mostly as a reaction to conservatism. This applies to both real-world and software-world politics.

So we'll start with an operational definition of conservatism, from Jost et al.:

  "We regard political conservatism as an ideological belief system that is significantly (but not completely) related to motivational concerns having to do with the psychological management of uncertainty and fear."

This theory is explored, re-tested and affirmed in a 2008 study from Garney et. al, "The Secret Lives of Liberals and Conservatives: Personality Profiles, Interaction Styles, and the Things They Leave Behind".

I hope you'll agree that this definition is minimally controversial. After all, the adjective "conservative" is more or less synonymous with caution and risk aversion. Financial conservatism is frequently (and intuitively) associated with age and with wealth. Companies tend to grow more conservative with age as they weather the storms of lawsuits, technical fiascoes, dramatic swings of public opinion, and economic downturns. We even have fables about ants and grasshoppers to teach us about conserving food for the upcoming winter.

Conservatism, at its heart, is really about risk management.

Similarly, liberal views are often associated with youth, with idealism, with naivete. In the corporate world, we think of startups as being prototypically liberal -- in part because they're setting out to change the world in some way (and liberalism is traditionally associated with change), and in part because they have to go all-out in order to hit their scheduled funding milestones, which can justify cutting corners on software safety.

Liberalism doesn't lend itself quite as conveniently to a primary root motivation. But for our purposes we can think of it as a belief system that is motivated by the desire above all else to effect change. In corporate terms, as we observed, it's about changing the world. In software terms, liberalism aims to maximize the speed of feature development, while simultaneously maximizing the flexibility of the systems being built, so that feature development never needs to slow down or be compromised.

To be sure, conservatives think that's what they're maximizing too. But their approach is... well, conservative. Flexibility and productivity are still motivators, but they are not the primary motivators. Safety always trumps other considerations, and performance also tends to rank very highly in the software-conservative's value system.

The crux of the disagreement between liberals and conservatives in the software world is this: how much focus should you put on safety? Not just compile-time type-safety, but also broader kinds of "idiot-proofing" for systems spanning more than one machine.

Let's characterize this core disagreement with some example statements that would be rated with much higher importance by conservatives than by liberals:

1. Software should aim to be bug free before it launches. (Banner claim: "Debugging Sucks!") Make sure your types and interfaces are all modeled, your tests are all written, and your system is fully specified before you launch. Or else be prepared for the worst!

2. Programmers should be protected from errors. Many language features are inherently error-prone and dangerous, and should be disallowed for all the code we write. We can get by without these features, and our code will be that much safer.

3. Programmers have difficulty learning new syntax. We should limit the number of languages used at our company, so that nobody has to learn a new syntax when a system goes down in the middle of the night on Christmas Eve. And we should never permit features that allow defining new syntax, nor changing the semantics of existing syntax. (Common examples: no operator overloading, and NO metaprogramming!)

4. Production code must be safety-checked by a compiler. Any code that cannot be statically checked should in general be avoided. In specific cases where it is strictly necessary, uses of it must be approved by a central committee. (Examples: eval, dynamic invocation, RTTI).

5. Data stores must adhere to a well-defined, published schema. Relational databases must be in third-normal form and adhere to a UML or equivalent schema definition. XML should have a DTD. NoSQL databases and name/value stores -- both of which should be avoided in general -- must have a separate physical schema that defines all permissible keys and their corresponding value types.

6. Public interfaces should be rigorously modeled. Data should never be stored in strings or untyped collections. All input and output entities should be thorougly and explicitly specified via statically-checkable, ideally object-oriented models.

7. Production systems should never have dangerous or risky back-doors. It should never be possible to connect to a live production system via a debugger, telnet shell, nor any other interface that allows the developer to manipulate the runtime operation of the code or data. The only ports into a production system should be read-only monitoring channels.

8. If there is ANY doubt as to the safety of a component, it cannot be allowed in production -- no matter how teams may cry and wail that they need it to make forward progress. (I'm talkin' to you, FUSE).

9. Fast is better than slow. Everyone hates slow code. Code should perform well. You should engineer all your code for optimum speed up front, right out of the box. Otherwise it might not be fast enough. Avoid using languages or DSLs or libraries that have a reputation for being slow. Even if they're fast enough for your current purposes, the requirements (or callers) could change, and suddenly the software would be too slow!

Of course these examples are meant to be illustrative rather than comprehensive. And obviously not all of them may necessarily be espoused by everyone who self-identifies as a conservative. But barring minor exceptions, they are all very common Conservative viewpoints.

To decide whether a system or a technology is liberal or conservative, just think of a bunch of independent "safety checkboxes". If a majority of them are checked, then the system is conservative as a whole. The more that are checked, the more conservative it is.

By way of comparison, here are the Liberal versions of the nine examples above. It might help to think of Scooby-Doo characters. The examples above are all from Fred, and the examples below are from Shaggy.

1. Bugs are not a big deal. They happen anyway, no matter how hard you try to prevent them, and somehow life goes on. Good debuggers are awesome pieces of technology, and stepping through your code gives you insights you can't get any other way. Debugging and diagnosing are difficult arts, and every programmer should be competent with them. The Christmas Eve Outage scenario never, ever happens in practice -- that's what code freeze is for. Bugs are not a big deal! (This belief really may be the key dividing philosophy between Conservative and Liberal philosophies.)

2. Programmers are only newbies for a little while. The steady state for a programmer's career is being smart, knowledgeable, creative, resourceful and experienced. Putting a bunch of rules in place to protect newbies from doing harm (or being harmed) is incorrectly optimizing for the transient case instead of the steady state.

3. Programmers figure stuff out amazingly fast when their jobs depend on it. People learn to read sheet music, braille, sign language, and all sorts of other semiotic frameworks. Hell, even gorillas can apparently do all that. Programmers don't need protection from syntax. They just need documentation and a little slack time to read up on it.

4. Succinctness is power. Code should be kept small. Period. If your static checking tools can't reason about the code, then the checking needs to be made smarter (e.g. by incorporating runtime data) rather than making the code dumber.

5. Rigid schemas limit flexibility and slow down development. Lightweight/partial/optional schemas are a better tradeoff. Moreover, the schema is often not well-understood until a lot of data is collected and a lot of use cases are thorougly exercised. So the schema should follow the code rather than precede it.

6. Public interfaces should above all else be simple, backward-compatible, and future-compatible. Rigorous modeling is just guessing at how the interface will need to evolve. It makes both forward- and backward-compatibility almost impossible, resulting in interface churn and customer unhappiness. Public interfaces should always do the simplest thing that could possibly work, and grow only as needed.

7. System flexibility can mean the difference between you getting the customer (or contract) vs. your competitor nabbing it instead. Security and safety risks in runtime production systems can be mitigated and controlled by logging, monitoring and auditing. There are plenty of existence-proofs of large systems with root-access backdoors and shells (e.g. RDBMS, online game servers) whose risk is controlled while still giving them world-class runtime flexibility.

8. Companies should take risks, embrace progress, and fiercely resist ossification. It doesn't matter how big your business is: it must grow or die. If you want to stay competitive, you have to make a conscious, often painful effort to take risks. Which means you'll need good recovery techniques for the inevitable disasters. But you need those even if you don't take risks. So take risks!

9. Premature optimization is the root of all evil. Get the code working first, focusing on correctness over performance, and on iterative prototyping over correctness. Only when your customers list latency as the top priority should you begin performing profiler-driven optimizations.

There you have it: Shaggy vs. Fred.

Just as in real-world politics, software liberals are viewed by conservatives as slovenly, undisciplined, naive, unprincipled, downright "bad" engineers. And liberals view conservatives as paranoid, fearmongering, self-defeating bureaucrats.

Once again, although I don't think the two camps will ever agree, I do think that mutual understanding of the underlying value systems may help the camps compromise.

Or at the very least, the conservative/liberal classification should help the two camps steer clear of each other. I think it is probably better to have a harmonious team of all-liberals or all-conservatives than a mixed team of constantly clashing ideologies. It's a lot like how vehicle-driving philosophies can differ regionally -- it's OK if everyone drives in some crazy way, as long as they ALL drive that way.

So Security Engineers are the most conservative, then, right?

Wrong! The reality here goes against intuition, and I mention it to show how poorly our intuition fares when it comes to interpolating software-political views from job descriptions.

Security engineers are deeply concerned with risk assessment and attack-surface management, so you might well guess that they would naturally tend towards software conservatism.

In practice, however, security engineers tend to be keenly aware of the tradeoffs between caution and progress, since they have to spend big parts of their day meeting with software teams who are often too busy (not to mention woefully underinformed) to spend a lot of time on security. Security engineers learn quickly to make well-informed and practical risk-management decisions, rather than conservatively always trying to be as safe as humanly possible.

Hence many security engineers are in fact software liberals. Some just swing that way.

Many of the security engineers at Google happen to be fans of Ruby -- both as an intrinsically secure language, and also as a nice, expressive language for writing auditing scripts and other security analysis tools. It wound up being fairly easy for me to get security sign-off for using Ruby in production for my first project at Google. In contrast, it was almost career-endingly difficult for me to get the same sign-off from our highly conservative systems programmers.

The reality is that almost any programming specialization is going to be divided into liberal and conservative camps. There are left- and right-wing versions of web developers, persistence engineers, protocol engineers, serving-system engineers, and most other sub-genres of programming.

I'm hard-pressed to think of any domains that tend to be mostly-liberal or mostly-conservative, with the sole exception of Site Reliability Engineering, which is sort of by definition a conservative role. For most of the other domains that initially came to mind -- for instance, data analysts, which at first I thought were uniformly liberal -- I've been able to think of specific teams or subdomains composed entirely of one or the other.

So in the end I think it comes down to personal preference. That's it. I don't think it's as domain-driven as much as it is personality-driven. Some people are just liberal, and some are just conservative, and that's how they are.

BIG FAT DISCLAIMER

Before I continue, I will now issue the important disclaimer that I am a hardcore software liberal, bordering on (but not quite) being a liberal extremist.

This fact, by and large, is what has driven me to pen many of my most infamous and controversial rants, including (among others) "Execution in the Kingdom of Nouns", "Portrait of a N00b", "Rhinos and Tigers", "Code's Worst Enemy", "Scheming is Believing", "Tour de Babel", "Dynamic Languages Strike Back", "Transformation", "Haskell Researchers Announce Discovery of Industry Programmer Who Gives a Shit", and many others besides.

Sure, I sometimes write about other stuff. My in-progress "Programmers View of the Universe" series is motivated by an entirely different bugbear that has nothing at all to do with software politics. My "Universal Design Pattern" article is about a technique that transcends software politics and can be applied with equal effectiveness in either a conservative or a liberal manner. And I've written about video games, Japanese anime and random other stuff.

But I've come to understand that liberalism underlies a tremendous amount of my thinking. Even when I'm writing about management, I see that I am a liberal manager rather than a conservative one. And despite being both relatively old and relatively wealthy, I am also a political liberal -- both socially and fiscally.

Nevertheless I am going to try to represent both sides fairly and accurately in this essay. You know, mostly. I think it's most important for you to buy in to the left/right distinction itself. I think it's far less important whether you happen to agree with my particular side.

I'll consider this essay a success if a sufficient number of you agree that the liberal/conservative distinction is valid for software engineering, and that my particular left/right classification of various technologies and philosophies below seems intuitively reasonable. I'm fine with declaring success if we disagree on a few small details, as long as we agree on the overall picture.

Soooo... static typing enthusiasts are conservative, right?

Why yes. Yes, they are. Static typing is unquestionably one of the key dividing software-political issues of our time. And static typing is a hallmark of the conservative world-view.

In the conservative view, static typing (whether explicit or inferred) is taken on faith as an absolute necessity for modern software engineering. It is not something that one questions. It is a non-issue: a cornerstone of what constitutes the very definition of Acceptable Engineering Practice.

In the liberal's view, static typing is analogous to Security Theater. It exists solely to make people feel safe. People (and airports) have proven time and again that you can be just as statistically secure without it. But some people need it in order to feel "safe enough".

That's a pretty big difference of opinion -- one I'm sure you can relate to, regardless of how you feel about it.

I'm not going to try to defend my view here, since that's what all those old blog posts were for. If I haven't convinced you by now, then there's not much point in continuing to try. I respect your opinion. Well, now. And I hope you now have a little better understanding of mine.

I should, however, mention that there is an unrelated (i.e. politically-neutral) point on which both camps agree: namely, that static types yield better toolchain support. This is undeniably true today, and I have made it my life's work to ensure that it is not true tomorrow.

I have spent the last four years championing an initiative within Google called the "Grok Project", one that will at some point burst beyond our big walled garden and into your world. The project's sole purpose in life is to bring toolchain feature parity to all languages, all clients, all build systems, and all platforms.

(Some technical details follow; feel free to skip to the next section heading...)

My project is accomplishing this lofty and almost insanely ambitious goal through the (A) normative, language-neutral, cross-language definitions of, and (B) subsequent standardization of, several distinct parts of the toolchain: (I) compiler and interpreter Intermediate Representations and metadata, (II) editor-client-to-server protocols, (III) source code indexing, analysis and query languages, and (IV) fine-grained dependency specifications at the level of build systems, source files, and code symbols.

OK, that's not the whole picture. But it's well over half of it.

Grok is not what you would call a "small" project. I will be working on it for quite some time to come. The project has gone through several distinct lifecycle phases in its four years, from "VC funding" to "acceptance" to "cautious enthusiasm" to "OMG all these internal and even external projects now depend critically on us." Our team has recently doubled in size, from six engineers to twelve. Every year -- every quarter -- we gain momentum, and our code index grows richer.

Grok is not a confidential project. But we have not yet talked openly about it, not much, not yet, because we don't want people to get over-excited prematurely. There is a lot of work and a lot of dogfooding left to do before we can start thinking about the process for opening it up.

For purposes of this essay, I'll assert that at some point in the next decade or so, static types will not be a prerequisite for world-class toolchain support.

I think people will still argue heatedly about type systems, and conservatives may never be able to agree amongst themselves as to which type system approach is best for modeling program behavior. But at least I will have helped that discussion be ONLY about representations. The quality of the corresponding developer tools should no longer be a factor in the discussions.

Dividing up the Space

I'm going to go through and toss a bunch of random technologies, patterns, designs and disciplines each into one of six buckets: "apolitical", "conservative", "centrist", "liberal" buckets, plus two buckets that start Centrist and head Left or Right in the presence of overuse. One bucket per thingy. Hey, it's not an exact science. But it should help set the rough foundation for the more detailed use cases below.

Non-political Stuff: Algorithms, data structures, concrete mathematics, complexity analysis, information theory, type theory, computation theory, and so on. Basically all CS theory. These disciplines occasionally inspire tempest-in-a-teapot butthurtedness in academia, but when it happens, it's just similar fish in too small a tank biting on each other. It's to be expected. Overall, these essentially mathematical disciplines are timeless, and they are all equally applicable to both the Liberal and Conservative programming worlds. Yes, even type theory.

Conservative Stuff: Provably sound type systems. Mandatory static type annotations. Nonpublic symbol visibility modifiers (private/protected/friend/etc.). Strict, comprehensive schemas. all-warnings-are-errors. Generics and templates. Avoidance of DSLs (XPath, regexps) in favor of explicit DOM manipulation and hand-rolled state machines. Build dependency restrictions. Forced API deprecation and retirement. No type equivalence (i.e. no automatic conversions) for numeric types. Checked exceptions. Single-pass compilers. Software Transactional Memory. Type-based function overloading. Explicit configuration in preference to convention. Pure-functional data structures. Any kind of programming with the word "Calculus" in it.

Centrist (or flat-out Neutral) Stuff: Unit testing. Documentation. Lambdas. Threads. Actors. Callbacks. Exceptions. Continuations and CPS. Byte-compilation. Just-in-time compilation. Expression-only languages (no statements). Multimethods. Declarative data structures. Literal syntax for data structures. Type dispatch.

Liberal Stuff: Eval. Metaprogramming. Dynamic scoping. all-errors-are-warnings. Reflection and dynamic invocation. RTTI. The C preprocessor. Lisp macros. Domain-specific languages (for the most part). Optional parameters. Extensible syntax. Downcasting. Auto-casting. reinterpret_cast. Automatic stringification. Automatic type conversions across dissimilar types. Nil/null as an overloaded semantic value (empty list, empty string, value-not-present). Debuggers. Bit fields. Implicit conversion operators (e.g. Scala's implicits). Sixty-pass compilers. Whole-namespace imports. Thread-local variables. Value dispatch. Arity-based function overloading. Mixed-type collections. API compatibility modes. Advice and AOP. Convention in preference to explicit configuration.

Centrist Stuff that Becomes Conservative If Taken Far Enough: Type modeling. Relational modeling. Object modeling. Interface modeling. Functional (i.e., side-effect-free) programming.

Centrist Stuff that Becomes Liberal if Taken Far Enough: Dynamic class loading and dynamic code loading. Virtual method dispatch. Buffer-oriented programming.

Woah, that exercise was surprisingly fun! It's far from complete, but hopefully you get the idea.

Some natural themes arise here:

  -- implicit is generally liberal; explicit is generally conservative.

  -- performance-oriented is generally conservative; late-optimized is generally liberal.

  -- compile-time binding is generally conservative; runtime/late binding is generally liberal.

  -- concurrency and parallelism in general seem to be politically charged topics, but the disagreement is orthogonal to the liberal/conservative camps.

I'd love to keep going with the classification. But I'll stop here, since we've got higher-level stuff to discuss.

Examples and Case Studies

I'll walk you through a bunch of examples to show you how just widespread and deep-rooted this political phenomenon is.

Example 1: Languages

Here are some very rough categorizations. Note that within each language camp there are typically liberal and conservative sub-camps. But as a whole, language usage tends to be dominated by what the language makes possible (and easy), so the culture tends to follow the features.

This list is just a few representative examples to give you the flavor. I'm only listing general-purpose languages here, since DSLs and query languages are typically feature-restricted enough to be hard to categorize.

Assembly language: Batshit liberal.

Perl, Ruby, PHP, shell-script: Extremist liberal.

JavaScript, Visual Basic, Lua: Hardcore liberal.

Python, Common Lisp, Smalltalk/Squeak: Liberal.

C, Objective-C, Scheme: Moderate-liberal.

C++, Java, C#, D, Go: Moderate-conservative.

Clojure, Erlang, Pascal: Conservative.

Scala, Ada, OCaml, Eiffel: Hardcore conservative.

Haskell, SML: Extremist conservative.

These are my own categorizations based on my own personal experiences with these languages and their respective communities. Your mileage may vary. However, I'd be quite surprised if you chose to move any of these languages more than a step or two away from where I've positioned it.

One thing that jumps out is that a language doesn't have to be statically-typed or even strongly-typed in order to be conservative overall. More on that in a bit.

The next thing you might notice from the list is that the liberal and moderate languages are all pretty popular, and that popularity declines sharply as languages head into conservative territory.

I think this has a simple explanation: It's possible to write in a liberal language with a conservative accent, but it's very hard (and worse, discouraged) to write in a conservative language with a liberal accent.

For instance, it's straightforward to write JavaScript code in a way that eschews reflection, eval, most automatic type casting, prototype inheritance, and other dynamic features. You can write JavaScript that plods along as unadventurously as, say, Pascal. It doesn't have all the static type annotations, but you can replace them with assertions and unit tests and stereotypically stolid code organization.

But if you try writing your Haskell code with a bunch of dynamic features, well, you're in for a LOT of work. Haskell enthusiasts have managed to implement dynamic code loading and a ton of other ostensibly dynamic features, but it was only through herculean effort.

What's more, if you write your liberal-language code in a conservative way, people will just look at it and say: "Well, it's kinda boring, and you could have saved a lot of coding by using some dynamic features. But I guess it gets the job done. LGTM."

Whereas if you write your conservative-language code in a liberal way, you run the risk of being ostracized by your local language community, because... why are you doing all that dangerous dynamic stuff in the first place? I'll explore this cultural phenomenon further when I talk about Clojure below.

The last big, interesting observation from the list is that a lot of the most popular languages out there are only moderately conservative -- even if they think of themselves as quite conservative compared to their ultra-dynamic cousins.

I've said it before, and it bears repeating here: the reason C++, C# and Java have been particularly successful in the marketplace is that -- just like effective politicians -- they know how to play both sides.

C++ allows liberal-biased programmers to program in straight C, and it allows conservative-biased programmers to layer in arbitrary amounts of static type modeling, depending on how much work they want to expend in order to feel secure. Java? Pretty much the same story.

Playing to both the fast-and-loose and lock-your-doors mindsets has proven to be a key ingredient to market success. Also marketing, but it helps a LOT to be viewed as philosophically friendly by both the liberal and conservative camps.

There is a new crop of languages on the horizon (for instance, Google's Dart language, but also new specs for EcmaScript) that are deliberately courting the centrist crowd -- and also delicately playing to grab both the liberals and conservatives -- by offering optional static types. In principle this is a sound idea. In practice I think it will come down to whether the marketing is any good. Which it probably won't be.

Language designers always seem to underestimate the importance of marketing!

Example 2: Tech corporations

Just for fun, let's contrast four similar-ish tech companies in their software-political outlook.

1) Facebook -- Diagnosis: Extremist Liberal. Despite their scale, they are still acting like a startup, and so far they've been getting away with it. They use primarily C++ and PHP, and they're prone to bragging about how their code calls back and forth from PHP to C++ and back into PHP, presumably bottoming out somewhere. Their datastore is memcached: just name-value pairs. No schema. They dump the data and logs into a backend Hive store and run Hadoop mapreduces for offline data analysis. They still hold all-night hackathons every other week or so, which will remain feasible for them as long as the majority of their programmers are very young males (as was the case last time I toured there) and their stock continues to promise great riches (as was not so much the case last I checked.) As a company they are tightly knit and strongly biased for action, placing a high value on the ability of individual programmers to launch features to their website with little to no bureaucracy or overhead. This is pretty remarkable for a company as big as they are, with as many users as they have. Conservatives no doubt regard them with something between horror and contempt. But Facebook is proving that programmers of any world-view can get a hell of a lot accomplished when they gang up on a problem.

2) Amazon.com -- Diagnosis: Liberal. Which is surprising, given how long they've been in business, how much money is at stake, how mature their Operations division is, and how financially conservative they are. But "Liberal" is actually quite a retreat compared to their early days. Back in 1998-1999 they were almost exactly like Facebook is today, with the sole exception that they put everything in relational databases and did a ton of up-front relational data modeling. Well, except in Customer Service Apps, where we used a name/value store just to be flexible enough to keep up with the mad chaotic scramble of the business launches. All part of my multi-decade indoctrination as a Liberal. In any case, despite many corporate improvements with respect to work-life balance (which happened after several stock plunges and years of significant double-digit turnover in engineering), Amazon has retained its liberal, startup-like engineering core values. Every team owns their own data and makes their own decisions, more or less like independent business units. Amazon still launches and executes faster than just about anyone else out there, because they're still willing to take real risks (incurring occasional huge outages), and to make hard decisions in favor of launching early and often. Above all else, Amazon has proven conclusively that after fifteen years, they can still innovate like nobody else. They've still got it.

3) Google -- Diagnosis: Conservative. They began life as slightly liberal and have grown more conservative ever since. Google was only software-liberal in the very very early days, back when the search engine itself was written in Python. As they grew, they quickly acquired a software conservatism driven entirely by the engineers themselves. Manifestos were written about the dangers of using multiple languages, and strict style guides were put in place to severely limit "risky" or "hard to read" language features of the few languages they did allow. Google's JavaScript code is written in an extremely conservative style with extensive static type annotations, and eval is forbidden. The Python style guide forbids metaprogramming and other dynamic features, which makes their Python look a lot like untyped Java. And they have severely limited the use of many C++ language features, with C++11 support rolling out literally one feature every few weeks. (There are over five hundred new features in C++11.) In internal surveys, Google engineers commonly cite bureaucracy, churn and complexity as core obstacles to feature advancement and rapid launches. Google has made serious attempts on several occasions to reduce this bureacracy, but they always get pushback from -- surprise -- the engineers themselves, who have grown so staunchly conservative that they actively (and even more often, passively) resist the introduction of more flexible stacks and technologies. Most of the major technological shifts within Google over the past half-decade have been overtly conservative. For a liberal like me, it has been a very sad process to observe. But at least I've found myself a niche that's widely regarded (by both camps) as valuable, and within my own org we can still be pretty liberal and get away with it.

4) Microsoft -- Diagnosis: Batshit Conservative. Microsoft has two geese that lay golden eggs: Office and Windows. Microsoft has been reduced to a commercial farmer protecting the geese from all incursions. The golden eggs still have value, because customers are locked into the platform by the cost-ineffectiveness of retraining their fleets. But Microsoft can no longer innovate in Office or Windows precisely because of those corporate fleet retraining costs. Their OEMs are stretched as thin as they can go. Apple is dominating the handheld markets, and Microsoft is actively stifling their own innovation in Windows Phone because they're afraid it will cannibalize their core Windows business. Microsoft has not had a successful product-level innovation in fifteen, maybe twenty years. All of their successful products have been copies of competitors' products: IE, XBox, C#, .NET, Bing, Windows Phone, and so on ad infinitum. All great implementations of someone else's ideas. Microsoft's playbook is to embrace, extend, and leverage their brand to crush the competition -- or at least it was, until the goverment put an end to that circa 2002. Now the company genuinely doesn't know what the fuck to do with themselves, and what's more, instead of Bill Gates they now have a lunatic in charge. Employees are leaving in droves, all citing the same internal "existential crisis" and unbearable corporate politics caused by competing business units actively sabotaging one another. Microsoft has turned into a caricature of right-wing corporatism: sitting on their front porch with a shotgun cursing at passers-by, waiting for their government bribes to give them another few years of subsidies and shelters while they wait to die. I've personally chatted with close to four hundred current and ex-Microsoft employees over the past seven years. Oh, the stories I could tell you... someday, maybe.

5) Bonus company: Apple. Diagnosis: no idea, but they're so good at marketing that it's almost irrelevant. Would love to have more insight into their internal software culture, though. Any takers? Throwaway accounts? AMA?

OK, that was a fun exercise too. But we need to move on! Almost done now.

Specific Case Study: The Clojure Language

I've been meaning to follow up on Clojure for a while now. Over a year, at least. But until recently I didn't have the conceptual tools to explain what I wanted to say about it.

Now I do!

Clojure is a new-ish Lisp dialect that runs on the JVM and .NET, and I was honored to write the Foreward to "The Joy of Clojure" a while back. For a few years I had been really excited to start learning Clojure, and my initial experiences with it were quite positive.

However, I eventually learned that the Clojure community is extremely conservative. That is is pretty unusual for a Lisp dialect. Lisp is widely regarded as one of the most liberal language families in existence. And Clojure has the superficial appearance of being a laissez-faire kind of language. It is quite expressive, including a -- ahem -- liberal dose of new syntax. And it eschews static type annotations and strong type modeling in favor of a small set of highly regular, composable data types and operations -- not unlike, say, Scheme or Python.

But the resemblance to a liberal language ends there. Clojure's community came pre-populated with highly conservative programmers from the pure-functional world: basically Haskell/ML types (lots of puns today!) who happen to recognize the benefits of Lisp's tree syntax. So under its expressive covers, everything about Clojure is strongly conservative, with a core overriding bias towards protecting programmers from mistakes.

And the community follows suit. At a Clojure conference last year (or was it two years ago? time flies so fast these days...), there was a key presenter doing a talk on how Macros were basically harmful and should be avoided in modern Clojure code.

I trust that if you know anything about Lisp, your blood is basically boiling at this point. I know mine was.

But his argument is perfectly valid from the classic software-conservative's viewpoint. Macros allow you to invent domain-specific language abstractions. Those require documentation in order for users to figure out what they do, and what they mean. That means you can know Clojure and not really know enough to read someone's Clojure code without some documentation handy. Which is sort of the definition of a newbie. And there you have it. In a very real sense, conservatives fear being turned -- in the blink of an eye -- from masters into newbies by the application of macros.

It's sort of scary if you have a lot of your personal identity invested in knowing some shit. And wouldn't you know it, real-world politics conservatives are shown in study after study to be "staunch" in sticking to their world views rather than compromising. That means they have a lot of identity tied up in those views.

So while I liked a lot of what I saw in Clojure, as a hardcore software liberal I was inevitably and inexorably driven away from the language. And that's good for me, and it's good for Clojure. I mean, why should they compromise?

I think that my conceptual framework gives us an "out" -- a way to avoid being emotional about these subjects. Casting the problem as a clash between Liberalism and Conservsatism gives us the ultimate ticket for "agreeing to disagree".

Hopefully it will also help language designers and communities do a better job of targeted marketing. Right now just about every language out there makes a claim along the lines of "This language is the best choice for everybody!" But now we know that is very unlikely to be true -- or if it is, we can at least be assured that they're centrists, and they run the risk of being equally distasteful to everybody.

In the conservative/liberal framework, language designers can make more accurate, less bait-and-switchy claims; for instance: "Haskell is the best choice for every radical extremist conservative programmer!"

Well, we can work on the wording. But you get the idea.

Wrap-Up

I was thinking of going through a bunch more examples and stuff, but I see that I'm on my third (Editor's Note: fourth) glass of wine, which means my typing is about to give out any minute.

So let's wrap it up!

There's one kinda key point I wanted to get across, but didn't see a good place for it. That point is this: please do not be alarmed that I am calling you a (software) Conservative.

I worry that politically left-leaning programmers will hear the term "conservative" and will immediately associate it with all of the... uh, politically-charged connotations associated with far right-wing conservatism in the United States political arena today. You know, racism, sexism, religious fundamentalism, homophobia, warmongering, bear-shooting, that kind of thing.

I'm not saying they're bad, at least not in this essay. I'm just saying nobody in their right mind wants to be associated even remotely with those embarrassing wingnuts. See what fine-grained, nuanced distinctions three (Editor's Note: four) glasses of wine can produce? But I'm not saying their views are bad. No. Not here. I'm just observing that they're heavily politically charged viewpoints which have, for better or worse, recently come to be associated with the term "conservatism" in US politics.

So please do me a favor and try to dissociate those specific agendas and real-world political viewpoints from the generic term "Conservative", which here really just means "risk averse".

It's perfectly OK, and normal, to be a programming conservative. You don't have to shoot any bears. I would actually like to see the terms "liberal" and "conservative" to become badges of honor in the programming world. People should stand behind their beliefs. I mean, we do already, I think, so it shouldn't be much of a stretch to allow our beliefs to be given convenient labels.

Ah, me. I can see the Euphemism Treadmill rearing its ugly head already. We'll see.

Anyway, tell me what you think! I welcome any and all viewpoints and comments. Even from bears!

Special thanks to Writer's Block Syrah for reviewing this post for career suicide.

(Special Note to my fellow Googlers: Yes, I meant to post this externally. BOTH times. No, I am not the Mouth of Sauron.)

Re:Entire Article (1)

Anonymous Coward | about a year and a half ago | (#40945671)

Guy who posts to G+ is a Google employee. Shocked.

We need to politicize software development (5, Insightful)

cvtan (752695) | about a year and a half ago | (#40945161)

Because, you know, there are like only two ways to code: Liberal and Conservative. There certainly can't be a THIRD way like Funny or Informative or Surprise and Fear. Damn! Or Ruthless Efficiency!

Re:We need to politicize software development (0)

Anonymous Coward | about a year and a half ago | (#40945307)

There certainly can't be a THIRD way like Funny

I write all my apps in LOLCODE, you insensitive clod!

Re:We need to politicize software development (1)

Trepidity (597) | about a year and a half ago | (#40945309)

Or Ruthless Efficiency!

Neoliberal software development?

Re:We need to politicize software development (4, Funny)

tnk1 (899206) | about a year and a half ago | (#40945359)

Because, you know, there are like only two ways to code: Liberal and Conservative. There certainly can't be a THIRD way like Funny or Informative or Surprise and Fear. Damn! Or Ruthless Efficiency!

I'm definitely a Surprise programmer. I'm surprised when it works.

Re:We need to politicize software development (-1)

Anonymous Coward | about a year and a half ago | (#40946017)

Then there's libertarian coding, where you insist that everyone write their own libraries.

just come out and say it (3, Funny)

slashmydots (2189826) | about a year and a half ago | (#40945179)

What he really means is, when it gets done, 1 group wants to give it out for free and the other wants to charge lots of money and DRM it lol.

Re:just come out and say it (5, Interesting)

Impy the Impiuos Imp (442658) | about a year and a half ago | (#40945545)

I started in AI, moved on to desktop apps, and have neen doing deeply embedded automotive stuff for 10 years now.

I assure you, when a bug changes from, "Oh, post an update on the web site" to a $100 million, government-ordered recall, your priority changes quickly.

I would recomment a 3 year stint in embedded for app programmers. You'll be shocked how sloppy you are, and, more importantly, how needlessly sloppy. Many techniques can be incorporated without slowing down the freewheeling development much at all.

Kudos to the fellow embedded dev. (1)

The Altruist (1448701) | about a year and a half ago | (#40945823)

I would recomment a 3 year stint in embedded for app programmers. You'll be shocked how sloppy you are, and, more importantly, how needlessly sloppy. Many techniques can be incorporated without slowing down the freewheeling development much at all.

Somebody mod that guy up.

Re:just come out and say it (4, Insightful)

jeremyp (130771) | about a year and a half ago | (#40945713)

No, he doesn't. He uses "conservative" in the sense of risk averse and "liberal" in the sense of not conservative. He then defines a number of traits which help define whether you are a programming liberal or conservative. For instance, if you like strong and/or static typing (he conflates the two), you are conservative. If you like dynamic/weak typing, you are liberal.

There are several other traits by which you can measure your conservatism/liberalism in programming terms. That exposes the flaw in the paradigm: just like in politics most people are not across the board conservative or across the board liberal. I, for example, would be labelled liberal in terms of the typing issue but conservative is respect of several of his other points - like database normalisation.

Another problem I have with his idea is his choice of terms. For many people, me included, the political label "conservative" has strong associations with US far right politicians, who, from my perspective in the UK, are all mad as a box of frogs. He spends a lot of time at the end of the article arguing that being software conservative is not bad in the way that the political equivalent is bad, but I think he would have done better to have chosen less pejorative terminology.

Re:just come out and say it (2)

mooingyak (720677) | about a year and a half ago | (#40945913)

You made it farther into the article than I could.

For instance, if you like strong and/or static typing (he conflates the two), you are conservative. If you like dynamic/weak typing, you are liberal.

His definitions seem arbitrary. I'm not sure I understand what static typing has to do with being risk averse.

It comes down to purpose, not conservatism. (5, Insightful)

gestalt_n_pepper (991155) | about a year and a half ago | (#40945183)

If you're getting paid for your software, there's one set of priorities. If you're doing it for your own satisfaction, there's quite another. Not understanding or being able to separate business from the actual activity of writing software seems to be the problem.

I see this on a daily basis where I work. Younger software developers seem to think that "cool" and "new" is a good reason to do things - which it is, as long as it doesn't get in the way of making money. When there's a client involved and significant money, "cool" and "new" are only good if they actually help sell and maintain the software. The client doesn't care about frameworks, or ruby, or agile or lambda expressions. They care about cost, reliability and usability. Change for its own sake, or to gratify only the programmer is frequently a problem.

You Guys Care About Maintenance? (1)

Greyfox (87712) | about a year and a half ago | (#40945341)

That's actually pretty progressive. On most projects, developers are atrocious at estimating the time it will take to do anything. Since this is the case, they are also atrocious at estimating how much redesigning a module to improve its maintainability will save the company. Since that's an unknown value, most managers that I've met simply choose to ignore it. In those cases, the cost of maintenance is also usually ignored and is also pretty high. I'd guess a software project that I was helping to maintain a few jobs back was probably costing the company upward of $1 million a year. That was a tiny drop in the bucket of their overall annual income, but it was also one tiny project in a vast tapestry of their product lines. Add a million here and a million there and pretty soon you're talking about real money!

Though to put it in perspective, I think $1 million was also what their CEO paid for a round of golf and some sushi afterwards.

Re:It comes down to purpose, not conservatism. (1)

bondsbw (888959) | about a year and a half ago | (#40945417)

I mostly agree with you, but refusal to do anything different--simply because the money doesn't require it--can lead your team into obsolescence.

I like living on the cutting edge because tomorrow, some of that will be the standard and what I'm doing today will be the mainframe.

Re:It comes down to purpose, not conservatism. (1)

Intellectual Elitist (706889) | about a year and a half ago | (#40945637)

When there's a client involved and significant money, "cool" and "new" are only good if they actually help sell and maintain the software. The client doesn't care about [...] lambda expressions.

Lambda expressions are in fact cool, but anyone who thinks they're new must have been in a coma since the 1930s.

I'm not gonna click on his blog (-1)

Anonymous Coward | about a year and a half ago | (#40945201)

I see his picture under "self-importance" in the dictionary...

OK, I get it (-1)

Anonymous Coward | about a year and a half ago | (#40945217)

I think I understand what he is saying. It is Freetards (or Fossies) vs COTSTards (or Cotsies).

Assembly language: Batshit liberal? (2)

dtmos (447842) | about a year and a half ago | (#40945231)

I would have gone the other way with this one. The AL programmers I know like it precisely because they have more control of the machine (e.g., they can name specific registers and memory locations for storage) than if they were using a higher-level language, where they would be at the mercy of the compiler, and its unknown decisions. If "we regard political conservatism as an ideological belief system that is significantly (but not completely) related to motivational concerns having to do with the psychological management of uncertainty and fear," then these guys manage their uncertainty and fear of the compiler by doing everything themselves, and therefore fit the definition of conservative. Yes, they're typically older; I haven't met Mel [catb.org] , but he's of this type -- although because he' uses machine language, he's perhaps even more extreme. One wouldn't call him liberal, correct?

I suppose it's possible that the spectrum line is actually more of a circle, and batshit liberal and batshit conservative are either the same, or next-door neighbors.

Re:Assembly language: Batshit liberal? (1)

mooingyak (720677) | about a year and a half ago | (#40945949)

I suppose it's possible that the spectrum line is actually more of a circle, and batshit liberal and batshit conservative are either the same, or next-door neighbors.

That would make his analogy more apt rather than less IMHO, since it can be difficult to tell apart batshit extremists from each side in real world politics too.

Limited view... (3, Informative)

Anonymous Coward | about a year and a half ago | (#40945241)

WTF... Dear America: the rest of the world doesn't divide their "world views" between left and right. Stop trying to shoe horn such a limited value system into other domains.

Software development might have it's own set of views internally, but trying to associate one with liberalism and the other with conservatism is asinine. The context of everything would just muddle things up and the nuances would get lost. Does Yegge even have the social sciences background to even approach making this argument? Or is he just another programmer spouting off on his blog?

Re:Limited view... (0, Flamebait)

1s44c (552956) | about a year and a half ago | (#40945321)

WTF... Dear America: the rest of the world doesn't divide their "world views" between left and right.

To be fair nor does America. They divide their world views into right and far right.

Re:Limited view... (4, Insightful)

Quiet_Desperation (858215) | about a year and a half ago | (#40945423)

Dear anonymous entity, stop projecting the opinions of one blogger onto a diverse population of over 300 million.

01 to the left or 10 to the right? (0)

Anonymous Coward | about a year and a half ago | (#40945249)

Moron, software engineers have political (programing) opinions, software is either bad (bloat) or good (useful).
On the other side I am quite sure that msoffice makes my life living hell because of my political opinion :P

Cat Tongue Denying Text Here. (1)

VendettaMF (629699) | about a year and a half ago | (#40945301)

So, the main message from the article (Despite the "Author"'s efforts to slant it othewise) is that bad design and programming practises should be called "liberal" as opposed to simply ignorant?

Re:Cat Tongue Denying Text Here. (0)

Anonymous Coward | about a year and a half ago | (#40945387)

Do you think all programs require similar adherence to those design and programming practices?

Automated Rover Landing Code
Realtime financial transactions
pacemaker firmware
wootoff monitor

Politics isn't that bad (0)

Anonymous Coward | about a year and a half ago | (#40945311)

"Any particular issue only makes it onto the political axis if there is a fundamental, irreconcilable difference of opinion about it. "

No, Politics is mostly if a particular set of tradeoffs is worthwhile, most things sit in the grey areas.

This false believe that there are fundamental irreconcilable differences pushes a BS hyperpartisan attitude where nothing can get done.

In the real world, things simply come down to where people draw their line on a particular issue

Risk management? (0)

Hatta (162192) | about a year and a half ago | (#40945335)

Conservatism, at its heart, is really about risk management.

Yeah, they sure managed the hell out of the risks of invading Iraq and completely unregulated credit default swaps. Conservativism is not about risk management, but fear management. Keep people afraid of something else and they'll let you rob them blind.

Re:Risk management? (1)

Curunir_wolf (588405) | about a year and a half ago | (#40946029)

Conservatism, at its heart, is really about risk management.

Yeah, they sure managed the hell out of the risks of invading Iraq and completely unregulated credit default swaps. Conservativism is not about risk management, but fear management. Keep people afraid of something else and they'll let you rob them blind.

I don't think either of those ideas had anything really to do with "Conservatism", at least not the Goldwater / Reagan / Jeffersonian tradition of it. "Unregulated" financial transactions are, sure, but not in a system with a Federal Reserve holding a monopoly on the financial instruments, and the Federal government willing to bail out the failures instead of letting the market tear them into pieces and distribute the pickings on its own. Unfortunately for those of us on the "outside" of the ruling elites, both of those decisions (Iraq and the bailouts) were heavily supported by both political parties. Even Hillary Clinton voted to support the Iraq invasion.

Well duh (0)

Enry (630) | about a year and a half ago | (#40945347)

I'm not bothering to read the obvious slashvertisement. But that's not to say the author doesn't have a point.

This isn't comparing politics, it's about ideology. And purpose.

Writing code for hospitals (as I did in the past), or NASA, or nuclear reactors requires you by very conservative in your writing. I'm a very liberal guy, but I can clearly understand the need to make incremental changes for critical infrastructure. Coding isn't my thing, so I left that and became a system administrator. I'm now at an institution that is practically synonymous with Liberal and there's a wide mix of 'conservative' and 'liberal' approaches to coding and IT in general here We have ad-hoc storage devices sitting under someones desk that serves a department and there's also an enterprise-grade storage solution that's a few PB in size. Both have their place, and both can and do co-exist in the same environment.

I'd argue that these methodologies co-exist better than their political counterparts. Decisions can be made on basis of fact and need rather than just gut or making the 'other side' look bad. Be it the Oracle server or the MySQL server or whatever new NoSQL implementation is out there, nobody wants to see them fall over dead.

I'm rambling and I didn't get much sleep last night, so I'm just going to stop there.

This is sooooo useful. (0)

Old97 (1341297) | about a year and a half ago | (#40945381)

I'll use this when hiring so I can get a team that shares my values. Interview questions: Are you a Republican? Yes? Take a hike. Are you a Democrat? Yes? Take a hike. Are you an Independent? Yes? Obviously you can't make decisions, take a hike! Are you an anarchist or libertarian? Yes? I don't need folks with authority issues. Take a hike? Are you a Communist or Fascist? Yes? Let's do lunch. I want to see if you bend to my will. Socialist? If you are hot and female, let's talk. No I'm not hiring you because you'll want awards for showing up. OK, who is left? No one? Damn, you just can't find qualified people any more.

What is this I don't even (0)

Quiet_Desperation (858215) | about a year and a half ago | (#40945393)

I've spent the past eight years (starting back in June 2004) writing elaborate rants about a bunch of vaguely related software engineering issues.

And what did that accomplish?

In today's essay I'm going to present you with a new conceptual framework for thinking about software engineering. This set of ideas I present will be completely obvious to you. You will probably slap yourself for not having thought of it yourself. Or you might slap the person next to you. In fact you probably have thought of it yourself, because it is so blindingly obvious.

But in my thirty-odd years as a programmer I'm pretty sure this way of thinking about things, if it already existed, has never been mainstream. That assertion is backed by what has to be at least ten Google searches that turned up nothing. So I'm pretty confident.

I'm going to make it mainstream, right now. Watch!

And I suspect this conceptual framework I'm giving you will immediately become, and forever remain, one of the most important tools in your toolkit for talking with -- and about -- other programmers.

-_-

The punch line, a.k.a. TL;DR

Way too late for that.

I know exactly what's been bothering me.

Your narcissistic personality disorder?

Incorrect analysis (1)

jgotts (2785) | about a year and a half ago | (#40945421)

I feel that this is an incorrect analysis. Depending upon the problem to be solved, all programmers will adapt the appropriate style.

When life is on the line, all programmers are conservative. When money is on the line, cautious. When writing a one-off script to test a programming technique, liberal. Even management, who tend to push programmers to be less cautious, adjust their demands for the situation.

Open Source Hippies (0)

Anonymous Coward | about a year and a half ago | (#40945441)

Time to shake off the liberal drivel and MS bashing your college profs indoctrinated you with.

The guy has a point (3, Interesting)

SmallFurryCreature (593017) | about a year and a half ago | (#40945445)

As a web developer, I am a liberal and find myself at odds with conservatives who often just can't see simple business needs. Conservatism is good for heart monitors but for building the next facebook? But the Conservative amongst you will argue, don't you think that a billion dollar, millions of visitors, holding fast amounts of private data site NEEDS to be extremely secure?

And it shows much you don't get it if you think that. I said the NEXT facebook, which will start out as a small site with a shoestring budget and bankruptcy just a bill away. Then you need to deliver a product BEFORE yesterday and all the fancy stuff can come later when you are rich and can afford to hire the terminally slow.

I have talked with webshop clients who wanted triple redundancy and failover to carry max expect load... YOU HAVEN'T SHIPPED A SINGLE ORDER YET! And PAY MY BILLS FIRST! Part of the reason the tech bubble burst was all these old developers insisting on enterprise grade hardware with oracle licenses coming out of your ears, meaning that even if they would have ever been able to release a product, the operating costs would have been so high, the break even point would have been somewhere after the heat death of the universe.

The big ones that did survive made it on cheap hardware with buggy, hastily written code that was good enough to make it to the next month.

One old school guy I worked with wanted a detailed plan for general debugging when there was a crisis... because he first wanted to fully analyse the problem before bringing the server down if it started coughing up bad orders because that is what you do in a factory, your don't shutdown an entire factory just because a few widgets come out wrong...

The moron never managed to understand that you DO shut the entire factory down if the cost of 1 defective widget is equal to profit of an entire days output of that factory.

For web shops, margins are tiny and customer service is very expensive. It is BETTER to be down for an entire day, then have to spend a week dealing with complaints because of messed up orders. 1 day no-profit == 1 day of low costs (highest cost are sending and goods, both of which are non existent if you don't ship anything) while shipping orders wrong so they have to shipped again gets VERY expensive REALLY fast.

So, you shut things down and dive right in and fix it, just good enough to get up and running again.

But doesn't that prove you should write bug free code? Only if a website has infinite resources for its startup. Most don't. If you got 10 grand to start a website, you need 5k for supplies, 3k for shipping and that leaves 2k for code. When that money is gone, the webshop either needs to have earnings coming in or it is down the tube.

It is different if there is a large established company and you can pull a MS and just throw good money after bad. But 99% of web development ain't like that.

Mind you, I wouldn't like to fly a plane I had written the software for.

Re:The guy has a point (0)

Anonymous Coward | about a year and a half ago | (#40945725)

tl;dr but I think I got what you were trying to say. You don't want to be mistaken for conservative do you?

(Lest I contribute nothing to the discussion... Both ends of the spectrum tend towards generating problems. As is often the case, moderation is the best course. Specifically for the purposes of this topic, neither too fast and loose nor too slow and methodical.)

Re:The guy has a point (0)

Anonymous Coward | about a year and a half ago | (#40945755)

People like you are why businesses have embarrassing and expensive major security breaches.

Re:The guy has a point (1)

serviscope_minor (664417) | about a year and a half ago | (#40945827)

YHBT.

It just goes to show how stupid the article is.

Apparently I'm a conservative according to most of his definitions, since I like static checking. Actually, many of the points he makes (static typing, relational schemas) are about static checking.

I, personally like static types, because in my mental model of computing, computing is all about maniuplating data. If you don't know what the data is, then how do you maniuplate it?

I find it's generally quicker not to write bugs than to find them after.

Apparently that's what he means by conservative.

What you're describing is people with a inability to weight risks and rewards, couple with chronic risk aversity. I don't know if that's conservative or just plain dumb.

Ugh! Gag me with a coke spoon! (-1)

Anonymous Coward | about a year and a half ago | (#40945451)

Lame story, big advertisement, requires log-in... Poor old Slashdot... becoming such a spam site I remember FM radio going through a similar degradation in the middle 70s.

Try it, it works well when you can do it. (1)

Impy the Impiuos Imp (442658) | about a year and a half ago | (#40945453)

Here'a my programming politick: Several programmers of both types hamhand things and cannot find their bug for hours to 2 days...

Me: "Move!"

10 minutes to 1/2 hour later: "Here."

Where I stopped reading (4, Interesting)

sideslash (1865434) | about a year and a half ago | (#40945491)

"We regard political conservatism as an ideological belief system that is significantly (but not completely) related to motivational concerns having to do with the psychological management of uncertainty and fear."

Thanks, dude. Being a conservative myself, I suppose one example of that distinction is that I think there should be more guns in the general population, because having the good people in our country be a little dangerous seems like a healthy thing to me. The reaction of liberals whenever I bring that up truly evidences a position of bold, experimental confidence and legislative permissiveness. Can't detect an attitude of fear at all in their response. /sarcasm

That and the green eggs and ham thing. Has this guy not read the world's great literature?

Re:Where I stopped reading (0)

Anonymous Coward | about a year and a half ago | (#40945729)

That and the green eggs and ham thing. Has this guy not read the world's great literature?

He read the wikipedia article on it. Ok, glanced at it. Well, he really just saw the title show up when he was searching for something significantly more NSFW, but what matters is that he rememberred the order of terms.

Steve Yegge, the Rush Limbaugh of software dev (1)

MatthiasF (1853064) | about a year and a half ago | (#40945609)

I read the entire, lengthy pile of bullshit presented and I can boil it down for you.

The guy has a list of things he doesn't like and then associates it with a political faction he doesn't like, so he can embarrass the people who do the things he doesn't like by associating them with the political faction they most likely do not want to be affiliated.

It's a Rush Limbaugh tactic used to polarize a topic and try to force people to behave like you want them to behave.

In other news.... (1)

Jerslan (1088525) | about a year and a half ago | (#40945683)

Expert Scientists announce that the sky is blue, and not, in fact, green as was previously believed by nobody at all.

Terrible Google Plus post. (1)

Bill, Shooter of Bul (629286) | about a year and a half ago | (#40945687)

I disagree with everything in the article. His definitions, the entire premise, his dislike for green eggs and ham as a culinary masterpiece. He's not even wrong.

Someone got out their "Jump to Conclusions" mat? (1)

Brewster Jennings (2642639) | about a year and a half ago | (#40945741)

This is exactly the kind of reasoning that makes me want to verbally tear someone a new backdoor for their production system, if you know what I mean.

A dev's approach to writing code isn't a binary state; neither is political ideology, for that matter.

This is a classic case of someone coming up with the "answer", and then attempting to find a way to logically justify it. But hey, since this is "Snap judgement and reason later" Friday, I'm going to automatically assume that Yegge is one of the geniuses behind the push to put everything on the cloud, despite the fact that more than a few long-term prediction models show user data volumes rising geometrically and overtaking infrastructure increases, or the inherent privacy and identity risks associated with waving's one's digital cheese out in the electronic wind.

Let's put this logical tar pit to bed before someone has to ponder if LISP programmers, being "liberal", would support gay marriage.

what do they mean? (1)

CosaNostra Pizza Inc (1299163) | about a year and a half ago | (#40945759)

I haven't read the article, as I often only have time to glance through these. Are they referring, as an example, to proponents of the waterfall process vs. Agile?

Re:what do they mean? (0)

Anonymous Coward | about a year and a half ago | (#40945865)

Woah, you don't know how it works here. You're supposed to not read the article and then rant about how the article's writer and subject are idiots as if you had read it.

I did read the article, and half the complaining comments here clearly didn't. Most of the others got offended because he used the same terms used in our current political arguments.

Just routine software architecture (0)

Anonymous Coward | about a year and a half ago | (#40945825)

TFA looks to me like the author has just realised that there is a tension between competing quality requirements.

There are over 100 different quality attributes that one might consider when planning a large project. To think that they are all lined up on a single axis is somewhat absurd. The reality is that the problem has a rather large number of dimensions, and finding the optimum solution in that problem space is hard. This is what software architects do.

Pigeon-holed Thought (0)

Anonymous Coward | about a year and a half ago | (#40945873)

Wow, what is it with the need to pigeon-hole all thought into 2 categories? Not everything is Liberal or Conservative! Those are incredibly crude, essentially worthless labels.

In reality, there are infinite numbers of ways of thinking about things and ways to implement that idea, whether that is a political idea or a software feature. There are best practices defined for some of these, and lots of other areas where intelligent consideration is required to attempt to understand the ramifications of something. One then balances risks vs costs/efforts, potential benefits, etc.

As far as politics go: because the US only has 2 political parties, they are aligned with the only two alternatives and you have a vigorous debate going on about two very subtly different parties that represent the corporations and elite. Meanwhile, many alternative ideas are just ignored. Picture a giant circle, representing all political philosophy and consideration. Then draw 2 tiny, almost completely overlapping circles inside it. Label them "Liberal" and "Conservative", and that gives you a pretty good idea what I'm talking about.

This isn't an accident either, because the last thing the oligopoly wants you to do is realize there are other ways of doing things. The entrenched system works pretty darn good for them. Not so well for the rest of us though.

What about the Evil Commie Open Source folks? (1)

fantomas (94850) | about a year and a half ago | (#40945929)

"Everyone in the software industry who does stuff related to programming computers falls somewhere fairly precise on this political spectrum,"

Conservative to Liberal in US political terms. Hmm, USA!=World. Fail.

Quite apart from the fact that some folk who do stuff relating to programming computers are clearly out and out anarchists if we're to judge on the evidence and I am sure you'd all agree the Open Source people are definitely Evil Commies :-)

Because everything is about politics (0)

Anonymous Coward | about a year and a half ago | (#40945951)

Especially things that aren't.

Load More Comments
Slashdot Account

Need an Account?

Forgot your password?

Don't worry, we never post anything without your permission.

Submission Text Formatting Tips

We support a small subset of HTML, namely these tags:

  • b
  • i
  • p
  • br
  • a
  • ol
  • ul
  • li
  • dl
  • dt
  • dd
  • em
  • strong
  • tt
  • blockquote
  • div
  • quote
  • ecode

"ecode" can be used for code snippets, for example:

<ecode>    while(1) { do_something(); } </ecode>
Sign up for Slashdot Newsletters
Create a Slashdot Account

Loading...