
Org-Mode Is One of the Most Reasonable Markup Languages to Use for Text (2018) - funkaster
https://karl-voit.at/2017/09/23/orgmode-as-markup-only/
======
lucideer
> _Org-Mode Makes Sense Outside of Emacs_

... goes on to name one tool (pandoc) that parses Org-Mode (and also parses
Markdown. I would in fact guess pandoc is used much more often for the latter
than the former).

> _Org-Mode Has Excellent Tool Support_

> _this is not an article about Emacs_

... goes on to describe the "tool support" in Emacs. Sorry, but the paragraph
title here really implies we're going to be talking about a _range_ of tools,
not just Emacs.

And then to conclude:

> _With this blog article I wanted to point out the usefulness of Org-mode
> even when you are not using Emacs as an writing tool._

Can anyone point me to where exactly in the article the author has done this?

Org-Mode is great if you use Emacs. Try installing the Org-Mode addon in your
non-Emacs IDE of choice, and you'll hit the same "partially implemented/not-
yet-supported/etc." issues you would using an obscure markdown parser. In this
regard, Markdown is much more "standardised" than Org-Mode—a standard exists
for both, but the level of adherance to that standard in terms of the total
number of parsers out there is undoubtedly higher for Markdown.

~~~
jillesvangurp
Org-mode looks very similar to markdown. Almost so that I would call it
pointlessly different.

The word standardization gets abused a lot in our industry. Usually it implies
something that 1) has a non ambiguous specification, 2) is widely used. 3) is
endorsed by some standards body or cross industry organization or simply so
widely used that it effectively is a standard 4) has multiple independent
implementations (tools, parsers, websiters, etc.)

