
Responsible Open Source Code Parenting - fogus
http://www.codinghorror.com/blog/archives/001317.html
======
dasht
Atwood's blog post is an example of why I sometimes say that the main point of
inventing "open source" was to turn the free software movement into the gratis
labor movement.

Atwood's account of history here is misleading, judging by the mailing list he
quotes. He is unfair to accuse Gruber of being "passive aggressive". I'll talk
at the end about why the accusation is part of the gratis labor movement.

The discussions started in February of 2008. Joseph Lorenzo Hall asked if
anyone has considered forking Markdown.pl "hopefully with Gruber's blessing".

In reply, Tomas Doran mentions that maintains a CPAN module called
Text::Markdown and that he would like this to be the fork or, "if [he] can get
John to agree and approve - [to] become the 'official' maintained version
which is linked from daringfireball [Gruber's web site]."

In short, the question arose which we can paraphrase: "Would Gruber give his
name to bless Text::Markdown as the successor project of his earlier work?"

Gruber responded fairly directly that he does not like the way Doran has
maintained Text::Markup (and he gives technical reasons why). He asserts that
he would not like that to become the 'official' version of Markup.

From that, Atwood somehow gets "passive aggressive".

Why is that a "gratis labor" play? Atwood asserts that Gruber now has a
problem and that he would not have that problem if between 2004 and 2008 he
had given away labor to manage an open source community. That Gruber did not
give away such labor makes him a "negligent parent". Evidence of the bad
parenting is to be found in Gruber's alleged bad attitude, visible in his
"passive aggression".

We ought to ask what effects such pronouncements have, especially coming from
a prominent blogger. I can think of two that are quite conceivable (and jive
with my own experience): First, let's suppose that Gruber decides to apply for
a job somewhere and happens to mention on his resume that he has some
experience with free software or "open source" projects. Recruiters are often
advised to scan for articles like Atwoods to weed out (or in) resumes. In this
case, the accusation that Gruber is a "negligent parent" with a bad attitude
hurts his chances of getting hired. It especially hurts that this accusation
comes from Atwood. Second, consider what happens if Gruber wants now to start
a project and solicit public volunteers. The first time he makes a project
decision someone doesn't like, there's every chance that someone opposed will
say something like "This is no different from how Gruber handled Markup.pl. We
should just fork away from him and move on." Yes, that kind of thing really
happens.

So the Atwood's of the world are creating and helping to enforce a set of
social norms within the so-called "open source community" in which failing to
give away labor upon demand, or standing up for a technical decision when it
is inconvenient for others - these are grounds for marking and ostracism.

Quite absent from Atwood's hit piece is any consideration of _why_ Gruber was
inactive on Markdown.pl for those years or _why_ declining to endorse Doran's
fork might be quite appropriate. Atwood just wants to generate some smoke, it
seems.

Turnabout is fair play? Perhaps Mr. Atwood should next answer the question
"When did you stop beating your wife?" (
<http://en.wikipedia.org/wiki/Loaded_question> )

~~~
nollidge
> From that, Atwood somehow gets "passive aggressive".

That confused me too. Exactly how is "I despise what you've done with
Text::Markdown" passive?

~~~
codinghorror
that's the "aggressive" part. The passive part is doing nothing (in public,
anyway) for five years.

------
ElliotH
Not to be too harsh on Jeff Atwood - as he has decades more experience than
myself. But does anyone else feel that this blog post is a bit out of line?

In short when John Gruber gives the code out under a BSD thatis a gift to
whoever wants to use it - and it gives them near-complete freedom to use
Markdown however they like. I don't see why on top of this gift he is in any
way obliged to provide 'leadership' or 'direction'. I don't really see why its
even required. Anybody can feel free to come in, fork the project with their
own modifications - and if its popular then they can be the leader or their
fork.

~~~
algorias
When you release code, there's an implicit commitment of improving and
maintaining it, or at least finding someone who will when you can't anymore,
unless you say otherwise from the start.

The attention and effort others invest in your project needs to be respected.
You _do_ have an ethical obligation to follow through on the project, at least
in my view.

Feeling no obligation towards your user base just because one of the price
dimensions (money) happens to be 0 is an irresponsible attitude.

~~~
boucher
Have to disagree. Releasing code doesn't imply any obligation to that code. If
it did, the volume of open source code out there would be a fraction of what
it is right now.

People are constantly changing directions, and constantly trying out new
things which may or may not be useful to them in the future. We're all better
off if that code gets released. In turn, we can't expect people to support
code they may no longer use, or may not have ever really cared about in the
first place.

It should be clear that running an open source project is something completely
different. If you make an attempt to _start_ a community, you probably should
keep up with that community, or at least responsibly exit it. But people
usually build communities around things that are really important to them, or
that they have an ulterior motive for advocating (not necessarily a bad
motive, just one beyond pure open source).

From where I'm sitting, if Gruber isn't adding anything to the community, he
should have been made irrelevant by that community.

~~~
algorias
You're right that there needs to be a distinction between community projects
and loose pieces of code. They're completely different in nature, and that's
why it's so important to make clear which is which.

------
ihumanable
The idea that since markdown hasn't done anything in years its somehow being
stewarded improperly is a bit foolish. Look at Gruber's vision statement, he
wanted to make an easy-to-read easy-to-write markup.

He did it, it is done, it's called markdown. If Atwood had his way Gruber
would have spent the last 4 years filling it up with features and today we
would be reading a post about how Markdown went from slim and sleek to fat and
bloated.

------
sfk
Markdown is _not_ John Gruber's baby, it is an open source project. Stop
anthropomorphizing everything in order to make a cheap point.

~~~
daleharvey
Open source projects are usually someones 'baby', democracy is nice and all
but experience suggests that open source does best with an 'owner / leader',
if the owner/leader isnt committed, then the project flounders until someone
else takes their place.

a highly visible blog post criticising gruber isnt the way to move forward
though, email your issues offline, maybe offer to take 'leadership' of it if
gruber is too busy, and if it seems gruber wont relinquish control, but wont
help the project either, then fork.

the cathedral and the bazaar is a pretty interesting read on the politics of
open source

~~~
thwarted
Open source projects are not someone's baby unless someone claims them as such
and takes their development personally. Having a leader on a project is nice,
but not all source code needs a leader, and not all projects flounder without
a leader. And just because development is stagnant on a popular project
doesn't mean that it's floundering either.

It seems that the "official" version is 1.0.1 and is available as a zip file
on daringfireball. The license file doesn't say anything about Gruber being
against someone else maintaining it, or forking it, or whatever. Nothing is
stopping anyone, or everyone, from importing the code into github and people
maintaining it there. Considering the recent comments on this submission
<http://news.ycombinator.com/item?id=1017698> it only makes sense to put it on
github, where everyone can contribute or fork _and_ make it easy for control
of the _conceptually_ "official" version change hands.

------
billpg
"Item #3, the conversion of returns to linebreaks, is somewhat more debatable.
I'm on the fence on that one, but I do believe it's significant enough to
warrant an explicit choice either way."

Really?

Has anyone ever typed stuff, hit enter once, then typed more stuff, ever _not_
intended a line break?

"Oh no, I kept hitting Enter between words instead of using the space-bar! If
only pressing Enter was interpreted as a space character unless it was
prefixed by four spaces. What a world! What a world!"

~~~
telemachos
I'm not sure of the origin of the convention, but using two newlines
consistently to mark new paragraphs (rather than indentation or just one
newline) seems awfully common to me in technical writing. So the Markdown rule
has always made sense to me. Or to put it another way, it was immediately
natural to do it that way.

 _Edit_ : to answer the question of the comment below this, poems need to be
handled specially in Markdown as in HTML. It's an issue more generally, and I
think that the standard solution is <p> for the poem as a whole and <br> (or
<br /> depending on your markup flavor preference) for the lines. It's a known
thing: <http://blog.signified.com.au/a-poem-element-for-html5/>

~~~
nollidge
But what if you want a newline for a reason other than for paragraphs, like a
poem or something?

~~~
technomancy
Then you end the line in two spaces.

~~~
StrawberryFrog
How obvious!

------
sjs
I'm all for the first 2 proposed changes. They would very welcome by almost
everyone. But that 3rd idea.... oh boy.

> It should be a standard configurable option in every Markdown implementation
> that you can switch on or off depending on the intended audience.

I hope Atwood never actually tries this. Markdown should not have any
configurable options. Any attempts to augment Markdown like this should be
clearly labeled as such. One way or the other the spec should make a single
choice and stick to it. If someone wants something different they should
create something different and use it, rather than confuse people who use
"Markdown" on several sites and have to remember which options each has. ...
yuck!

------
gfunk911
1\. This article is a bit too personal, 100% agree on that.

2\. The best thing Gruber could do is pass on "ownership" of the project to
someone else. He is under no obligation to do so, but it seems like that would
essentially solve the problem, while requiring almost no effort from him.

~~~
tptacek
What's the "problem" here? The bugs Atwood is talking about are minor, and
their solutions don't require drastic incompatible changes to Markdown-the-
language.

The issue here is that Gruber seems to be satisfied with Markdown-the-
language, and Atwood (and many others) aren't.

Obviously, Atwood could just create a new markup language derived from
Markdown (like MultiMarkdown). But then he can't call it Markdown. He wants
the best of both worlds, and he's not going to get it. And that's his problem,
not ours.

~~~
joeyh
The underscore bug sounds minor, but is not.

The problem with this bug is you can start with something that works just as
you would expect, like "HTTP_PROXY is a CGI variable".

Now you go back and, edit the sentence: "HTTP_PROXY and REQUEST_METHOD are CGI
variables". Suddenly, and in violation of Least Suprise, markdown spits out
text that has a em tag between the two underscores.

So, in practice, you have to remember to always escape underscores, so you
start with. "HTTP\\_PROXY is a CGI variable" and never run into the problem.

Except now you have to keep this arbitrary rule in your head, and remember to
do it all the time, and you end up with something that does not look like a
plain text email; it's obviously marked up now. Which rather defeats the point
of markdown.

~~~
tptacek
The change required to fix that glitch is so _not_ drastic that many (most?)
Markdown implementations have silently applied it already.

------
pkaler
The way that Atwood quotes the mailing list is irresponsible.

Please read this message: [http://six.pairlist.net/pipermail/markdown-
discuss/2008-Marc...](http://six.pairlist.net/pipermail/markdown-
discuss/2008-March/001188.html)

1) Gruber states that he doesn't have time to update Markdown. 2) Gruber
states that any fork of Markdown should be clearly stated as such.

