
Steve Yegge: Notes from the Mystery Machine Bus - kungfudoi
https://plus.google.com/u/0/110981030061712822816/posts/KaSKeg4vQtz
======
cletus
As much as some commenters are (weirdly?) railing against this classification
scheme I think the underlying idea that software conservatism is about risk
aversion is essentially accurate.

Perhaps another way of framing this is to ask the question: are you optimizing
for the best case or the worst case? This ultimately is a form of risk
management. And I'm not talking in the algorithmic sense, meaning complexity
expressed as the asymptotically worst case. I'm talking about people, software
and ecosystems.

Let me illustrate this idea with Java.

\- C++ has operator overloads. Java does not? Why? Because people might abuse
them. That's optimizing for the worst case (ie bad or inexperienced
programmers). Properly used, operator overloading can lead to extremely
readable code;

\- Java has checked exceptions and uses them liberally (pun intended). C#, as
one example, only has unchecked exceptions. Why? Philosophically the Java
language designers (and many of its users) feel that this forces callers to
deal with exceptions. Pragmatically (IMHO) it does not and leads to more cases
of exceptions being simply swallowed. But again this is optimizing for the
worst case ie programmers who should deal with a particular error condition
but won't;

\- Java has no multiple inheritance. Same story: it can be abused ("it is
known"). But also mixins can be a powerful metaphor.

\- Rinse and repeat for duck typing, extension methods, etc.

Putting Python two steps from Ruby strikes me as an interesting choice. I'd
say the difference is at most one.

I'll also agree that Google as a company (based on my own _much_ more limited
experience than Yegge's) is firmly conservative. The style of writing
Javascript that he refers to is about writing Google Closure code with all
sorts of directives to aid the Closure Compiler (I describe Closure as putting
the Java back into Javascript).

I also see a lot of Python code that isn't really Python. It's Java expressed
in Python syntax rather than idiomatic Python and that is kind of sad.

Which isn't to say that any of this is necessarily bad (or good). It's just a
(software) political viewpoint you need to be comfortable with (or at least
can tolerate) or (to quote the South Park meme) "You're gonna have a bad
time".

One of the comments linked _Worse is Better_ [1], which is worth a read too.

[1]: [http://www.stanford.edu/class/cs240/readings/worse-is-
better...](http://www.stanford.edu/class/cs240/readings/worse-is-better.html)

~~~
flatline3
Yegge took a massive shit on technical discourse, and if not countered, the
ramifications thereof could be felt for _years_. His influence is
disproportional to his value, and I am extremely disappointed to see anyone
here taking his emotional arguments seriously.

Unless firmly censured, I expect to see Yegge's ridiculous viral meme of
"liberal vs. conservative" spread and repeated by inexperienced developers
indefinitely.

If I had any respect for Yegge, I entirely lost it here. The question of how
to write software should be founded in careful consideration of specific
problem domains, experience and research, and studied approaches. It should
not be founded in some gross politicized and emotional argument.

Yegge is not just wrong, his reframing of engineering decision making is
dangerous, and his ridiculous and viral engineering-as-politics meme makes
people dumber for having simply read it. I'm disgusted with it, as well as any
debate that seriously approaches his irrational appeal to emotion.

Yegge should be ashamed.

~~~
jeremiep
I couldn't disagree more with that.

From reading his other essays, it's obvious the guy has a broader perspective
on programming than most software developers.

I believe it's experienced developers who will spread this because it takes
experience in many different languages and paradigms to really understand what
Steve described. I have different coding styles for Lisp, Haskell, D, Ruby and
CoffeeScript for instance.

The foundations of software development are generally not well understood.
Otherwise the vast majority of software out there would be more robust by a
few orders of magnitude.

Steve at least offers a classification for the different styles found in
programming communities today. He may not be right on spot, but at least it's
a start.

~~~
flatline3
The two-axis political classifications discards all reason and nuance in favor
of us-vs-them media sound bites.

The idea of applying two-axis classification to software development would
laughable if it wasn't so _dangerous_ in its attractiveness as an
oversimplified tribal mental model.

> _Steve at least offers a classification for the different styles found in
> programming communities today. He may not be right on spot, but at least
> it's a start._

No. It's not a start. It's a dangerous, dangerous viral meme that threatens to
replace rational dialog with ridiculous emotionally-driven opinionated
politicized tribalism, and I can't help but wonder if that's his intent.

It's a play out of cable news' playbook, and _I_ for one don't want an
environment for engineering discourse modeled on American politics.

I couldn't think less of Yegge as an engineer and a thinker than I do now.

~~~
tesseractive
My view may be colored by the fact that I'm a raging pragmatist about these
sorts of issues who thinks that the right type of solution depends on the
project and on the team (i.e. the right solution for mission-critical bank
financial transaction processing is likely not also ideal for a high-velocity
startup), but my impression was that the idea was for such an axis to be
considered as a _spectrum_ , not a simple dividing line for an us-vs-them holy
war.

When interviewing and considering joining a team, envisioning a spectrum like
this allows you to ask questions to see where a potential employer tends to
fall on this spectrum, and thus determine whether it seems like a good fit for
how you prefer to work and what you want to do.

And no, this is certainly not the only axis along which one can plot software
development, and I doubt Mr. Yegge's goal was to propose that it was. At most
it is _an_ axis, and the goal would be for it to be a useful one when
leveraged in the right context.

Can people take interesting ideas and horribly abuse them? Well, obviously.
One might even argue that an idea that _can't_ be abused by someone so
inclined must not be very interesting at all.

~~~
mononcqc
I swear to God if someone ever asks me about political interests related to
the way I develop software in an interview I'm going to take a dump on their
desk.

------
postfuturist
The things he said about the Clojure community are in contradiction with the
data from the 2012 State of Clojure survey here:
[http://cemerick.com/2012/08/06/results-of-the-2012-state-
of-...](http://cemerick.com/2012/08/06/results-of-the-2012-state-of-clojure-
survey/) .

Steve claims that Clojure folks come from the Haskell/ML world when the survey
lists the "former primary language" of survey takers to be 1% Haskell, 0% SML,
0% Ocaml. Whereas they actually come from Java, Python and Ruby mostly.

The Clojure "replacement" in the survey is all over the map with Common Lisp,
Erlang, Haskell, Java, Python, Ruby, Scala and Scheme all performing well. The
liberal/conservative thing is a false dichotomy and Clojure community is
probably living proof of that.

~~~
spottr
Yegge has a bone to pick with Clojure. It's about his feeling towards the
community, the language and the direction Rich Hickey is taking it [1]. It's
funny, reminds me of "In which Everyone had better shape up" [2].

[1] <http://news.ycombinator.com/item?id=2466731>

[2] <http://wondermark.com/333/>

------
yaongi
So, this is the culmination of 8 years of rants and blog posts? This is what
he's been trying to say all that time? What a peak he has reached. What an
insight.

I'm trying to think of an apt analogy for this post that doesn't involve vomit
or defecation, but it's hard. From the introduction proclaiming how readers
will be stunned by how clearly and resoundingly true the revelation revealed
within will be, to the literary diarrhea it's followed by... it's like a
little kid proudly telling his parents he finally used the toilet properly
only for them to find he completely missed the bowl. Yeah, I failed.

If the political spectrum is deeply flawed, as he said, then why even try to
hack it onto something completely unrelated, made of individual technical
points where each programmer may have a different approach?

I don't know, I like a lot of his past posts, but I don't dig this one. I
don't think it provides any useful insight whatsoever.

~~~
jeremiep
I get the feeling his essay is setting the scene for more to come, most likely
around Project Grok. The name is well suited, Yegge really understands how
code works.

Why hack on it? Because it's what hackers do. Steve only pushes it further and
hacks the philosophy of it. I love his essays as food for thought, and I
respect him for publishing his in-process thoughts about the matter to let the
idea out.

To me, this post was quite entertaining and broadened my perspective a little
bit again. The only downside, as is the case with most of his other essays, is
that it definitively wasn't long enough.

------
cromwellian
before it started I knew it was going to be another typing rant. I think you
continue to present a false dichotomy on typing, as well as missing some of
the reasons people desire it.

In particular, I like typing as machine readable documentation, that makes
IDEs simpler and more accurate in code navigation and refactoring. Dart in
particular shows this false dichotomy really well, but having a type system
for human and machine readable docs, making the IDE experience far more
pleasant, but which can be turned on or off. Unsound, untyped, programs can
still run. Yes, dynamic languages can have nice IDEs too (Smalltalk), but they
are harder to engineer.

In terms of optimization, typing is a must for many types of hard real time
programming. You can bet that the Mars Curiosity rover isn't using a garbage
collected dynamic language. Nor are the inner rendering loops of most mobile
games or console games. (Lua is another story when it comes to actual game
logic)

Lots of bold claims have been made for Javascript JITs for example over the
years, include a lot of hype about tracing JITs, but the reality is,
Javascript still doesn't even come close to native performance, and it's
hideously slow on mobile platforms in comparisons, with basic, idiomatic
programming (e.g. dictionaries with fields) having terrible numeric
performance. All this has actually served to threaten the Web with a native-
takeover because we don't have a fast web language CPU and memory efficient on
these devices.

I don't think that Tim Sweeney or John Carmack are prematurely optimizing when
they decide to write a game engine(rendering) in C++, because experience has
taught them that it is highly unlikely they'll be able to optimize a dynamic
language implementation later to a satisfactory level.

I think many people use a mix of languages depending on the context. I
certainly wouldn't write a web service in C++, nor would I write a 3D game in
BASIC. I wouldn't use anything but Perl to masage text files, and I'd use R
for data analysis. ﻿

~~~
bad_user
In the examples given, Dart with its optional type system (and with type-
checking that only triggers warnings) would actually fall in the liberal camp.

    
    
         You can bet that the Mars Curiosity rover isn't 
         using a garbage collected dynamic language
    

It's using 2.5 million lines of C. C is not a strongly typed language. C can't
really be classified as dynamic or static. C is just low-level assembly with
some structure attached.

    
    
         I don't think that Tim Sweeney or John Carmack 
         are prematurely optimizing ...
    

These people's jobs are building engines, not games. If you want to build a
game, especially if you don't have their resources and knowledge, you're far
better off by starting with friendlier tools, such as PyGame.

It's much cheaper to validate your idea that way and in the process you might
end up with a hit like Angry Birds, which runs in the browser just fine.

~~~
cromwellian
1\. Dart is less liberal than JS. For example, it is early bound. This fact
alone allows the IDEs to do a much better job with less complexity.

As I mentioned, Carmack and Sweeney make engines, the artist interface is
UnrealScript, or Lua, etc. But that's besides the point: performance matters.
Carmack isn't trying to build yet another Box2D casual game (the Iphone Angry
Birds uses a C implementation of Box2D, and Lua for game logic)

For someone like John Carmack, they are trying to push the state of the art,
and starting off implementing say, idTech 7 in Python would yield unrealistic
data if you're trying to see how feasible a given new rendering technique
works on the large scale.

C is a typed language, there's no getting around it. It is in fact, a
manifestly typed language, the types aren't optional. The fact that you can
freely cast your way out of any situation doesn't really make it a dynamic
language, anymore than Java reflection or bytecode rewriting makes Java a
dynamic language.

The basic fact remains, the Mars rover is a highly performance critical piece
of software with hard real time requirements, and it's simply not going to be
written in a language that doesn't allow precise control over numeric types
and memory allocation behavior. It's really those guarantees that many people
associate with strongly typed systems programming languages, not the compile
time checking.

Game programmers are very liberal, they want to escape straight jackets, and
get deterministic and low level control over everything, often breaking the
rules of the system. And in this regard, dynamic languages often taken away
some freedom -- the freedom to control memory, stack, and cache behavior. They
are conservative in a way.

~~~
ajanuary
"C is a typed language, there's no getting around it. It is in fact, a
manifestly typed language, the types aren't optional. The fact that you can
freely cast your way out of any situation doesn't really make it a dynamic
language, anymore than Java reflection or bytecode rewriting makes Java a
dynamic language."

C is statically and weakly typed language. That doesn't make it dynamic in the
same sense as python or ruby, but it does make it a heck of a lot less safe, a
heck of a lot more flexible, and thus a lot more liberal.

------
ezyang
Hidden inside this fascinating screed is an announcement about the "Google
Grok" project, which appears to be something of an Eclipse-killer for dynamic
languages. It's good to hear that Google is working on this problem, and I'm
interested to see what they come up with.

~~~
cageface
That was the most interesting point for me too. Mobile development has
reminded me of the significant tooling benefits of static languages but also
the verbosity and awkwardness of said languages. If I could have an IntelliJ-
level IDE for Ruby or Python or JS I'd be very happy.

~~~
rabbitfang
_If I could have an IntelliJ-level IDE for Ruby or Python or JS I'd be very
happy._

The company behind IntelliJ already makes IDEs for Ruby, Python and JS:

Python: Pycharm <http://www.jetbrains.com/pycharm/>

Ruby: RubyMine <http://www.jetbrains.com/ruby/>

JS: Webstorm <http://www.jetbrains.com/webstorm/>

~~~
cageface
I was a rubymine customer for 1.0 and it's good but nothing like intellij is
for java. Static typing just makes building good tools so much easier.

------
austintaylor
I think this is fundamentally flawed. Take HAML, for instance. It tends to be
polarizing, but not along the axis he has laid out. People who don't like it
usually point to the unfamiliar and non-standard syntax (conservative), but
the thing that I like about it is that it is more structured, and less error-
prone than string splicing (also conservative).

In general, when I fall on the liberal side of an argument, I think it is for
the reasons he gives (no fear, resist ossification). But when I fall on the
conservative side (which happens just as often) it is not because of fear, but
because I think that mathematically rigorous abstractions (pure functions,
persistent data structures, etc) offer a more powerful way to approach the
problem.

I think my attitude toward bugs (which he suggests is the defining issue) is
more nuanced than this spectrum allows. Bugs are inevitable, and it's not the
end of the world when you have a bug. We need debuggers. But I think that over
time, if we are doing anything right, we should be growing a stable core of
our codebase that is increasingly flexible and bug-free. I guess maybe this
could be considered a centrist view. It is certainly neither liberal nor
conservative.

Someone in the thread mentioned pragmatism vs. idealism. I think this is a
much more useful distinction. I would definitely consider myself an idealist.
But the pragmatic-ideal axis doesn't map to the conservative-liberal axis at
all.

------
Darmani
This is a brilliant move by Yegge. Now if you call him wrong, you're just like
the guy who attacks Aunt Marge's politics at the family dinner.

Unfortunately, your business is not Aunt Marge. You need to be able to make
the tough calls and say that, no, banning the color yellow is not a viable
policy. Software engineering and programming languages are both seriously-
studied disciplines, and all too often, the evidence comes down conclusively
in favor of one position.

To pick an easy target, in many languages like Java and C++, null can be
passed in place of (almost) any type. But

1) Empirical studies show that values intended to be non-nullable are more
common...