Org-mode has a specification
([https://orgmode.org/);](https://orgmode.org/\);) is at this point in time
not widely used; has not been endorsed or proposed to a standards body like
e.g. w3c, ietf, etc.; has a very limited amount of implementations. Declaring
it a standard is meaningless until that is fixed.

The Github flavor of markdown has a decent specification
([https://github.github.com/gfm/](https://github.github.com/gfm/)), many
implementations of e.g. parsers for different languages, many
websites/tools/etc. using it. It's not at this point a formal standard but the
previous makes it more or less a de-facto industry standard that is widely
used, with a reference OSS implementation and many other parsers aiming to be
compatible.

If you are implementing markdown support, you could do worse than pick this
flavor. Several other flavors are equally well specified, have similarly good
tool support and industry endorsement, and might very well be considered
standards in their own right.

Of course, like with Json, there's a long tail of not so great parsers that
have implementation specific bugs/quirks/omissions/features, etc.

~~~
throwanem
I agree that Org-mode and Markdown are pointlessly different! The latter has
no excuse for existing, given that the former both long predates it in time
and vastly exceeds it in power.

~~~
SmellyGeekBoy
One could say the same about Usenet and Hacker News. Yet here we are.

------
setr
>org-mode is standardized

Last I looked into it (mainly with interest for vim), few if any
parsers/tooling exist for it outside of emacs; as I recall, people claimed
that it apparently has sufficient (undocumented/poorly specified) quirks in
the emacs implementation that 100% reproduction is difficult; similar to
implementing vim-mode for editor plugins

In which case, its only as standardized as the one implementation; which is
exactly how standardized markdown started with (the perl implementation)

~~~
terhechte
Came here just to say that. I had a static blog written in org-mode and
converted it over to markdown a couple of weeks ago because there's no good
way of converting org-mode to html except by running emacs. So for each
article, getting a html representation requires firing up emacs. That's
insane.

If there were good (and fast!) js, c, python, etc libraries to fully support
parsing org-mode to AST and HTML, only then would it be a viable solution for
markup.

~~~
s7atic
Emacs can run as an elisp interpreter, check out the '\--script' switch. This
makes it possible to run org-export without starting an emacs session.

~~~
kqr
I was just about to say. The GP sounds like they're saying

> there's no good way of converting <markup language> to html except by
> running <preferred converter>. So for each article, getting a html
> representation requires firing up <preferred converter>. That's insane.

~~~
terhechte
And how do I use that when I want to interactively convert org-mode to html in
javascript? Like countless pure-javascript markdown libraries allow me to do?
not to mention the security hazards of running emacs with any user input from
a website.

~~~
kqr
That you don't – much like you don't get Pandoc Markdown in JavaScript,
because Pandoc is not written in JS.

But if you are content with a less featured variation of the markup language
(but still more featureful than Markdown), you can get that for JavaScript
too:
[https://xiaoxinghu.github.io/orgajs/syntax](https://xiaoxinghu.github.io/orgajs/syntax)

------
JonAtkinson
The authors argument that Markdown should be discarded because there are
several competing implementations isn't valid.

For many years (even now), we have several competing implementations of HTML,
yet the HTML document is the dominant presentational document format (and UI
layout language). It hasn't done anything to hurt adoption.

The fact that Markdown does have a common subset of features, and that
Markdown is widely interoperable with a vast amount of products is why it
wins. As far as I can tell Org-Mode markup is used within Emacs and really
nowhere else.

~~~
mort96
The argument isn't that Markdown is bad because there are competing
implementations. The argument is that Markdown is bad because there is no
standard for those implementations to adhere to, so they end up being wildly
incompatible. With HTML, there will be browser differences, but there's a
pretty well-defined standard which browsers try to adhere to; there will be
bugs, but at least you can know you're writing standards-compliant HTML, and
then work around particular browser engines as necessary.

You say Markdown has a common set of features, but what is that common set?
There's no standard, and I find myself surprisingly frequently struggle with
figuring out what's the correct way in a particular markdown engine to do what
I need to do.

An example is that in Reddit's markdown; this text:

    
    
        ```
        if (true) {
            console.log("hi");
        }
        ```
    

will all end up as inline code, with all the newlines and extra whitespace
stripped out. The correct way to do it in Reddit's markdown is to hit the
space bar (n+1)*4 times before each line, where n is the indentation level.
Some (but presumably not all) other markdown engines would render it as a code
block.

Markdown engines are also wildly inconsistent about when they treat something
as a link, and whether they require a blank line between a paragraph and code
blocks or lists.

They seem to mostly agree about how explicit links and bold and emphasis and
headings work though, so if that's your consistent common set of features, I
suppose you're right.

~~~
cfv
Commonmark ([https://commonmark.org](https://commonmark.org)) exists, has a
fairly well defined standard, and the reference implementations are not hard
to reason about. They are part of several thousands of larger codebases right
now, too.

Org-mode on the other hand is basically an emacs thing that has never been
seen in the wild outside maybe as a pandoc input? Which is coincidentally
another tool I almost never actually use by itself. And I have literally no
idea how ota reference implementation works or on which languages could I
embed it and how.

I'm pretty sure my experience isn't that rare too.

~~~
AlexCoventry
> _an emacs thing that has never been seen in the wild outside maybe as a
> pandoc input_

There are a couple of vim plugins. I don't know whether they're any good.

[https://www.reddit.com/r/vim/comments/4ms4z0/org_mode_which_...](https://www.reddit.com/r/vim/comments/4ms4z0/org_mode_which_plugin_to_use_vimorganizer_or/)

------
lifthrasiir
After considering two or three dozens of different "lightweight" markup
languages (i.e. not flavors) and designing a few (plus at least three failed
attempts to improve Markdown), I'm now almost convinced that Scribble [1] or
Perl POD [2] have one of the best possible designs. Not that they are optimal,
but they are definitely heading at the correct direction.

They are extremely generic: every Scribble syntax is prefixed `@`, every POD
construct is either `letter<...>` or `=word`. And yet they are surprisingly
unobstructive and readable enough. Compare with BBCode, which is also pretty
generic but too annoying.

They are readily extensible and need no special one-off syntaxes for most
things. Yes, using asterisks or underscores for emphasis is handy, but how
about strike-throughs? Underlines? Non-emphasis italics (e.g. species name)?
Language tags? Abbreviations? Do they nest? Do they work in any context? Why
not adding some harmless options to the existing constructs? Syntax
extensibility should be one of the foremost concerns of markup language design
and they got it right.

Edit: I should stress that these concerns are only valid for writings. For
casual comments, less is better (ideally no-follow links and verbatim texts
should suffice).

[1] [https://docs.racket-lang.org/scribble/](https://docs.racket-
lang.org/scribble/)

[2]
[https://perldoc.perl.org/perlpod.html](https://perldoc.perl.org/perlpod.html)

~~~
astrobe_
Reading the comments here, it feels like people miss the whole point of
markdown.

Markdown's _raison d 'être_ is, "if you follow these conventions when doing
ASCII art formatting, the my program can transform this to HTML or whatever
other format".

The conventions being mostly the ones used in the pre-HTML email era, like
underlining headings with a bunch of ======.

Orgmode is completely different to that. Orgmode is an "outliner/GTD" at
heart, but this aspect has been buried under a ton of features.

Then if you want "prawfishunal qvalitat" advanced formatting, typesetting and
layout control what you really want is something like Latex. Yet another whole
different thing.

~~~
hyperion2010
The thing about org mode is that it has everything you need to do the full
fancy latex typesetting without loosing the ability to export to other formats
the way you do if you write raw latex. Of course there are times when you have
no choice but to duplicate a block if you are doing something really fancy,
but that is a fairly rare occurrence.

------
hollasch
If you haven't seen it yet, check out Markdeep: [http://casual-
effects.com/markdeep/](http://casual-effects.com/markdeep/).

Write in any text editor, and a tiny JS boilerplate turns it into nicely-
rendered HTML.

~~~
skullborg
The flowcharts are gorgeous.

~~~
lloeki
Check out [https://mermaidjs.github.io](https://mermaidjs.github.io) which is
less visual in plain text but much easier to write.

~~~
desas
PlantUML is a good alternative too and has a good jetbrains plug-in

~~~
Jach
I came cross PlantUML recently, it's so much more than a classic diagram tool.
I was particularly intrigued by their wireframe system:
[http://plantuml.com/salt](http://plantuml.com/salt)

------
sondr3
As much as it pains me, org-mode is no better than Markdown when it comes to
standards or implementations. There's basically just one de facto
implementation of it, and it has no specification or standard. There are
parsers out there, but all of them are lacking one or more of the parts that
make org-mode so great. Markdown shines with its simplicity, org-mode shines
with its extensibility. Want to use it like a Jupyter Notebook? No problem.
Want to use it as a spreadsheet? No problem. Want to write academic papers and
export it to LaTeX? No problem. Want to use it outside of Emacs? Well...

I've been looking for and at solutions for using org-mode as the markup
language for a static site generator, and none of the ones I find do what I
want. org-mode has a builtin exporter that can build whole websites, but it is
very barebones. The only real solution I know of is Hakyll with Pandoc, which
is what I'm playing with right now.

I wish we had something like CommonMark for org-mode, but the overlap of
people who use org-mode and don't use Emacs is probably extremely small, so
it's not like there will be competing implementations outside of Emacs.

~~~
kqr
Sorry, probably missing something obvious: what prevents you from using Emacs
instead of pandoc to convert Org to HTML in whatever pipeline you have going
already?

~~~
sondr3
Mostly that Emacs only exports to HTML without any context of the content, in
a blog you'd like to extract the metadata which org-mode doesn't, it just
exports the whole buffer as HTML. I've been thinking about writing a blogging
engine in pure Emacs Lisp, but I'm not sure if I'm that crazy yet :)

~~~
kqr
If at some point you want to feel what it's like to be that crazy, there's a
chance you'll find that it's actually not that crazy at all!

When I created the current iteration of my website[1], I started out just
adding some custom export formatting advice to the default ox functions. I
couldn't resist add some additional functionality, though, and it takes
refreshingly little work: There's one function that iterates through the Org
source files and uses the built-in Org functions to query the files for tags,
title, date, and so on. The result is memoised in a list, and then various
other functions iterate through that list to generate index page, tag listing,
and so on.

[1]: [https://two-wrongs.com/](https://two-wrongs.com/)

~~~
sondr3
Now this is intriguing to me, do you have any pointers for a setup like this?

------
enriquto
The day org-mode will reach the masses is when the tutorials about it do not
even mention the word _emacs_. Until then, it will inevitably be seen as a
thing useful only for emacs users.

~~~
mickael-kerjean
There's an ecosystem around org-mode that's developing. I made a client:
[https://demo.filestash.app/view/docs/tasks-
projects.org?shar...](https://demo.filestash.app/view/docs/tasks-
projects.org?share=hnorg) the project is also open source
[https://github.com/mickael-kerjean/filestash](https://github.com/mickael-
kerjean/filestash)

~~~
non-nil
There is indeed, and it's making me very hopeful for the future of org-mode.
Beyond Filestash (great work!) there's the somewhat similar org-web [0], Beorg
for iOS [1] and Orgzly for Android [2], all of which them leveraging the power
of org-mode without requiring anyone hitting M-x or C-c even once.

What Markdown has going for it is a much wider acceptance as a simple,
straightforward way to work with text. Especially on modern devices, users
with little or no coding background are successfully being lured into
(superior!) plaintext workflows by apps with a great UI, and appear to take to
it. iA Writer [A] and Bear [B] are two prominent examples of such apps, and I
can't see why they would be any worse (or less popular) apps had they instead
opted for org-mode behind the scenes.

This is what org-mode needs to gain widespread adoption, and I'm hoping we're
on our way there.

[0] [https://github.com/DanielDe/org-web](https://github.com/DanielDe/org-web)
[1] [https://beorgapp.com/](https://beorgapp.com/) [2]
[http://www.orgzly.com/](http://www.orgzly.com/) [A]
[https://ia.net/writer](https://ia.net/writer) [B]
[https://bear.app/](https://bear.app/)

------
kemitchell
Last I checked, and admittedly it's been a while, parsing full org-mode syntax
outside Emacs itself is a nightmare. It's essentially cloning whatever version
of org-mode you have in mind.

Not that org-mode's any less for it. I'm no longer a daily user, but I was,
for quite some time, to organization a particularly chaotic episode of my work
life.

------
agentultra
I really, really, really like org-mode. I've used it for more than a decade.
I've written self-published books with it. I use it for capturing ideas. For
writing Reveal presentation slides. My database of links. I use it as a
lightweight kanban board for personal projects. I use it for generating
technical documentation mixing graphs, code, and prose.

But most of that isn't possible without Emacs.

As a markup format I wish it was more widely used. The promise of org-mode is
that _text_ is the best format for storing your data in. However to properly
read more than the surface markup language of org-mode requires a significant
amount of software. And very few editors or software packages exist outside of
emacs work with it.

And so lacking any other features of org-mode it's markup language isn't any
more impressive or useful than any other and is more of a matter of
preference. It would be nice if more software packages supported the org-mode
markup syntax but I wouldn't say it's the most "reasonable," even given the
arguments in this article.

------
enitihas
Org mode is simply awesome and the only reason I open emacs these days. I
still haven't managed to find a software, free or paid, which has the same
amount of flexibility.

~~~
black-tea
Org-mode and magit were the reasons that I had to use emacs. Ended up falling
in love with emacs itself, though.

~~~
db48x
Magit does make pretty good bait.

------
wzdd
Might be time to plug my very orgmode-esque Vim plugin:
[https://github.com/nfd/disorganiser](https://github.com/nfd/disorganiser)

I recently came to the same conclusion as the article but was dismayed by the
performance of the popular Vim plugin (and wasn't ready to switch to emacs),
so I wrote a very, very minimal implementation which is enough to get me
headings, folding, tables (including formula solving, the syntax for which is
currently left as an exercise for the reader), unordered lists, dates, and
various other things.

It's very much a work in progress (in particular, the syntax files expect a
graphical Vim) but it's definitely improved my note-taking. Requires Python 3
support.

------
lloeki
While reading the thing I could not help but feel like what I'd call "sensible
markdown" is both very close and bijective to org syntax. The trouble comes
when I need to define what is "sensible markdown" which is a thing I never
attempted to do, but pragmatically works very well. It seems like it's
CommonMark + GFM (for tables, checklists, and syntax-aware fenced code blocks
mostly) + MarkdownLint[0], the latter enforcing stringent rules that makes
Markdown very consistent and portable as well as prune the nonsensical stuff
(like double space before newline or underline headings). It's fantastic to
use with VScode[1] or vim-ale.

Some pet peeves:

I really don't ever get the argument about Markdown URLS. Being able to do
both [](url) vs [][ref] is awesome (the latter I liberally use when writing
long form docs). If one finds it so annoying one would make the mistake like
three times and then it'd be burned into one's brain due to selective
pressure. Or just use [][ref] style (which is more readable anyway since you
don't have the URL right in the middle of a sentence).

Also, very personal thing but my brain seems to hate /italics/ as it branch
predicts into parsing that as a regex.

What drives me nuts though is all the variants and ad hoc syntaxes like JIRA's
or this very board's, which sit right in the uncanny valley of nonsense.

[0]:
[https://github.com/DavidAnson/markdownlint](https://github.com/DavidAnson/markdownlint)

[1]: [https://github.com/DavidAnson/vscode-
markdownlint](https://github.com/DavidAnson/vscode-markdownlint)

~~~
mickael-kerjean
> bijective to org syntax

To date, I haven't seen a flavor of Markdown that has a comment feature. I use
it extensively to hide all my notes that don't have a place in the final
exported document people will read.

~~~
tomcam
Some versions support HTML-style comments

~~~
lloeki
They may very well exist but I’ve yet to encounter one that does not.

------
xamde
AsciiDoc! As nice as org-mode syntax, but with "=" instead of "*". Also, has
code blocks so copy&paste is nicer. Also, has one giant document explaining
everything.

~~~
tmm84
My first love was AsciiDoc and it still is. I never got into markdown as much
as AsciiDoc because it did what I wanted which was to generate documentation
for software. However, when keeping track of stuff I am working on, snippets
of possible code and completion status, etc. then Org-Mode has my attention. I
have tried doing the same in markdown but most themes don't handle TODO as
gracefully as ones targeting org-mode.

------
zelly
I use org-mode often. It's a very intuitive way of structuring notes because
most things are hierarchical in nature and lend themselves well to infinitely
nested lists. It really pairs well with The LISP Way™️.

I use it to make flashcards (csv format for Anki) out of my notes. The front
side is the hierarchy of a headline to its parents, and the back is the text
below the headline.

e.g.,

    
    
      * Python3
    
      ** I/O
      
      *** modes
      
      - 'r' open for reading (default)
      
      - 'w' open for writing, truncating the file first
      
      - 'x' open for exclusive creation, failing if the file already exists
      
      - 'a' open for writing, appending to the end of the file if it exists
      
      - 'b' binary mode
      
      - 't' text mode (default)
      
      - '+' open a disk file for updating (reading and writing)
      
    

...makes a flashcard like:

    
    
       -------------- --------------
      | Python3      | - 'r' ...    |
      | :: IO        |   .          |
      | :: modes     |   .          |
      |              |   .          |
       -------------- --------------
    

source for undocumented spaghetti code: [https://github.com/hackharmony/org-
to-anki-csv/blob/master/o...](https://github.com/hackharmony/org-to-anki-
csv/blob/master/org-to-anki.el)

However I would say that there are much better markup languages out there. (Or
better yet, don't use a markup language at all and use richer formats. We're
not in the PDP11 era anymore.) It's good if you need version control though.

~~~
BeetleB
Just as an FYI, Org mode has a flashcard software (org-drill).

(Broken on Org 9.x - not sure if they fixed it - you may need to use 8.x).

~~~
zelly
I tried that but it didn't have all the features I wanted. Specifically, I
wanted to be able to make a list of subheadings as a flashcard (the front side
being the headlines above). There's a lot of information you can encode in
just the hierarchy for free.

------
tpaschalis
It does look nice, and I'd be more than happy to put some effort and use Org-
Mode, instead of Markdown, if only \- There was a standardized release outside
emacs which would consistently provide the same results. \- There was an easy
way to render documents (like the Perl script markdown has) \- There was
serious support for plugins for my editor for easy rendering to
pdf/html/whatever.

------
crispyambulance
The author claims, several times, that "many" people use org-mode outside of
emacs.

I am skeptical of that.

The whole point of an abbreviated mark-up is to RENDER that mark-up into
something else. The "many" people who use org-mode outside of emacs are just a
subset of pandoc commandline users (and perhaps some other tool which I am not
even aware of). I guess it depends on what one considers to be "many"?

------
chipotle_coyote
I can't help but think this is a bit more of an apples-to-oranges comparison
than it's being treated as in this post. Org's introduction (chapter 1.1 of
its manual) begins,

* Org is a mode for keeping notes, maintaining TODO lists, and project planning with a fast and effective plain-text markup language. It also is an authoring system with unique support for literate programming and reproducible research.*

Whereas the introduction to Markdown from its original author begins simply,

 _Markdown is a text-to-HTML conversion tool for web writers._

These are both lightweight markup languages, sure, but they're designed for
different domains. What makes Org-mode interesting isn't ultimately its markup
language; look at all the comments here talking about tasks and tags and such.
What makes it interesting is its _implementation._ Markdown, conversely, was
explicitly intended as an HTML preprocessor. You can do anything in Markdown
that you can do in HTML for the simple reason that if you can't do it in
Markdown, you can literally use HTML. That's not what Org-mode is for.

I think the thesis of this article is basically "Org-mode's specific choices
with respect to markup syntax are better than Markdown's." And, well, fine;
I'm not entirely sure I agree, but I'm not sure it really matters. What does
matter to me is that Markdown (a) works very well for what I want in practice
and (b) works everywhere I want it to. If I was one of the folks who lived in
Emacs, the chances are Org-mode would handily hit both of those points for me.
But I'm not. And as lucideer noted in his comment, just because it's possible
to use (a subset of) Org-mode's markup outside Emacs doesn't mean it offers
any particular advantage over, well, Markdown.

------
fourier_mode
Once I played with tables in org-mode, I never turned back to markdown. I am
not sure if there is another markup tool which looks at tables as good org-
mode does.

~~~
joseph8th
Agreed. Sadly ox export for markdown doesn't render markdown tables. Of
course, as the OP argues, that's a little like exporting PDF to EPS.

------
jopsen
Actually, looks very reasonable :)

But adopting trumps perfection, hence, GFM is probably the most reasonable
choice for new applications today.

------
013a
> Org-Mode Is Standardized

Let's be totally clear about this: If Org-Mode were actually popular, it too
would have twelve variants. It is not popular.

------
LoSboccacc
> consistent, intuitive, standard

about that, just found some random online editor and entered this:

[https://i.imgur.com/Mcyi3kS.png](https://i.imgur.com/Mcyi3kS.png)

not what I'd call intuitive. maybe is that particular editor implementation?
but then I'd have an issue with the other half of the post, where he talks
down markdown dialects.

------
zaarn
The article title is missing a footnote:

"Only if you use EMacs, as Org-Mode is impossible to implement outside of
EMacs".

Source: tried once as someone who never used org-mode or emacs. Did not go
well.

~~~
mickael-kerjean
I built a complete web app for org-mode:
[https://demo.filestash.app/s/hnorg](https://demo.filestash.app/s/hnorg) ho
and it's open source [https://github.com/mickael-
kerjean/filestash](https://github.com/mickael-kerjean/filestash)

~~~
julienchastang
Hey, this looks pretty nice! Could you elaborate a bit here on what this is?

------
narrator
I like Wikitext[1] which is Mediawiki's markup. Mediawiki is the software that
runs Wikipedia. I have a personal Mediawiki that I use for taking notes and it
works a lot better than org-mode in that it is easy to make tables, nicely
formatted outlines , hypertext, etc. Chrome has a plugin that lets you edit
textboxes in emacs too so you can use a real text editor instead of just
chrome textboxes.

[1]
[https://meta.wikimedia.org/wiki/Help:Wikitext_examples](https://meta.wikimedia.org/wiki/Help:Wikitext_examples)

------
celadevra_
Org-mode syntax is no better than that of AsciiDoc, or arguably Markdown.

But I can assign keywords and unique id to sections, include sections from
another file, generate indexes and sitemaps in fully customizable manners,
incorporate other programming environments. What markup languages can do that?

Org-Mode syntax is an interface to a powerful writing/authoring environment.
To dismiss it as a `markup language' is not a good way to advocate its
adoption. Something similar can be said to ways people appreciate the power of
Emacs.

------
ggm
What we need is more time machines so we can go back in the past and make even
more future choices. Because just splitting amongst the choices we have is so
.. limiting.

I do kind of wish we only had one markdown flavour. Maybe why we only have one
org mode is because of its lack of ubiquitousness? If it had an electron
windows version would it be the same?

The commensurate note is, everything here (Bar one) says it's a stalking horse
for Emacs

------
01100011
Maybe I'm just old but I miss the old MoinMoin syntax. A lot of markups are so
complicated (mediawiki) I'd rather just write HTML.

For my personal notes I now just use vim and a custom syntax file to give
color to special names and headings. I've used markdown before but it seemed
like different tools treated the language slightly different.

~~~
lifthrasiir
I do the same for my personal notes. Something like (the actual contents
differ because I take notes in my native tongue):

    
    
        if exists("b:current_syntax")
          finish
        endif
        
        syn match diaryHashtag "\w\@<!#[A-Za-z]\+"
        syn match diaryInlineCode "`[^`]\+`"
        syn match diaryLineMarker "^[ \t]*\%([0-9]\+\.\|[*-]\)\S\@!"
        syn match diaryInlineMarker "=>\|\S\@<!(\?\%(i\{1,3}\|iv\|vi\{0,3}\|ix\|x\))\S\@!"
        syn match diaryInlineDate "\<\%(today\|yesterday\|tomorrow\|\%(\%(next\|last\)\s\)\=\%(mon\|tue\|wed\|thu\|fri\|sat\|sun\)\|20\d\d-\d\d\%(-\d\d\)\=\)"
        syn match diaryInlineTime "\<\%(\d\d\=:\d\d\|morning\|afternoon\|night\)"
        
        hi default link diaryHashtag String
        hi default link diaryInlineCode Delimiter
        hi default link diaryLineMarker Statement
        hi default link diaryInlineMarker Statement
        hi default link diaryInlineDate Comment
        hi default link diaryInlineTime Comment
        
        let b:current_syntax = 'diary'
    

But this system is entirely unusable for longer and potentially public
writings.

~~~
pcnix
I used something similar, along with a few additions to add timestamp as a
column on the left etc.

I've since switched over to org-mode though, I find that the agenda
integration and a couple of org-journal plugins make for easy task management.
I'd really like an alternative that lets me handle this on mobile, so far I've
tried termux and the github edit file interface, and neither are as
satisfactory.

------
IshKebab
Unconvincing. Markdown surely has way better tool support.

The lack of standardisation is probably the best argument, but I suspect that
is mostly not a problem for Org mode simply because barely anyone uses it. If
it were as popular as Markdown you'd find plenty of non-standard extensions
and slightly different implementations.

------
sevensor
Having written my dissertation in markdown, and having not tried org-mode, I'm
intrigued. The thing about multiple markdown implementations is a bit of a red
herring. The subtly different problem with markdown is not multiple
implementations, but a syntax with too many alternative ways of doing the same
thing. Section headers, tables, raw HTML, raw LaTeX -- it's kind of a mess.
Multiple flavors make this worse by supporting subtly different variants of
the alternative syntaxes, but the core of the problem is that the original
specification was "whatever this perl script does," and that leads to weird
corner cases.

The appealing case for org-mode is consistent syntax. At least that's what it
looks like from a distance. Like I said, I haven't tried it.

~~~
maga_2020
what do you think about Org2Blog [1] (it supports math notation as well as
integrated publishing from orgmode to wordpress) ?

I would like to minimize my learning curves, so wanted to get a performant
blogging service installed on a 2.50$ Vultr instance, and keep using Emacs for
blogging with something that includes math typesetting.

org2blog seems to be fit closest to what I am looking for (but I would prefer
something other than wordpress if I have a choice).

[1]
[https://github.com/org2blog/org2blog](https://github.com/org2blog/org2blog)

------
byproxy
Makes me think of a comment I posted not too long ago (and it's responses) :
[https://news.ycombinator.com/item?id=19474623](https://news.ycombinator.com/item?id=19474623)

Reasonable for text...for most text that's skeuomorphic with regards to the
printed word (in most senses). But... what is there for that which is beyond?
A response to the linked comment mentions TEI (Text Encoding Initiative).
Anything else? Is it too vast a problem in that we should make due with
solutions that cover 90% of use-cases? Ah, but does that limit potential
future development as people mold themselves to the constraints placed on them
by the tools and what those tools allow?

Just thinking out loud, per usual.

------
anbop
I refuse to use a plain text editor for my personal notes. Bold, italic,
underline, text highlighting... these are all things that help me organize
text and draw my attention to certain areas. Asterisks simply don't do the
same job, visually.

~~~
mikekchar
Luckily for you Emacs lets you set the faces (emacs's name for syntax
highlighting) however you want it. You get the best of both worlds: convenient
keyboard interface and marked up text in the editor.

------
ogre_codes
It fills most of the same niches as a tool which is currently extremely widely
used (Markdown) without having any major benefits over it. Probably the single
biggest improvement I see is the link syntax which I find bothersome in
Markdown for the reasons the author suggests (parens first or brackets first).
Aside from that, tooling for Markdown is massively better with dozens of tools
supporting Markdown parsing and authoring. Yes there are a lot of sub-versions
of Markdown, but if you know the basic markdown features you can use any of
them.

~~~
submeta
> ... without having any major benefits over it.

How about tables?

~~~
ogre_codes
Fair point.

Though I would suggest that one of the strengths of Markdown is the fact that
the basics are simple and easy to understand and it leaves more advanced
concepts to specific implementations. So there are implementations for
everything from code comments ([https://www.hackingwithswift.com/example-
code/language/how-t...](https://www.hackingwithswift.com/example-
code/language/how-to-add-markdown-comments-to-your-code)) to Script Writing
([https://fountain.io](https://fountain.io)) which have features specific to
their respective domains. Markdown itself doesn't have a huge featureset but
the sub-markup languages which inherit from it do.

Edit: What I find more confusing about Markdown is actually incomplete
implementations like what's used by HN.

------
rini17
Such free-style formats are easy and addictive, but you eventually hit some
well-hidden sharp corners. For example I missed some deadlines without any
warning from emacs nor any indication with syntax higlighting when I had:

    
    
        * TODO stuff
        text <- no text should be here!!
        DEADLINE: <date>
    

Not to mention I am vim user and ANY vim compatibility layer for emacs
eventually goes infuriatingly against my muscle memory.

------
pwinnski
I sometimes think that Org-mode suffers in the same way that SGML lost to
HTML, SOAP lost to XML-RPC, Atom lost to RSS, XML lost to JSON, and so on.
What some people see as the over-simplicity of Markdown is exactly what leads
to it being implemented "everywhere." The simpler format often ends up being
more widely used precisely _because_ of its simplicity, not despite it.

~~~
pmoriarty
The analogy breaks down because the complexity in org-mode is completely
optional.

You don't have to use or even know of all of org-mode's features in order to
use it. You could use a tiny subset of features and still have a valid org-
mode file which is as simple as any other markdown format.

In fact, that's exactly how most people use it. But if they want more power,
it's there.

What's more likely to be the reason for org-mode's lack of adoption is that
most people don't use emacs.

------
Aardwolf
Another one that doesn't respect line breaks

What is the reason why all those lightweight markup languages don't preserve
plain text line breaks by default without special formatting?

It would be much easier to use if they did, if I hit enter in plain text it's
for a reason

I like BBCode, and that one preserves your line breaks too

------
blablabla123
Org mode is great, at work I use it since half a year to keep myself
organized. For instance when I'm debugging something, I can keep notes and
clues or the sometimes not avoidable request that just won't fit into the
issue tracker.

------
otterpro
Previously in
[https://news.ycombinator.com/item?id=15321850](https://news.ycombinator.com/item?id=15321850)

------
CivBase
This looks very similar to markdown. I wonder how org-mode distinguishes
itself.

> Org-Mode is Standardized

> the very widely used markup language named Markdown has many flavors to
> choose from

I believe the XKCD about standards applies here.[0]

The problem with Markdown is only real if you treat Markdown as a single
language instead of a family of languages. You don't need to support multiple
Markdown compilers. Just pick a particular flavor of Markdown to support for
your project. I usually go with GitHub's.

Besides, having a standard doesn't stop others from adding unofficial features
on top of that standard. If this happens to take off, maybe I'll be using
GitHub Flavored Org-Mode in the future.

[0] [https://xkcd.com/927/](https://xkcd.com/927/)

------
burtonator
I'm surprised how many people use org-mode.

At least on Hacker News... a Lot of the Polar users mention org-mode as one of
the other tools they're using.

------
asciimov
I've always wanted to learn org-mode and emacs.

Can anybody recommend a good tutorial?

Also, should I learn pure emacs or go the spacemacs route? My background is in
vim.

~~~
zaiste
Another, long-time Vim user here. I recommend Emacs Doom [1]. It was built
especially with Vim users in mind.

[1]: [https://github.com/hlissner/doom-
emacs](https://github.com/hlissner/doom-emacs)

------
exabrial
So markdown. But standardized. Again.

~~~
BeetleB
Org mode predates markdown.

------
ninju
> Org-Mode Is Standardized

(until it isn't)

I'm assuming all of the variations of Markdown that were created were created
without knowledge of the original Markdown creator.

Is the OP going to monitor all open source projects and block people from
creating an improvement of Org-Mode

~~~
ternaryoperator
>(until it isn't)

There is only one version of Org-Mode, with its own reference implementation,
and it's been that way for years.

>I'm assuming all of the variations of Markdown that were created were created
without knowledge of the original Markdown creator.

Not so. Daring Fireball was repeatedly asked to participate in advancing,
changing, standardizing MD, but chose not to. He was well aware of the
variants emerging.

>Is the OP going to monitor all open source projects and block people from
creating an improvement of Org-Mode

That's not how reference implementations work. The only thing that matters are
variants that get enough traction.

------
nitwhiz
This is just markdown..

------
skookumchuck

        : Simple pre-formatted text such as for source code.
        : This also respects the line breaks. *bold* is not bold here.
    

The trouble with that is you cannot easily copy/paste code to/from it, because
you'll need to manually add/subtract the : prefix. Delineating the section
with:

    
    
        ```
        Simple pre-formatted text such as for source code.
        This also respects the line breaks. *bold* is not bold here.
        ```
    

is much more practical.

~~~
confounded
They’re not mentioned in the article, but org-mode does have syntax for source
blocks (a little uglier than Commonmark/Github-flavor markdown’s blocks in my
opinion, but it does the same thing and works well).

~~~
TeMPOraL
It may seem uglier if you use it first time:

    
    
      #+BEGIN_SRC lisp
        (format t "Hello world!~&")
      #+END_SRC
    

but it has two things going for it.

One, it's consistent with other blocks, like BEGIN_QUOTE, BEGIN_EXAMPLE,
BEGIN_VERSE, etc. (n.b. all four have a default shorthand that gets tab-
expanded; <s. <q, <e and <v, respectively) , and with arbitrary user-defined
blocks like BEGIN_whatever.

Two, while #+BEGIN_SRC may seem only an unnecessarily verbose way of writing
```, things change when the block starts to look like this:

    
    
      #+NAME: advanced-block
      #+BEGIN_SRC lisp :package my-package :var foo=123 :var bar=asdf :noweb yes :exports both :eval never-export
        <<preamble>>
        (format t "Hello ~A!~&" <<some-other-block(param=3.14)>> )
      #+END_SRC
    

AKA. a named source block (so I can reference it elsewhere) of Lisp executing
in selected Lisp package, with org mode variables injected into it, using
noweb syntax (literate programming) for injecting other code blocks[0], which
when exporting the document to a different format (say, PDF) will export both
code and results of its evaluation, but will not automatically evaluate the
code.

This feature makes Org Mode essentially a kind of better Jupyter, with
automatic support for any and all possible language that you can plug into
Emacs, simultaneously.

\--

[0] -- here, it'll paste the literal contents of #+BEGIN_SRC block with
#+NAME: preamble at the beginning, and then paste the _results_ of executing a
block with #+NAME: some-other-block, with value 3.14 for its :var param, at
the end

~~~
kqr
I have a slight preference for

    
    
          #+NAME: advanced-block
          #+HEADER: :noweb yes :exports both :eval never-export
          #+HEADER: :package my-package :var foo=123 :var bar=asdf 
          #+BEGIN_SRC lisp
            <<preamble>>
            (format t "Hello ~A!~&" <<some-other-block(param=3.14)>> )
          #+END_SRC
    

(Just wanted to point out that the header format has even more flexibility
than what you've shown!)

------
mruts
org-mode with latex yasnippet expansions is the best note taking method I’ve
ever used. Inline images, tables, ans latex. So seemless.

