# The Art of Markdown
<The way this document looks in the raw
is intentional.
For a discussion of the intention,
Please see
https://github.com/anEXPer/texts/blob/master/the-art-of-markdown.md>

<The above comment is self-referential.
If you were to put it
in a different document
that looks like this,
it would not be.>

[comment]: # (The above two comments appear in the output html, though they are not rendered as text. This comment will not be, though it is clearly an abuse to utilize the reference-style link syntax this way, and though it would be a hassle to use a nice multi-line style in this format.)

There is a particular style
possible in formats where
whitespace is rendered out.
You can put each clause
of each sentence
on its own line.
Of course it is possible to put each sentence, and all its clauses, on a line.
Should you?

The basic unit of git is the line.
The basic unit of prose is the sentence.
What is the basic unit of code?

I suppose it's either the line, or the function.
Which is more like a sentence?
Which is more like a clause?
What is wrong with this comparison,
and is there a better one?

So perhaps you should put each sentence on its own line.
But some sentences are very long, and the benefits of matching sentences-as-the-units-of-prose to lines-as-units-of-git begin to erode.
So, maybe you can then break up the lines
without breaking up the clauses,
as I initially suggested.

Alternatively, you could avoid writing sentences like that.

Either way, you can achieve something special.
Prose becomes more like code
when you use tools designed for code
and let them shape your choices.
This may not be immediately recognizable as a benefit.
With prose as with code,
readability is essential to industrial use.
With prose as with code,
smaller functions/sentences are easier to understand.
With prose as with code,
asking yourself the questions about structure
meant to drive decisions about line breaks
may inform and drive other decisions about what you've written,
as well.