evolving the spec (was: forking Markdown.pl?)

[Aristotle Pagaltzis]

* Waylan Limberg <waylan at gmail.com> [2008-02-29 17:00]:

> As implementors, we want a strict spec because it's easier to

> implement, but that does not always result in easier to read

> and/or write.


You have “strict” and “simplistic” confused. If the spec for the
syntax is rigorous that does not mean the syntax has to be rigid.

It just means it is well-defined how an implementation of
Markdown should parse particular constructs. That has nothing
whatsoever to do with the flexibility in the syntax.

The current syntax summary leaves a lot of grey areas where you
could reasonably do any of several things. The upshot is that the
whenever someone implements Markdown from scratch, most likely
his implementation *does* do something other than the reference
implementation for that case. And experience confirms this.

Therefore, I don’t quite follow this argument:


> Now, before you all write me off as insane, this is actually

> why I think Markdown 2.0 is a good idea. By moving to 2.0, we

> don't have to worry about backward compatibility (Markdown 2.0

> should not allow those 3 spaces).


You *already* can’t move documents from one implementation to
another without expecting breakage. Heck, you can’t move them
from one version of an implementation to a newer version of the
same implementation without expecting some breakage.

The question is, how much breakage would conformance to the more
rigorous spec cause?

If it isn’t much: do you think any users will care about the
subtleties of Markdown 1.0 vs Markdown 2.0? Don’t you think
they’ll blithely grind their Markdown 1.0 documents through a
Markdown 2.0 processor if this works most of the time?

If it would cause a lot of breakage: isn’t that maybe because
a lot of people actually like this “unintended feature”? Does
that not possibly mean that it’s worthwhile to try preserving
as an actual feature in the spec? (If several implementations
have the same accidental feature, particularly?) Remember, it’s
always easier to change the spec to fit existing fact rather than
the other way around. (Cf. HTML5.)

Now if you insist on causing so much breakage that people
*cannot* just grind their 1.0 documents through a 2.0 processor:
what do you expect does this imply for the adoption of 2.0? Don’t
you think it would rather cause a lot of people not to “upgrade”
the way they did with XML 2.0 and Windows Vista? Some upgrades
those were.

Now turn around and consider the two calls you make in relation
to each other. I don’t know about you, but it seems contradictory
to me that first you argue for a spec that allows documents to be
written in a very lax syntax, then turn around and backward
compatibility should be abandoned so that we can have the freedom
to reduce the flexibility of the syntax.

Regards,
-- 
Aristotle Pagaltzis // <http://plasmasturm.org/>