
Org-Mode for Visual Studio Code - walkingolof
https://github.com/ajtoo/vscode-org-mode
======
hyperhopper
As much as I like spacemacs/emacs, org mode truly is one of the best things
about that editor, and its amazing to see it gaining some real momentum with
those outside that ecosystem. This should do wonders for org mode, but more
than that, give a lot of people scared off by emacs the chance to use the
amazing org mode features.

~~~
oblio
> give a lot of people scared off by emacs

I'm not even scared off, but I won't use Emacs because it doesn't have tabs. I
know about the alternatives presented, but I just want tabs. I find it funny
that the kitchen sink "Eight Megabytes and Constantly Swapping" Emacs doesn't
have a built in tab implementation while the supposedly small Vim has one :)

~~~
barrkel
I've found tabs to not scale as a UI idiom, generally. They're ok for up to
about 10 documents, after that, I'm looking for something else.

I normally use IntelliJ with two panes open, and about 120 tabs between the
two of them. But because IntelliJ tabs can't scroll and Java filenames are
long, the tab I want to switch to is never visible, and the tab list dropdown
is painful to scan. C-n and C-S-n are what I end up using.

And for the browser, I use tree-style tabs. The hierarchy keeps related tabs
together, and I can collapse when I do a context switch. The fact I can see
all the (top-level) tabs at once in a long list means spatial memory works
better.

In emacs, I use Helm and Projectile, bound to F11 and F12 for buffer and
project searches. I've bound buffer switching to C-prior and C-next (those are
PgUp and PgDown), and since the buffer order is basically a LIFO of whatever
buffer you jumped to, the buffer you're looking for is usually within easy
scrolling reach.

~~~
qwerty456127
In the current reality as it is tabs seem an essential part of a web browser
and some other apps. But I feel like tabs should not be done by any app - a
window manager is to take care of this IMHO.

I especially don't like tabs in IntelliJ Idea: I never (except the cases when
I want to detach one to a separate window) actually use them, every time I
want to switch to a particular file in a project I choose it in the project
tree in the left panel, the tabs only pile up atop of the editor pane and
annoy me so I close them every now and then.

~~~
adrusi
Hey, I'm with you in feeling that tabs are essential to web browsing but that
they should ideally be the window manager's responsibility. For a while I used
surf [1] (which lacks tabs) and the i3 window manager, but for various reasons
I wanted to move back to Firefox.