2) ...which means that many method definitions are cluttered with is-null
checks (to cut down the exponentially-increased state space)...

3) ...and it's just as easy to provide a feature to turn it on when it's
wanted (option types/Maybe monad)...

4) ...which many companies hack into C++/Java anyway (various annotations and
preprocessors)

This is a pretty solid case. Liberals win -- it's less code. Conservatives win
-- there are fewer bugs. Sometimes things really are that one-sided.

~~~
gaius
Yes, software engineering will never be engineering as long as so much of it s
just people's unsubstantiated opinions.

------
dsantiago
I'm trying to think of what anti-macros Clojure talk by a "key presenter" he
might be referring to. I'm only familiar with the talks from Clojure/conj, so
the only one that I can think of is Christophe Grand's (not= DSLs macros) talk
from 2010[1]. If so, I think his summary mischaracterizes the content of that
talk, but it could be another talk he's thinking of.

[1] [http://blip.tv/clojure/christophe-grand-not-dsl-
macros-45407...](http://blip.tv/clojure/christophe-grand-not-dsl-
macros-4540700)

~~~
richhickey
I think Christophe's is the talk, and Yegge seriously misunderstood it, if he
even bothered to watch it. Christophe's point was that basing the
underpinnings of a DSL on macros was frequently a mistake, vs a data +
functions approach that "leads to greater dynamicity". It is inarguable that
macros are less flexible than functions (e.g. they can't be applied) and less
composable. Christophe's argument wasn't against macros, but that they should
be the last layer of sugar, not the core mechanism of a DSL. This approach has
been advocated and practiced by Lispers forever. Ditto the advice to not use a
macro when a function will do.

And for Yegge to imply that more serious Clojure devs like Christophe are
macro averse because they are afraid they might not understand someone else's
macro code shows his complete lack of familiarity with Christophe's macro
skills and other work of the community.

Taking potshots at things you don't understand and people you don't know
(while leaving out the link so others could verify) smells like a FOX-news
rhetorical approach to me. Ditto political labeling (though in the programming
community the negative tag is "conservative", whilst in politics it is
"liberal"). Tag the thing you don't like with the negative label, then
rationalize, and spew misinformation. "Clojure's community came pre-populated
with highly conservative programmers from the pure-functional world: basically
Haskell/ML types": surveys[0][1] say... nope.

He even ignores the bulk of his own criteria in his labeling exercise. Clojure
has almost none of the things on his "Conservative Stuff" list except STM
(huh, is GC conservative too?) and almost all of the things on his "Liberal
Stuff" list. None of his 1-8 conservative points apply to Clojure (and I see
nothing wrong with conservative about speed - Common Lisp has always pursued
it, and its pursuit always involves risk), and all of his 9 liberal points
apply to Clojure.

