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.
You're not being too harsh. Atwood's decades of experience is no excuse for what is essentially a personal attack, nor should it be a defense when you call him on it.
If Gruber had released markdown and explicitly walked away from it, then yes, we would only be justified in appreciating his gift.
(And I think anyone seriously using markdown has to conclude he did essentially release and walk away from the perl implementation. Aside from it being 6 to 12 times faster, there is no reason now to use it rather than the Text::MarkDown in CPAN -- which fixes its many, many, crippling bugs and maintains perfect compatability.)
However, somehow or other, we've gotten the idea that Gruber is responsible for at least the ongoing development of the spec. Atwood excerpts a recent mail from Gruber where he's clearly still trying to do that. I sorta get the impression Gruber wants to keep the markdown spec exactly as it is, although the last time he surfaced on mailing list it was to say that a proposed addition looked like a (rare) good idea.
At least the internal underlines issue makes markdown a real PITA to use for any technical writing, and really needs to be fixed in the spec. The URL thing is debatable; while Atwood's newline suggestion misses the point of markdown. The risk is clearly that markdown will fragment with different sites handling these issues differently. There are many better ways to manage specs than what Gruber is doing.
Not harsh at all. IMO, the kind of attitude that equates the responsibility to maintain your open source projects to the parenting of a child is one thing which scares people from contributing to the open source community.
By the way, what's with the assumption that github is the one true way? Is it that much better for you? I have code on Github, SourceForge, google code and while Github has some UI goodess, the windows tools for it are quite raw. The others also work fine. If you like DVCS, Sourceforge and Google code both do Mercurial
Github's strength is that it allows for incredibly easy collaboration. If you want to make a change to any open source project, you just need to fork it, make changes in your copy, and send a pull request to the original author. Neither Google code nor SourceForge offers such a simple contribution mechanism.
I haven't participated in any Github projects yet, so forgive me if I'm missing something, but isn't what you're describing a part of DVCS (Distributed Version Control Systems) in general, and not Git per se? (and, least of all, GitHub?)
Couldn't one do what you're describing with a Google Code project that uses Mercurial? Or at bitbucket.org using Mercurial? Or at launchpad.net using Bazaar?
I don't think StrawberryFrog's question has been adequately answered: "what's with the assumption that github is the one true way?..."
I don't think anyone said GitHub is "the one true way". I think you'll find more and more people putting code on GitHub, because of the general uptick in contributions when code is hosted there.
I don't think anyone said GitHub is "the one true way".
I'm pretty sure the question was meant a bit more loosely, not as a direct challenge to someone's post here, but to the general prevalence of a meme that roughly fits that description. I certainly wouldn't suggest grepping for that phrase as a method of getting a feel for its virulence out "in the wild".
Instead, look or tacit assumptions, misattribution's of value, and conspicuous omission of alternatives. I guess good, old-fashioned "reading between the lines" is what I'm suggesting.
A pretty dramatic illustration popped up on my RSS reader this morning. Someone submitted a HN article with the title "Jeff Atwood's open source contributions", which was nothing but a link to http://github.com/codinghorror - which currently shows zero projects. It was quickly flagged here at HN, but it lives on over at Reddit.
The tacit assumption here is that if Jeff has zero repositories at GitHub, then he has made zero open source code contributions.
I don't mean to detract from how cool it is that your product is so successful. (Kudos!) But its fans often have a creepy blind spot to alternatives, in my opinion.
Full marks for getting to the core of what I was asking. It seems almost like a year ago nobody had heard of github; and now there are people who don't seem to have heard of anything else.
Not to take away from GitHub being good, but I'm asking what makes it seems that good.
I put a new code on Github and it seems all right. But I'm not going to move code that's been hosted elsewhere for several years even if something slightly better comes along. Consistency is a virtue.
I don't think anyone said GitHub is "the one true way".
No, I don't think anyone did. pohl's comment that it's meant about "the general prevalence of a meme that roughly fits that description" is about right.
because of the general uptick in contributions when code is hosted there.
Github is a slick and friendly home for open source, even if the Windows Ui tools for git still need a lot of polish. But do you have numbers to back that idea? It could well be true, who knows.
My guess is that this article is a precursor to doing just that. I expect an announcement from Jeff pretty soon about a new markdown project on Github. I don't agree with his point of view in this article, however it does sound like he knows the project pretty well and would be suited to getting it rolling again.
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.
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.
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.
If everyone thought this way, many really great projects would never have been started, because their authors would be so bogged down by maintenance work they'd never do anything new. Take a look at John Resig's projects page:
Click on anything that's not a JavaScript project, and you get a broken link. Would you rather he spend time fixing them up, or would you rather he spend time improving JQuery?
If your code is meant to be an experiment, a headstart for someone else to build on, then that needs to be explicit. There's enough open source code out there. The problem is quality. All projects that are making an impact are doing so because they are actively backed and developed.
It's great that this guy works on JQuery, but I think the minimum that should be expected is to properly tie up loose ends: Fix broken links, make sure it's clearly stated that the code in question is considered done (feature complete, unmaintained, etc). Officially hand it off to someone else if possible.
You don't know what's an experiment and what's a massively successful library until you release it. JQuery was initially intended to be the experiment; presumably he had other projects he was working on at the time that were supposed to be his "real" work.
There're a bunch of counterexamples to the "all projects that are making an impact are doing so because they are actively backed and developed." Markdown is one obvious one. The Internet Explorer team was disbanded from 2002-2005, even though it was the most popular browser on the market. Several Google projects that are used by millions of people a day are completely de-staffed.
And there are many more projects that are actively backed and developed and yet are not making an impact. We'd be much better off if their developers quit what they were doing and found something else to do.
I don't think that's fair. I think "when you SELL code", there's an implicit (and usually explicit) commitment to improve/maintain it, but not when you give it away. When someone buys me a Christmas present, I don't go to them to repair it if it malfunctions.
Besides, the Markdown license explicitly says it's "as is" with no such support promises.
I don't think you can even call Markdown users Gruber's userbase. He created Markdown because it works for him. If you don't like how it works, change it and call it something else (MarkSide? MarkIn? MarkOut?)
If you say you'll help someone out, then you better show up. Otherwise, you'll leave the other guy worse off than if you hadn't offered to help in the first place.
So, yes, it is better to release nothing than something buggy and unsupported. The former doesn't waste everyone's time pretending to be a solution.
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.
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
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.
It's not a collaborative project in any way -- Gruber does not accept contributions and repudiates forks + reimplementations. His Markdown.pl implementation is dogshit even by the already low standards of hand-written many-pass regex-based spaghetti-parsers.
"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!"
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/
I always just indent poems 4 spaces, making them into preformatted text.
In published work, poems are usually set apart from the prose and rendered in a different font anyway, so this seems natural enough to me. Courier isn't exactly my first choice for a poetic font, but it's good enough and gets the formatting across.
"Oh no, I'm trying to paste this block of text from an email and it thinks every line is a new paragraph!"
Besides, Markdown was designed to be readable as plaintext and test written with the expectation that single return -> linebreak is not easily readable (unless people are in the habit of indenting the first line of their paragraphs.
Very much so. One of the cool things about markdown is it looks good in source form as well as after processing to HTML. In order to keep that looking good you of course keep your lines to under 80 characters. That makes sense in fixed width ASCII but no so much once it's gone to HTML.
Yes, I have. When you hit alt-q in emacs, you do, too. It goes with the theme of "making it look like you write ascii files". Have you never tried to read an ascii file that's written without line breaks in an xterm?
When programming, do you never cut lines with enter except after the semicolon either?
When writing code, I hit enter to add a line-break in order to make the code look nice. I would consider it a bad thing if next time someone looked at the code, those line-breaks were removed and changed to spaces, even if the code was technically equivalent.
Compilers (except maybe Python) don't care about layout.
> Has anyone ever typed stuff, hit enter once, then typed more stuff, ever not intended a line break?
Yes. It makes diffs of version-controlled documentation far, far more readable (and efficient).
^Q in TextMate does it for you, so it's not even much extra effort. Type your paragraph, ^Q to wrap it to 78/80/whatever characters. I think someone else mentioned that emacs has a similar feature, and I'm sure vim does too.
(Edit: I think I was a bit rash in this message, stemming from my sense of sheer disbelief. While I stand by my overall point, I would like to apologize for my tone.)
Really? I can't recall the last time I saw a multi-line text box that didn't word-wrap.
That may have made sense back in the day when TEXTAREA form elements didn't wrap and there was no way to switch the wrapping on, but its been over 10 years since that was the case. Do people still do that?
Even in the presence of people needlessly hitting enter because they don't realise the input box will word-wrap, the effect of doing the-wrong-thing still seems preferable with turning enter key presses into line breaks.
The worst that happens
when you hit enter at
the end of the input
box is a narrow column
of text.
If you expect hitting Enter to result in a line-break, doing the-wrong-thing results in text being wrongly joined together into one paragraph.
Fair enough. My point would be that if people are still doing that, they don't have to anymore.
Also, my earlier response was written a little rashly, stemming for my sense of sheer disbelief. While I stand by my overall point, I'd like to apologise for my tone.
I agree. This is frustrating in many markup formats. A carriage return should turn into a br tag and two carriage returns should start a new paragraph. Simple, intuitive, where's the problem??
IMO any situation where that behaviour is undesirable is an edge case and should require more effort to work around.
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!
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.
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.
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.
Why should Gruber pass on "ownership" in the absence of a prospective owner who's work on the project he likes?
What "problem" would be solved here other than the problem that Atwood is bad-mouthing Gruber, apparently to force him to pass on "ownership" or at least to make Gruber into a negative example for others?
Isn't the better solution to that "problem" for the rest of the libre software community to disapprove of Atwood's defamatory statements about Gruber?
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.
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.
I suspect the word "fork" was deliberately excluded from the article because it would be less provocative. Atwood appears to be more interested in starting controversy than actually solving problems.
[edit: Ok, so it does appear in the quote taken from a mailing list, but Atwood does not explicitly address the idea.]
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.
Given your history behind the quote, it sounds as if Atwood found the quote to fit the judgment of the situation that he already had, rather than vice versa.
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.)
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?
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.
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.