I made a very simple webextension that disables tabs in firefox, so that I can
use my window manager's tabs instead. I've been using it since the stable
release of Firefox 57.
[http://static.adrusi.com/notable.html](http://static.adrusi.com/notable.html)

[1] [https://surf.suckless.org/](https://surf.suckless.org/)

------
tandav
This is not org-mode if it can't do folding. Folding is main purpose of every
outliner.

Another fundamental thing is narrow to subtree (C-x n s/w in org-mode or just
click in workflowy)

So this is just .org syntax highliter with some snippets and shortcuts.

.org markup language is much less common than markdown, and this is bad.
Nobody wants to learn 2 similar languages with conflicting syntax.

~~~
hyperpape
[https://github.com/ajtoo/vscode-org-
mode/issues/85](https://github.com/ajtoo/vscode-org-mode/issues/85)

There's an issue, and the project is in alpha, but this doesn't sound good.

------
m12k
For anyone who thinks infinitely nested lists sounds like a good way to
organize things, but would prefer an online, less editor-centric (but still
keyboard friendly) tool, I recommend workflowy.com (or their more recent
competitor dynalist.io who add more rich content support if that is your
thing).

I've been using Workflowy for years to organize my work, both for tasks and
for mental maps and note-taking. I've found that it maps extremely well to the
recursive nature of my mental map of an application and it subcomponents,
tasks and subtasks, and so on. And overall I find that collapsible nested
lists have all the benefits of a classic 'mind map' but without the
constraints and 'easier to read than edit' nature of a bubble visualization.

~~~
walkingolof
For me the whole point of org-mode is that the stuff in it is to valuable to
trust with a vendor that stores it in a proprietary format that cant be
extracted in a meaningful way if the service/company folds.

~~~
NickBusey
So one more note here, my open source Workflowy clone backs up all your data
to a .txt file in your Dropbox every night. If my hosted service goes away,
you can just run it locally, import the .txt file, and you're good to go.
[https://github.com/NickBusey/BulletNotes](https://github.com/NickBusey/BulletNotes)

A large part of the reason I made it was for exactly the scenario you
described. I run my entire life out of it and wasn't comfortable relying on
one company for it.

~~~
kingkongjaffa
Nick, thank you for this, you've got another user!

~~~
NickBusey
Hey thank you! And please don't hesitate to create GitHub issues or let me
know about any problems.

------
roryisok
Forgive my ignorance but what makes org mode better than markdown? Whenever I
see it demonstrated it seems to be just another way of marking up content in
plain text. Is there more to it?

~~~
saulrh
If you're looking at it purely as an interchange format for pretty documents,
no. However, once you think about actually using it, the tooling for the
format is _fantastically_ more powerful. A small selection of some of the
standouts:

Emacs' better understanding of the structure gives you much better editing; I
have chords for operations like "move this item up/down" and "promote/demote
this item", plus excellent folding, jumping, and a measure of intellisense-
like functionality.

org-babel can do anything that even looks like literate programming. I make
regular use of both its notebook functionality (like ipython) and its more
traditional features (compile to a documentation part and a code part), and
its integration with emacs lets you do things like pop out to edit a code
block in its native mode as if it were a little tiny file.

org-agenda and org-todo use the format's support for rich semantic metadata to
do anything you could want from a calendar, bug tracker, organizer, note-
taker, or list manager. You can tag your items with indexed keywords,
arbitrary and even simultaneous to-do workflows, and arbitrary (and I do mean
_arbitrary_ , it's emacs and everything can be an elisp snippet) to-do
deadlines and recurrences. And all that data isn't just a wash; a wealth of
options exist for slicing and dicing your data in any number of ways, high-
level overview or detailed statistics.

And on top of all that, you can render org-mode documents to nearly any markup
under the sun! I regularly compose documents in org, using all of this power,
and export to markdown or html to publish.

~~~
roryisok
But it really sounds like you're telling me about things Emacs can do. If I
don't use Emacs, what advantage does org mode hold for me? This link is for
org mode in vscode, which I do use, but from what I can see it doesn't do any
of that fancy stuff there?

~~~
saulrh
Yes, if you're not using emacs you don't get much from the format itself.
Which is why everyone talks about org- _mode_ , not the file format. That
said, available libraries matter when you're choosing a programming language,
and interop and available integrations matter when you're choosing, say, a bug
tracker; why wouldn't the available editing tools matter when you're choosing
a calendar+agenda+literate-programming environment+note-taker+organizer?

I'd almost say that a "mode" for editing org-mode files almost doesn't deserve
to be called "org-mode for X" if it doesn't do all the fancy stuff. It'd be
like calling telnet a gmail client because you can theoretically negotiate an
SSL handshake by hand - yes, but that's not the point. I think that people
came into this thread hoping for a vscode extension that does everything that
emacs org-mode does, but I don't think that that's something that'll happen,
unfortunately, not unless vscode's architectural philosophy is very different
from what I expect.

------
based2
[https://plugins.jetbrains.com/plugin/7095-org4idea](https://plugins.jetbrains.com/plugin/7095-org4idea)

------
tambourine_man
We need that on Vim

~~~
s4vi0r
Or just accept that emacs is objectively better software and switch to it?
Evil mode is by far the most complete/true to vim vim emulation that exists,
as far as I know.

~~~
davidmr
It's easier said than done. I decided to switch about a month ago, and after
playing around with evil mode for a week, I gave it up in favor of emacs-std
bindings. The core editor evil emulation was flawless. All my 20-year muscle
memory commands just worked without a second thought.

When going into other packages like org, magit, etc. I noticed that all their
default bindings were emacsey as well (for obvious reasons). I realized that I
would be forever mapping evil bindings into new packages every time I wanted
to use something new, so I gave it up as a bad job and just bit the bullet and
switched to stock emacs without evil. I'm like halfway through the learning
curve (I hope!) and it's tough. I've always had the caps lock key mapped to
Ctrl anyway, but I still feel like my pinkie is about to fall off. After using
vi/elvis/vim for almost 25 years, I do admit that I like emacs, but "just
switch" still means a period of remarkably reduced productivity to many.

(Yes, I know that for any popular package someone has published evil mode
bindings and use-package makes them trivial, but it's not the point.)

~~~
dxepcion
have you looked into evil-collection? This is a collection of evil bindings
for various emacs packages. [https://github.com/jojojames/evil-
collection](https://github.com/jojojames/evil-collection)

~~~
davidmr
Thanks; I have, but I thought I might as well try to do it right. If after
another month or so, I still have "Emacs pinkie", I might just bite the bullet
and go to evil mode.

------
yodon
Are “checkboxes” like [ ] and [x] understood by the real org mode or would I
need to define say [_] and [x] as TODO keywords if I wanted highlighting of
that sort of syntax? (It’s been ~20 years since I was a heavy emacs user,
looking forward to finally getting to play with Org Mode or at least an alpha
of it)

~~~
TeMPOraL
Yes, they're understood, but in the different way. Org mode opted to treat
_headlines_ as TODO items (this choice is important for the purpose of e.g.
generating agendas), whereas checkboxes apply to _list items_.

As for the checkboxes, org mode understands [ ] and [X], and can process them
relative to checkboxes in a sublist. For instance, if you write something like
this:

    
    
      - [/] Foo
        - [X] Bar
        - [ ] Baz
      - [%] Foo
        - [X] Bar
        - [ ] Baz
    

and then make org-mode reevaluate the list (by e.g. using a shortcut that
toggles a checkbox state), it will automagically turn into:

    
    
      - [1/2] Foo
        - [X] Bar
        - [ ] Baz
      - [50%] Foo
        - [X] Bar
        - [ ] Baz
    

(similar / and % feature is available for TODOs in headlines too). Org mode
maintains such associations itself, recomputing them as you change state using
org-mode commands, and it can also be configured to enforce additional
structural constraints - e.g. preventing you from turning a TODO to DONE, if
its subtasks are not all in DONE state.

------
dotdi
Finally, a thing that I was using before it made it to the top of HN.

------
bzg
Very nice! Congrats for this.

In GNU Emacs, Org is both a plain text format and a set of tools to edit .org
files: it's nice to see both implemented outside Emacs!

------
luord
These all seem really useful. Specially the date thing, handy.