Clojure devs are liberals that want their programs to work.

If Yegge doesn't like Clojure, fine. But to rationalize like this is weak.

Yawn.

[0] [http://cemerick.com/2010/06/07/results-from-the-state-of-
clo...](http://cemerick.com/2010/06/07/results-from-the-state-of-clojure-
summer-2010-survey/)

[1] [http://cemerick.com/2012/08/06/results-of-the-2012-state-
of-...](http://cemerick.com/2012/08/06/results-of-the-2012-state-of-clojure-
survey/)

~~~
technomancy
> If Yegge doesn't like Clojure, fine. But to rationalize like this is weak.

A bit of historical context from the last time this came up:

[http://groups.google.com/group/seajure/browse_thread/thread/...](http://groups.google.com/group/seajure/browse_thread/thread/18baa18ffdbdd790/917004da1b517f11)

------
kephra
One thing came up in mind " United States has only one party:the property
party. It’s the party of big corporations, the party of money. It has two
right wings; one is Democrat and the other is Republican. "

From a German point of view both liberals and conservatives are right wing.
And his article is totally missing any left wing politics. He is missing the
green, the socialists, the communists, and the anarchists point of view here.

And making it one dimensional also does not fit: What about Christian
socialists, what about conservative greens, what about anarcho-capitalists, or
national socialists?

e.g. I would classify myself (when it comes to programming) as anarcho-
capitalist: I'm using the language that best fits the problem, without bias.
And I'm earning most of my money with free software.

I also can not agree with how he positioned some languages, e.g. Perl might
look liberal at first, but the CPAN community is more conservative when it
comes to constraining regression test or documentation than the Ruby or Python
people. Also ASM might look liberal at first, but if you ever worked in a
closed shop, you know that ASM/370 coders have a really conservative approach
to create software.

------
thebluesky
Yegge: <http://www.urbandictionary.com/define.php?term=Yegge>

_"A measurement of length of a piece of writing, particularly when indicating
a length excessive for the genre. A Yegge is approximately 4000 words or 25
kilobytes.

Named for well known programmer and technical blogger Steve Yegge, whose blog
up to about 2009 was notorious for entries of approximately 1 or 2 Yegges in
length, vastly exceeding the typical length of blog entries in the genre."_

------
cturner
Broad-brush talk is a step backwards.

Political talk and thinking is poisoned by the ideas of "left" and "right"
even though those phrases haven't had a connection to reality since the French
First Republic.

It'll probably be fine. Politics is in many respects a zero-sum game, and
polarises participants into two camps. Software isn't like that.

~~~
stonemetal
The ideas expressed in the article ring fairly true to me. I wouldn't have
couched them in political terms, because as you point out there is too much
emotion in that arena. I tend to think of it as Engineers vs Artists. On the
one hand you have Linus' think it through, do it right. On the other hand you
have PG's explore, discover, express yourself style. Each method is valid in
different situations.

------
parasubvert
This doesn't actually seem to be all that new of an argument: the debate used
to be about "craft" vs. "engineering" or between "software is math" and
"software is mechanism".

For example of what's pretty close to a Yegge rant of the 1980's, see Edsger
Dijkstra, "On the cruelty of really teaching computing science" [1]. It seems
to be bemoaning similar debates in the software field, though from a very
"conservative" perspective, since Dijkstra prefers that a formal proof should
be required with every program, and one should completely avoid
anthropomorphism in discussing software design.

Another thought that's crossed my mind: one of the reasons for the evolution
of these approaches to politics and risk over the years has to do with the
scale of impact. Liberally messing around with a social and economic systems
can lead to widespread human disaster: China's Great Leap Forward comes to
mind. How the software is used and how reliable it needs to be is an
engineering tradeoff with regards to cost & time. This is often why you tend
to see much more liberal approaches to software in smaller companies - the
scale of impact is much smaller (in terms of customer base, and investment)
when you cock up.

Now, it's clear that larger companies, particularly many IT shops, could learn
a thing or two about being "progressive conservatives", as they've "conserved"
for far too long and are caught in the trap of special interests (i.e.
traditional vendors dependent on their cash). Fear of dynamic languages, open
source, or cloud services, or non-waterfall development is mostly a
reactionary ideology grounded with some kernels of truth - static typing DOES
help codebases scale (but you shouldn't be proud of a large codebase), you
can't just pick ANY open source library as some are DOA, or ANY cloud as some
are unreliable, and tinkering with your delivery methodology can reduce your
performance greatly due to confusion, plus there's plenty of cargo-cult agile
consultants waiting to rope you in. So, you need to think these things
through. But that's not an excuse for avoidance. Perhaps that means I'm a
software moderate.

[1]
[http://www.cs.utexas.edu/~EWD/transcriptions/EWD10xx/EWD1036...](http://www.cs.utexas.edu/~EWD/transcriptions/EWD10xx/EWD1036.html)

(edit: typo)

------
lispm
The characterization of Clojure is questionable. A conservative would want to
avoid risk and would be against change. About the only really conservative
thing of Clojure I would see that it preserves the investments made into the
JVM and uses an accepted technology as a base. Other than that it is a radical
break for the Clojure user base. The Clojure user base does not come from ML
or Haskell. It comes from Java, Ruby, Python and a few other languages. But
not from statically-typed functional languages and not even from Lisp. Even
Rich Hickey does not come from there.

With Clojure you keep one feet on the ground (the Java ecosystem) and the
other feet is in the unknown dark water.

------
grandalf
While I found the article annoying in its oversimplification, I think the real
tension Yegge is feeling is about contracts. At a high level, contracts apply
to coding standards, and at a low level they apply to interfaces, etc.

One may find many aspects of a contract annoying yet still prefer a world
where contracts are widespread to a world without contracts.

In a sufficiently complex ecosystem contracts make some things easier and some
things more difficult. But contrary to Yegge's assertion, it may be that some
organizations have a contract that if something breaks, then one of the
parties involved does a rewrite/redeploy. This is not a replacement for a
contract, as Yegge implies, simply a different contract.

One contract might be: "All code must be unit tested". Another might be "If
you don't write unit tests and your code works, that's great, but if it fails
then prepare to pull an all-nighter if necessary."

My guess is that most developers, if asked which kind of methodology was
appropriate, would generally pick a methodology that was appropriate for the
level of risk involved. If the code is going to manipulate a robot arm holding
a knife as it jabs quickly toward the programmer's body, few programmers are
going to think that the bugfix/redeploy approach makes sense. But when it's a
social site then everyone starts to feel more like a cowboy.

I think it is an insult to the professionalism of programmers everywhere to
assume that risk decisions are a function of internal constitution rather than
a rational risk assessment.

------
narag
Honestly, I can't see it that way. People that I met and I know how they work
and think don't fit in this axis at all. The distinction that I do see is
between people that trusts experience of what works and what doesn't (and
still willing to test new ideas when it makes sense) and people that rigidly
adheres to policies or dogmas.

The type of tools they use and like are circumstantial. It's more of a
empiricists vs. authority thing.

~~~
naitbit
In the beginning I too wanted to write that I don't agree with this split.
Then I come to conclusion that he met far more programmers then I so he
probably knows better.

Anyway I'm not sure were to put myself on this axis. My behavior changes
depending on other variables(what consequences would bug have/how many times
code is going to be executed etc).

FE: critical part of commercial software (like money calculation) would be
written in a way that would try to make it obvious that there are no errors,
in language with type checking with unit tests and if possible even with
mathematical proof of correctness. With code review and QA thrown at it
afterwards. To sum up very conservative(and costly) approach.

On the other hand my holiday photos got completely different treatment. Short
python script, that would batch their HDR process in a way specific for their
content and with a lot of dependencies to my current desktop setup, without
any unit tests(script thrown up few temporary files making it easy for manual
debug, had backup of my photos in case script ate them). The only conservative
thing that I could think of in this setup was that I made it concurrent to use
4 cores because it was only one line change and 4time speed up in lengthy
process was worth it.

Can someone suggest were on liberal-conservative axis am I?

------
kstenerud
What "politics" I adopt depends mostly on what I'm building.

If it's a library that someone else will use, I try to play as conservatively
as possible, and I fully expect that despite my best efforts those developers
will uncover lots of bugs regardless.

If it's a mission critical application, I'll also be conservative. The more
pain there is in fixing things later, the more careful I'll be up front.

When I'm writing a game, I'll play it more fast-and-loose. So long as any
glitches don't crash it or open an exploit or ruin the user experience, it's
usually an acceptable trade-off.

When I'm writing stuff for myself, I go crazy, trying out all new fads and
methodologies just for the hell of it. This way, I learn new things and get
enough experience with them to mark them as conservative-safe and liberal-
safe.

My only sticking point is this: If someone competent cannot follow your code,
you haven't documented things properly.

~~~
dasil003
This is essentially what I commented on G+ and what I came here to say.

A programmer who does not understand the tradeoffs of liberalism vs
conservatism as Yegge defines them is _not_ a good engineer. At best they
might be talented at doing things a very specific way, sort of like a designer
whose stuff all looks the same and is often inappropriate for the job at hand.
Such a person is more an artist than a designer, and I'd make the same
distinction for someone who writes log-processing code in Haskell or codes
software for a spaceship in Ruby.

~~~
pjscott
Actually, I'm pretty sure you could make a good case for log processing in
Haskell. There are some businesses with _lots_ of log data, containing any
number of dimensions along which you might legitimately want to slice and
dice, with their formats and schemas changing over time. Haskell's type
checking is really good at catching the type of bugs that tend to crawl out of
this kind of application, and its speed is a good thing when you're dealing
with a whole lot of logs.

~~~
dasil003
Sure, bad example, but the point stands. Not everything requires type safety,
and playing fast and loose with dynamic typing is not always faster.
Programmers shouldn't be ideological, they should always be striving for the
best solution by understanding the tradeoffs in any given situation. To do so
effectively requires both liberalism and conservatism as Yegge defines them.

------
brown9-2
Off-topic but does Google Plus offer any way to view a post nearly full-
screen, without all the extra margin and white space taking up 2/3rds of the
screen?

A bit annoying that the post text only takes up about 33% of my available
screen real estate, even on the "view single post" URL:
<http://cl.ly/image/1p1B2o3D262g>

~~~
naitbit
Personally for longer page browsing I pivot my screen vertically, zoom and
scroll to make content fit my screen. It may not be fastest way but gets job
done. It works better on Google plus then on some other pages(were some
toolbars obfuscates content on zoomed page, or which get to wide for screen).
On non pivoted screen I usually have browser only on left halve on the screen
and do it same way. There may be some plugin that would fit you more though.

~~~
vorg
You're lucky you can view any of it. In China nothing from gplus arrives.

~~~
technomancy
That's called a blessing in disguise.

------
pshc
_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._

So this is the project that Yegge mentioned would turn "all code [...] into
Wikipedia." Man, my ongoing project is more similar to it than I thought.

I find it curious that he would even bother to mention (IV) though. (IV) falls
right out if you start from the correct data representation, which I would
have assumed from (A). I wonder if he's still listing dependencies explicitly.

------
ChuckMcM
I think the best (only?) point to come out of this essay is that different
people have different definitions about what makes code or coding methodology
"good".

And because of that you can find yourself in an endless argument with someone.

Why he dressed it up in political satire (allegory?) I don't know, seemed to
me to make his point less forcefully.

------
fleaflicker
In his section on Tech Corporations, he classifies Apple as "Diagnosis: no
idea."

Is there a reason nobody speaks publicly about Apple's engineering culture? We
hear a lot about the culture at Google, Facebook, Microsoft, and Amazon. But
I've never met an Apple engineer. And I've never read any detailed accounts by
an insider.

Does anybody have any good resources? Or is there a very restrictive
confidentiality policy?

~~~
jfb
I can only speak as to Apple as of 2004-2009, when I was there. It was
intensely pragmatic, much more so than other companies of comparable size I'd
been at. The focus was on shipping, and whatever it took to get product out
the door. Once projects were no longer directly in the gaze of Barad-dûr,
however, politics set in and things ossified rapidly.

Day to day in my world was a lot of C, Objective-C and C++, with Python for
rapid prototyping and glue code; Java formed the backbone of the store
infrastructure, but there was plenty of other stuff going on. Fairly standard
architecture (huge Oracle DB, loads of web servers). Teams tended to be
undermanned, so there was constant tension between getting stuff done and
standardization; much of the time, the wrong balance was struck, meaning that
people couldn't easily switch roles, but still had a lot of bureaucratic
scutwork to manage. Things were improving when I left, and I imagine that they
have continued to do so.

------
ziadbc
Who is more of a 'liberal' programmer, RMS or Linus. Think about it.

In my estimation, if the answer here is unclear, then this metaphor breaks
hard.

~~~
pjscott
GNU and Linux both seem to fall into the "conservative" side of Yegge's
taxonomy. Do you disagree?

------
mononcqc
I truly fear we'll get into debates of software conservatives vs. software
liberals, and at some point some jackass will say "of course but <person x> is
a researcher for <liberal/conservative> software engineering" as if it were a
contest.

If that happens, I predict a fucking hellhole and I can only imagine myself
leaving the industry at once.

------
sandGorgon
Clojure is tied very strongly to the Java toolchain (note "toolchain" rather
than "ecosystem"). The packaging system and package managers use Maven and
Java jars instead of a clojure-based one.

This means that promising projects like Clojure CLR have no chance of taking
off the ground, unlike say Ruby vs Jruby vs Ruby EE vs Rubinius.

------
robocop
I think a better analogy is

Conservative: the existing system must not break!

Progressive: we must add new features!

------
darkandbrooding
Yegge's entire essay seems like an application of JWZ's regex admonition. "I
know, I'll present my hypothesis using political terminology!" Now you have
two problems.

Political terminology in the United States is MASSIVELY warped by entities who
spend literally millions of dollars in an effort to connotatively redefine
words. When you (re)define words like "conservative" or "liberal" you risk
alienating people who have been conditioned to have an emotional response to
either definition. If you define a term in a way that seems pejorative to your
reader, the reader will weight every subsequent statement against the rigor
they think you brought (or did not bring) to those definitions. Your essay
will entirely fail to persuade if it rests on (perceived) faulty definitions.

When writing to a largely US audience, no attempt at honest communication will
be aided by the application of political labels.

Here's a test: can the essay be rewritten without that political terminology?
Reader "nirvana" used the terms "cowboy" and "architect" to describe his two
axes. ( <http://news.ycombinator.com/item?id=4367328> ) I very much prefer
those terms. Yes, they're also connotative and subjective, but as analogies
they map much better onto the subject being discussed.

------
yevuard
The difficulty that I have with his linear generalization is that I strongly
agree with some points on both sides - sometimes feeling oppositely strongly
about two halfs of the same sentence. Another commenter linked to
<http://james-iry.blogspot.com/2010/05/types-la-chart.html> which makes the
statement that "the design space is very highly dimensioned, perhaps
infinitely so". I suspect that the programmer opinion space is similarly
highly dimensioned, and more particularly, that the specific single
dimensional analogue that Steve Yegge draws in his post obscures critical
features of this topology. If I can come down hard all over the line, then he
does not have a good enough mapping from the higher dimensional space. As an
aside, using the labels "liberal" and "conservative" inappropriately
juxtaposes rather strong emotions in the mix. Hopefully the emotional/visceral
reaction was not his intention as a means of ideological persuasion.

------
eternalban
"Just as in real-world politics" it is a 'misguided' idea to view the
political space as a 1 dimensional space, ...

------
j_baker
I think one could make an argument that Haskell is like Fascism. They're both
extremely liberal applications of extremely conservative beliefs. This can
make categorizing them difficult.

Scheme, Erlang and company are more like communism: extremely liberal
applications of extremely liberal beliefs. So much so that people tend to view
them as "good in idea, but flawed in practice".

Python and Ruby are more like traditional liberalism. They bring in new ideas,
but not in excess.

Scala and Clojure seem remarkably centrist. They both bring in good ideas from
both the liberal and conservative camps.

Lastly, C is "old guard" conservatism, C++ is a Bush-style "compassionate
conservatism" that tries to please everyone while being labeled
"conservative", Java is a neo-con, and C# might be compared to the Tea Party.

------
swah
Wait, what is <http://c2.com/cgi/wiki?AlternateHardAndSoftLayers> then ?

------
duaneb
I think that a better parallel dichotomy would be features vs quality, in a
world where they are mutually exclusive. However, I think Yegge wasted too
much thought on this. It is the software that dictates how conservative a
piece of software is: bugs and stability are generally tolerated in user-
facing software because at worst the user has a bad experience. However, a
database better be as close to 100% reliable as possible, which in turn leads
to testing and static analysis, meaning typing... It is not really negotiable.

I think there are way too many variables for a linear scale to provide
meaningful comparison.

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

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

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

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

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

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

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

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

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

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

~~~
bad_user

         I would probably place C# as significantly more 
         "liberal" than Java
    

Only if you look at these languages in isolation from their virtual machines
and operating systems on top of which they run, also disregarding the
communities around them.

Java as a language is more conservative, definitely, but the Java ecosystem is
definitely more liberal. As proof, compare Java's open-source community with
.NET. Or compare the maturity of alternative JVM languages (e.g. Scala,
Clojure, JRuby), with the alternatives running on top of .NET ; or compare the
web frameworks available for each.

This is the reason why, when faced with a choice, a "liberal" developer will
most likely pick Java over C#, even if C# as a language is more liberal.

    
    
         Only very brave--very liberal--companies are going to 
         use Haskell or Scheme in actual production
    

I do not think this is an issue of liberals versus conservatives. It's
actually an issue of pragmatism versus idealism.

I'm pretty sure that many people wanted to use Haskell or Scheme in
production, but then they'd shoot themselves in the foot, because the
available libraries and tools for a language are far, far more important than
the language itself. That's why Perl was so successful in the first place,
because Perl hackers were getting shit done, then contributing to CPAN, which
allowed other hackers to get their own shit done, and so on.

On the other hand I'm seeing lots of startups trying out and even using
Clojure and Scala in production, at least for parts of the project. That's
because these languages have all the Java libraries at their disposal, even if
the languages themselves are still immature.

Don't mistake pragmatism for conservatism. That would be a mistake.

~~~
bmj
How much of the difference between the C# and Java ecosystems is due to the
age of the language? Of course, I agree with you, too, because we have a
"liberal" language (C#) tied to an extremely "conservative" company/platform
(Microsoft), and that will always be a limiting factor in the growth of the
ecosystem.

~~~
nahname
Has almost nothing to do with the age. Most dotnet shops wait for MS to give
them what they need. Java developers are more inclined to create (and share)
their own solutions. It also doesn't help that MS actively cannibalizes and
rebrands open source projects.

------
DanielRibeiro
Interesting positioning of languages:

 _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_

Woud be nice to overlap James Iry's chart[1] with it...

[1] from <http://james-iry.blogspot.com/2010/05/types-la-chart.html>

~~~
thebluesky
It seems very subjective (and somewhat arbitrary) to assign labels of
"conservative" or "liberal" to languages based largely on type safety. If this
random blog post is taken as the definitive source of "conservative" vs
"liberal" we get the following:

Twitter and Tumblr using Scala are "Hardcore conservative", while guys writing
assembler for IBM mainframes are "Batshit liberal" ?

~~~
abrahamsen
Assembler is so liberal that you have to be deeply conservative in order to
write code for it.

~~~
zaptheimpaler
Exactly! I think assembly language falls through the cracks in this way of
classification - languages themselves can be liberal/conservative, and the
communities using them can be liberal/conservative. In the majority of cases,
these two will be aligned. But in assembly code, there are a lot of different
ways to screw things up (batshit liberal purely based on the risk profile of
the language), so if you want code that works, you need to be extremely risk
averse (conservative) from the outset.

------
ericbb
I just want to add a link for people interested in this discussion.

(Dynamic Languages are Static Languages by Robert Harper):
[http://existentialtype.wordpress.com/2011/03/19/dynamic-
lang...](http://existentialtype.wordpress.com/2011/03/19/dynamic-languages-
are-static-languages/)

With HN discussion here: <http://news.ycombinator.com/item?id=2346590>

------
EzGraphs
Some of the tendencies depend upon the nature of the organization. Startups
tend liberal (want to change the world). Corporations tend conservative (want
to avoid major mistakes). The selection of tools does not always reflect this
immediately though.

Also some classification of technology as conservative or liberal depends upon
the competing technology it is running against. I was a bit surprised to see
Python classified as liberal - but it makes sense when comparing it to Java.
If it is being compared with Ruby it is very conservative ("do things one
way").

There are some non technological risks that influence technology decisions.
Visual Basic may be "Hardcore Liberal" from a language perspective, but it is
pretty conservative politically (backed by Microsoft, lots of available
experienced programmers).

Steve as usual has interesting insights. I am not sure that this is a paradigm
that completely fits - but it does provide a perspective for understanding
fundamental beliefs that can lead to disagreements in software projects.

~~~
EzGraphs
The general risk-adverse vs. change-oriented paradigm makes a lot of sense.
The problem is that it not limited to the technical realm in most
organizations. Technology decisions often need to be justified by management
who don't necessarily use purely technical criteria for their choices.

Some rather simple criteria can be used to group languages - age and
popularity. Perl, JavaScript, Java, Visual Basic are conservative in that they
are popular, well known, established languages (even though they cross the
Yegge's whole spectrum). Haskell, while extremely conservative technically, is
extremely liberal in many organizations - where there are no currently
implemented projects using the language and no programmers experienced using
it.

------
swah
I tend to relate to conservative with "small government", and in that light
Lua would be a conservative language, because it has a small core and doesn't
try to do too much.

His conservative definition is seems to be "everything that is wrong with the
world" or something.

\---------

Also, this older rant reads to me as Yegge saying that this "conservative guy"
was responsible for Google's success:

"I've been debating whether to say this, since it'll smack vaguely of
obsequiousness, but I've realized that one of the Google seed engineers
(exactly one) is almost singlehandedly responsible for the amazing quality of
Google's engineering culture. And I mean both in the sense of having
established it, and also in the sense of keeping the wheel spinning. I won't
name the person, and for the record he almost certainly loathes me, for
reasons that are my own damn fault. But I'd hire him in a heartbeat: more
evidence, I think, that the Done, and Gets Things Smart folks aren't
necessarily your friends. They're just people you're lucky enough to have
worked with.

At first it's entirely non-obvious who's responsible for Google's culture of
engineering discipline: the design docs, audited code reviews, early design
reviews, readability reviews, resisting introduction of new languages, unit
testing and code coverage, profiling and performance testing, etc. You know.
The whole gamut of processes and tools that quality engineering organizations
use to ensure that code is open, readable, documented, and generally non-
shoddy work.

But if you keep an eye on the emails that go out to Google's engineering
staff, over time a pattern emerges: there's one superheroic dude who's keeping
us all in line."

([http://steve-yegge.blogspot.com.br/2008/06/done-and-gets-
thi...](http://steve-yegge.blogspot.com.br/2008/06/done-and-gets-things-
smart.html))

~~~
zaptheimpaler
Thank you for the link to the older Yegge article. I REALLY needed that to
remind me I'm stupid again.

------
engtech
I've noticed this divide for a long time, but the way I've always plotted the
axis is "urban" vs "rural".

urban - accepts a certain amount of chaos for the benefits of reducing
redundancy, wants to centralize code, reuse via shared centralized code

rural - wants to be isolated, wants to "see" everything, wants to have control
over everything, reuse via cut-and-paste

------
brlewis
Kent Pitman on programming languages as political parties:

2001:
[http://developers.slashdot.org/story/01/11/13/0420226/kent-m...](http://developers.slashdot.org/story/01/11/13/0420226/kent-
m-pitmans-second-wind)

1994: <http://www.nhplace.com/kent/PS/Lambda.html>

------
dinkumthinkum
A political philosopher "he ain't." I still get the hype of Steve Yegge, I
guess he's a writer only software blog audience world could love. It was soooo
loqacious; he doesn't disappoint. :)

Nevertheless, I don't know which was worse, the claim about what political
conservatism/liberal is or the software one. I guess the software doesn't
matter because he's just making it up anyway, but still. Before anyone thinks
too highly of this piece, I recommend people study some actual philosophy and
humanities.

At it's very core this is just an elaborate (not in a good way) dressing up of
the static vs dynamic typing discussion; hardly a revolutionary insight. I
also don't see how this is "risk" based debate. But in any event, this is just
hard to take.

------
shiftb
I agree with this. Although, personally I'd make the analogy closer to
religion than politics.

------
prtamil
Now i understood why i love Common Lisp and hate Clojure. It has nothing to do
with Community or language. Its about Me. I'm a liberal. Knowing that i'm a
liberal liberated me.

~~~
lukev
What confounds me is that while I'm a liberal by every other measure Yegge
proposes, I still love Clojure.

------
7952
It depends on context. If you are aware of your own fallibility python is a
far more conservative choice than C++. Coding is difficult and the most
limiting factor is your own ability. Imagine asking some students to build a
Mars rover in 6 months with no experience. It would be far more conservative
to use Arduino than ask them to start rolling C code. You are liberal because
you are crazy enough to try and build a Mars rover in six months with no
experience.

------
dmoney
Just as you shouldn't limit yourself to being a "Python programmer" or a "Java
programmer", limiting yourself to liberalism or conservativism is a bad idea.
You may prefer more liberal or conservative projects, or companies, but that
doesn't mean you won't face safety-vs-speed[1] tradeoffs on a regular basis.

[1] safety meaning certainty of correctness, and speed meaning speed of
development (as opposed to execution)

------
mathattack
Great and obvious, but is this really new?

I think the issue he captures has been well known for a while. It is
structured versus unstructured. Neither is better in an absolute sense, but
one method can be better than another in a given situation. This is beyond
just software, but business approaches in general. Startups are generally
liberal/unstructured, Dow Jones firms are generally conservative/structured.

------
dusklight
I don't really think it is fair to characterize Clojure as conservative. If
anything Clojure was created out of the motivation to have the cake and eat it
too. Most other languages grant you the benefits of type-safety but at the
cost of reduced flexibility/increased complexity. Clojure tries as much as
possible to give you the pragmatic benefits of both while mitigating the
costs.

------
stock_toaster
I found it thought provoking, but I am not sure I agree with the
classifications he arrived at. People sure do love putting names on things and
classifying things into buckets!

I did find it interesting that he considers himself a liberal (both in
software and politics), then then goes on to create a "type system"
categorization for programmers (and programming languages) to be placed into.

------
cheddarmint
Is the introduction of a poisonous dichotomy into the engineering zeitgeist a
good thing? Consider what this has done for politics.

------
alinajaf
I think as a Ruby (and occasionally C) programmer I stand firmly in the
liberal camp, but is it weird that I sort of like Haskell too? I find the idea
of expressing the semantics of my program through types to be useful
sometimes.

Then again my actually political views tend to span the liberal/conservative
spectrum so I suppose this is not surprising.

~~~
duaneb
Ruby is more liberal than c (duck typing)

Haskell is more liberal than ruby (functional programming)

C is more liberal than Haskell (weak typing)

Also, I am apparently a radically conservative programmer, but my political
views in real life tend toward radical liberalism. I think any correlation
says more about age than it does about politics.

~~~
alinajaf
> Haskell is more liberal than ruby (functional programming)

Not according to the article, which is what my comment was in response to.

> I think any correlation says more about age than it does about politics.

Quite possible, I'm 26.

~~~
duaneb
> Not according to the article, which is what my comment was in response to.

I see. Yes, Haskell meets all the criteria for a conservative language,
emphasizing safety, and verifiability, and automated testing. However, purely
anecdotally, I can't think of a single person I've worked for that uses C++
approving of Haskell because it is so radically different. But perhaps this
doesn't matter.

~~~
alinajaf
I tend to agree, on my own personal scale of liberal/conservative (which has
little to do with type systems), I'd rank Haskell as fantastically liberal.
You could probably enumerate the companies that use it in production on one
hand.

------
hugoestr
His real argument is that there is a dynamic typing vs static typing divide.

Didn't we know that already?

I would like to believe that the political bit was just a well timed hook to
get people to read his blog. He understands that the right incendiary rant
will bring readers. If it is sincere, though, it shows a disturbing level of
crankiness.

~~~
ajanuary
His argument is that there is a reason behind the dynamic vs static divide
that reaches out wider than that.

------
mej10
Making these arbitrary categorizations into "liberal" and "conservative" for
things where we have all of the data is pretty much useless.

[http://lesswrong.com/lw/no/how_an_algorithm_feels_from_insid...](http://lesswrong.com/lw/no/how_an_algorithm_feels_from_inside/)

------
gwillen
The comments yield more or less the response I expected, to wit: The
'liberals' agree that this is a useful distinction, and the 'conservatives'
complain that the distinction is bullshit, and serves only to try to justify
the misguided beliefs of the 'liberals'.

------
kator
I know I will regret this but here is a little survey I whipped up quickly.
It's static so results are local to your browser.. Enjoy:

<https://dl.dropbox.com/u/704864/software-politics.html>

~~~
sramsay
Very surprised to see what a centrist I am; my unscientific number is -5). I
would have pegged myself as much more liberal, but when it comes to specific
points having to do with design and deployment, I'm more conservative than I
would have thought.

~~~
kator
I was a bit surprised at my result since I've done large systems and have been
developing for 30 years. I think I lean toward more of the "get it done" camp
unless it's a super high-production (i.e. money gets lost when down) system
then I might tend further toward the center. :)

------
anarchotroll
What he wrote about Microsoft is completely unrelated to the rest of his post.
It says nothing about the company's culture and software development
processes. He could have saved himself the embarrassment of writing that.

------
kanaka
Good response from chouser (author of "The Joy of Clojure"):
[http://blog.n01se.net/Clojure-is-not-Software-
Conservative.h...](http://blog.n01se.net/Clojure-is-not-Software-
Conservative.html)

------
abecedarius
Forth by this light is batshit liberal, but stereotypically conservative in
its early binding. I'm not sure how to take this -- libertarianism comes to
mind. Or Sealand. (I used to hack Forth a lot as a teenager.)

------
lani
I think a good way to classify the two is :"one group feels that others cannot
do what I do" and the other group feels "what I can do anyone can do - right
away or with learning/time".. and I think this shows up

------
pilgrim689
Do any other engineering fields suffer from these broad-stroke
categorizations? Do Mechanical Engineers have additive VS subtractive
manufacturing debates? Or do they just shut up and solve problems?

------
anarchotroll
The bottom line is: everything that cannot be scientifically proved acquires
this sort of "religous" attributes. No wonder religions and politics are like
that

------
kstenerud
notime, your account was hellbanned 15 days ago:
<http://news.ycombinator.com/item?id=4294279>

priestc, your account was hellbanned 26 days ago:
<http://news.ycombinator.com/item?id=4245644>

------
mark-r
I think he misclassified exceptions. A true conservative avoids exceptions and
uses error code returns instead.

------
MaysonL
The algebraist/analyst corn cob distinction seems much more valid & meaningful
than Yegge's split.

------
guscost
As with regular politics, it always depends on the project, and the
independents know best.

------
exim
He should invest more time in writing, to make his posts bit shorter.

------
sidcool
Pretty long essay, but worth a read.

------
michaelochurch
I think I'm a software libertarian.

If you like dynamic typing and can write good, legible code in a language like
Python or Lisp, do it. If you like static typing, knock yourself out. If you
want to use an IDE, go for it. If you want to use emacs, do it. Hell, if you
like object-oriented programming, try it out. I think 95% of "object-oriented"
programming (as currently practiced) is junk, but the other 5% is legitimately
valuable. If you have the taste to pick from that 5%, go ahead.

What you shouldn't have the right to do is impose complexity on other people.
Use whatever environment you like, but if your code depends on your
environment, that's bad. If people can't get work done because they're
cleaning up your messes, that's bad. Be as liberal and as kinky as you want in
your own sandbox, but don't impose your wacky, untested DSL on everyone else.

That said, I like statically typed languages. ML is the only language I've
encountered where reading average-case code is enjoyable. (Scala's a great
language, but average-case code is ugly due to the Java influence. There's a
fair amount of spaghetti code written in it due to the cultural legacy of the
SpaghettiFactoryFactory Java culture. I can't speak for Haskell because I
haven't seen enough.) I think that's neat and very rare in the programming
world. How much code is enjoyable to read? 1 percent, maybe? In Ocaml, that
number is a lot higher. Probably around 50%. 50 percent of Java code isn't
even _legible_. Being able to actually read other peoples' code is nice, and
it's one thing I miss about working in Ocaml.

I'm probably more in line with the hard-line conservative camp in terms of my
view of complexity: avoid it unless you need it. The Unix philosophy works.
Religious X-oriented programming doesn't. Big Code leads to fail. Small-
program methodology's little programs (Unix philosophy) are written to solve
problems: do one thing and do it well. Ambitious projects should be structured
and respected as _systems_ , not all-or-nothing, massive single-program
megaliths with no clear communication policy among modules. Small-program
development works. Big Software is written to get promotions. That produces
the next generation's legacy horrors. Also, structuring your company around
17-day "iterations" is stupid. Et cetera.

I also tend to think that a lot of the features that scare typical software
conservatives are genuinely worthwhile. Macros in Lisp are important and can
be very beneficial-- if used conservatively. Cleverness for its own sake is
bad, but there are times when macros are very useful. Document what you're
doing, and make sure it's tasteful and makes sense before you let anyone else
depend on the work, but go ahead and do it. I wouldn't have learned what not
to do with macros had I not made a few mistakes when I first encountered them.

So, with a mix of opinions from the "conservative" and "liberal" camps, I
can't say where I fall. I like macros (when used by disciplined people) but I
also like static typing. Both turn out to be very useful tools. Consequently,
I find that I like a lot of different languages and insist not on a specific
one, but on small-program methodology so that people can use the right tool
for the job.

I'm conservative because I dislike complexity (I think "software liberals" are
OK with complexity as long as it's under the hood-- most metaprogramming
involves extremely complex solutions that, when they work and the abstractions
don't leak, although this is rare, allow clean interfaces-- whereas I'm not
comfortable making that distinction) but I (a) understand that liberalism is
essential to driving innovation, and (b) can't classify myself as a
conservative because management is inherently conservative and is, in
software, almost never the solution to the problem. Usually, it is the
problem. Most companies fall to shit not because they have some difficult
code-- every codebase has some crap in it-- but because management mandates
that they use the bad code (often for political reasons, like the original
architect being a crony of the manager) as-is instead of taking the time to
understand or replace it. I'd like to see how Valve evolves over the next 5
years, because I think management in software is usually a source of
undesirable complexity, rather than the safeguard against complexity that it
thinks it is being. If Valve can give us a determination either way on whether
software can work without managers in the first place, that'd be incredibly
useful information.

Not surprisingly, software politics also has a lot of individual
inconsistencies and hypocrisy. Corporatism (in politics, not software) is
neither socialism nor capitalism but a system designed to give the best of
both worlds to a well-connected elite and the worst of both to everyone else.
(Consider air travel as a microcosm: Soviet experience and service quality and
comfort, mean-spirited and capricious-- but very capitalistic-- pricing.) I
think the same exists in software politics and the typical managerial
conservatism. People and organizations can identify in name with liberalism or
conservatism, but tend to pick and choose as suits them. (For an example of
this inconsistency: Google, a bastion of software conservatism, allowed GCL to
exist.) What makes 90 percent of software jobs so fucking miserable isn't
those rock star, "undisciplined" Rails liberals or stodgy gray-haired
conservatives. Rather, it's a corporatist "crony capitalism" state where
people who win managerial blessing get liberalism (i.e. the autonomy to do
whatever they want and freely impose complexity downstream) while the rest of
the drones get stonewalled with a supposedly stiff-lipped conservatism (e.g.
"you can't [fix that codebase | use that language | pursue that side project]
because we can't afford the risk") that is presented as principled, although
the drones see managerial favorites getting through that wall on a daily
basis, so they aren't fooled.

~~~
derleth
> I'm conservative because I dislike complexity

Except a lot of conservatism as defined here is _all about_ complexity in
terms of 'big design up front' methodology and, really, _having_ a big
methodology in the first place, along with having a lot of testing and static
analysis tools.

Ada is a conservative language. C is extremely, red-diaper liberal.

~~~
michaelochurch
Sure. I think that Yegge has hit on something real, but I don't agree with
where he's drawn the lines. Haskell and Lisp developers have more in common
with each other than with "best practices" Java developers.

A lot of this is about risk assessment. Business people and engineers don't
agree on how to define and measure risk. Business people think Java is the
low-risk choice, because the risks are hidden. Engineers know that these over-
ambitious, 20-person Java projects are actually a lot riskier. Putting 20
people on a 5-person project doesn't make it less risky, but more. Business
types fundamentally don't get this. They have no idea what is wrong with Big
Code methodologies, because they don't experience the externalized costs (of
long-term maintenance and diminished morale). They get promoted and move on to
the next (usually bigger) project.

Familiarity comes into the mix, too. Lisp is rejected because it's foreign and
weird and macros can create a lot of undesirable complexity, but
SpaghettiVisitorFactory patterns in so-called "best practices" Java are just
as bad. They're a lowbrow spin on the same theme: obfuscation through
indirection. There's a lot of indirection and abstraction that is done
prematurely because it's the "smart" thing to do, but reflexively doing the
"smart" thing is pretty stupid because often the "dumb" thing is more elegant
and easier to use. That's called cargo cult programming, which seems to be
business as usual in typical Java codebases.

~~~
ralfn
>Haskell and Lisp developers have more in common with each other than with
"best practices" Java developers.

Like in actual politics the emotion and the response, do not always match up
rationally. That's why its called an emotion.

For example, preventive wars do not make one safer. But they sure make you
feel like you are safer. Going out there, dealing with potential threats.

Likewise, Java can be very dynamically typed (depending on your perspective),
yet feel 'conservative' (stick with what we know). Haskell is very statically
typed, yet feel 'progressive' (explore new grounds).

Emotion is not an intentional thing, therefor its application is never
rational.

To get back to real politics. If a person is both sane, yet fearfull of his or
her security, they would not want a bigger military machiene, they would want
a bigger worldwide PR machiene.

I tend to put the two extremes differently though: a liberal fears being
wrong, a conservative fears being right. Which is why progressives go out of
their way to be right, and conservatives go out of their way to be wrong. (jk)

------
nirvana
I first noticed something like this, though I draw the lines differently, in
the 1980s.

What's interesting is that there has been a shift over the years to where
"programming" has come ot have a strong ideological bias to only one type.

The types I noticed then I call Cowboys and Architects. These are just terms
I'm using for convenience, not meant as pejoratives.

Cowboys are now more common: Some programmers write a bunch of sloppy code
without bothering to ever design anything. Their methedology for making a
product seems to be akin to bashing to the code into the shape it needs to be
eventually. This group of people tend to advocate policies that assume
everyone else is writing crappy code as well- unit tests, agile, etc. For
instance, agile rejects design and assumes you can't know what the right shape
for the code is going to be more than a week in advance and that all code is
maleable without repercussions.

Architects are now rare: Other programmers will sit for a week and think
without writing any code. When they do, they sit down and over the course of
an hour (or however long it takes to type it) will write out the code for the
complete system or module. It will be bug-free with the exception of typos.
Once the typos are fixed (Generally by getting the compiler to accept the
code) the programmer can move on to implementing the next bit of
functionality. Sometimes there are errors in the code working with other code,
generally integration errors, but not errors in the thinking of the
programmer. These programmers only accept that Agile makes sense because the
business side of things can't make up its mind, so they architect core systems
that are flexible to support multiple business needs, but don't need to be
rewritten or bashed around, because they did it right the first time.

I'm of the latter type, and I have tested this objectively, by producing a
10,000 line iOS App like this, which has been in use for several years by tens
of thousands of people with no crashes or other defects (a few minor
conceptual bugs- mismatch between the features and the expectations of the
business, which were fixed)... and not a single unit test. It compiled, it
worked, and almost all the development time was spent on the UI. It has had
major releases (eg: going from being iPad only to a universal app, etc.)

It has built in reporting for exceptions, and all of the reported exceptions
are the result of things other than my code (eg: there are several situations
where iOS will crash an app if it needs to or due to problems with pre-release
versions of iOS, and those are what generate the exceptions.) No customer
reported bugs either. (though they do have requests for things working
slightly differently and new features, no programming errors reported by
customers.)

The industry is so dominated by a culture of "all code is crap" that I think
many people think that all programmers are cowboys and even Steve here is
delineating types of Cowboys, and nobody believes architects exist.

Can you imagine someone saying "unit tests are a waste of time, they just
double the amount of work with no benefit.". It produces a litany of excuses
for why this isn't true. ("You need them if other people work on your code!",
"maybe for a team of one", "you're assuming you'll never forget a design
decision", etc.) I know this message will get responses along those lines--
its because Cowboyism has become an ideology. Yegge is right - programmers are
ideological.

I'm not a savant and I'm not rare. Architects like me were about %50 of the
programmers out there when I started out. I think the mainstreaming of
"hacking" has produced a lot of people who are taught to be cowboys and a
culture that encourages cowboyism.

~~~
ryanricard
I am fascinated at the idea that you wrote a 10KLOC iOS app in the time it
took you to type it out. I had heard tales of programmers approaching the
design, implementation, and then testing of a program as totally seperate
steps, but only as a consequence of an environment that had severe technical
limitations (IE, I'm going to hand my "code" over to the typist who will input
it into the computer, which will then run it N hours later). To code in that
manner intentionally sounds totally bonkers to me, although I accept your
proposition that that may be a result of being raised as a Cowboy.

I'd love a series of technical blog posts about the iOS app. What artifacts
did you create during the design phase? How many Modules/Features did you
split the process in to (or did you do it _all_ in one go)?