End of story.

Gruber could respond with a post titled "Responsible Forking". Hopefully,
Gruber just ignores Atwood and spends his time and attention on stuff that
actually matters.

------
kragen
Jeff wants Markdown to make a bunch of backward-incompatible changes that
would change the interpretation of existing Markdown documents. It doesn't
matter if Jeff is right that the new language would be better than Markdown;
changing the spec in this way would still be an act of vandalism, because it
scribbles all over the pages already written in Markdown.

I think Gruber is providing admirable leadership and direction by not making
backwards-incompatible changes to the spec and smacking down people who want
to do so.

------
michael_dorfman
I don't understand why the term "fork" didn't appear in Atwood's article.

It's the simplest solution to his problem.

~~~
lutorm
It did appear.

~~~
michael_dorfman
Only in a quoted passage, and Atwood didn't engage with that portion of the
quote.

------
telemachos
This isn't directly relevant, but if you use Markdown a lot, I highly
recommend David Parson's Discount (a Markdown implementation in C). (Parsons
is also active on the Markdown mail list, which is helpful.)

<http://www.pell.portland.or.us/~orc/Code/discount/>

~~~
nostrademons
I'll put in a plug for Pandoc here:

<http://johnmacfarlane.net/pandoc/>

It's written in Haskell, it uses a real parser, it fixes several bugs in the
spec, and it can output to nearly any format imaginable. What else could you
want?

~~~
sharkbrainguy
I found this really handy (from PLT scheme)

<http://github.com/toyvo/libpandoc>

    
    
      "a build configuration for Pandoc that produces a standalone C-callable system library"

------
Chickencha
This is the nature of free software and a big part of why free software is
great. Sometimes a maintainer can no longer work on a project for a variety of
reasons. A free license makes it pretty easy for someone to fork the project
and take over development.

It would be nice if John Gruber opened up the contribution process or
officially handed off development to someone else, but he's under no
obligation to do so. We're not paying him. He probably started Markdown for
his own purposes and was kind enough to release it under a free license. It's
totally fine if he doesn't want to continue work on it, because I can easily
take his code, check it into GitHub, and start my own fork.

