John Kitchin

> local notes solution ... published on the web ... crosslinked

Definitely a lot of ways to go about this.

If you haven't already, I'd suggest checking out what the creator of org-roam does for publishing his own notes: https://github.com/jethrokuan/braindump

It works quite well, and might be exactly what you want as far as publishing goes.

> end up in weird jams where Emacs has opened up 3+ panes (buffers), and I can’t figure how to even close/quit them

Typically 'q' will close Doom's popup windows (+popup/quit-window), otherwise you should be able use plain ol' Emacs 'C-x k' or Doom's '<leader> b k' (also 'b d') to kill a buffer.

If you actually want to keep the buffers, and you just want the windows out of the way, you can use winner-undo / winner-redo to cycle through past window configurations.

> bottom-up guide for personal information systems

AFAIK, this does not exist. But there is, I'm sure you've seen, a variety of independent users continually working out interesting new ways to process and link information using Emacs. For example, outside of bloggers in the Roam/Zettelkasten camp, you can always glean insights from John Kitchen's work [0][1], although it leans more towards research/academic use than PIM/PKM.

> my brother is writing a book - he’s not super technical but can get around

If it's technical/academic writing, you can honestly get astonishingly far just using org-mode's LaTeX export.

[0] https://kitchingroup.cheme.cmu.edu/

[1]…

> What I wonder is why are Jupyter notebooks so popular?

I often wonder the same. I'm now kinda forced to use them, since they're the tool of choice in my team, but it's a major pain. I think that they're "easy" (in the way Rich Hickey describes "easy" vs "simple") to get started with (just as python, btw), but their lack of flexibility comes back to bite you sooner or later.

For me, I've resorted to using a mix of EIN and ob-ipython, and then copy/pasting as needed to keep the stuff in synch with Jupyter. I'm now considering writing a simple ox-jupyter exporter, and maybe some import functionality, to avoid dealing with Jupyter directly.

John Kitchin has written a basic exporter (http://kitchingroup.cheme.cmu.edu/blog/2017/01/21/Exporting-org-mode-to-Jupyter-notebooks/), but it doesn't support inline images (it should be simple to fix this), and it doesn't really adhere to the ox- style of exports, so I think I'll probably do my own instead of adapting his (it'll be a good learning experience, for sure).

Tables are fairly easy to extract from org-files, even with some sed/awk function, e.g. `getOrgTable()
{ awk -vT=$1 '/^#\+NAME: /&&$2~T
{f=1;next};/----/
{next};!/^\|/
{f=0};f' $2 ; }`

The above should work for most tables, and you get back a pipe-separated-values output, that you could further refine with e.g. http://harelba.github.io/q/ to get tsv,csv output support and SQL query capabilities.

I regularly SQL-Query with INNER JOINs over tables in various org-files stored on multiple servers in one commandline using this combination.

John Kitchin has a description for a "cleaner" way to do it here:
https://kitchingroup.cheme.cmu.edu/org/2014/08/11/Using-org-mode-outside-of-Emacs---sort-of.org

My scripts are a dirty combination of ideas/concepts of both of the above, that work for me depending on situation/use-case, but that I should clean up one day, and gist someplace.
I can give more info, if the above doesn't give enough pointers yet for you to dig yourself further towards "your solution".

To get an idea of what you can do in Orgmode, a good place to check is the books/publications linked on John Kitchin's page. He's a professor of chemistry who uses Orgmode for lots of different things. Among other things (and also listed on the linked page), he is the author of the org-ref extension that integrates citations and referencing into Orgmode, using the bibtex database:

http://kitchingroup.cheme.cmu.edu/blog/2014/08/08/What-we-are-using-org-mode-for/

Here is a youtube video demonstrating use of the org-ref extension for citations and references:

https://www.youtube.com/watch?v=JyvpSVl4_dg

Plaintext OrgMode notebooks exhibit every benefit listed in Minimaxir's [0] post, and have the additional advantage of powerful editor integration beyond R code.

Here is an example of using the IPython kernel to evaluate inline Python code within an OrgMode document.[1][2]

More information on how to create multi-language notebooks with OrgMode Babel here[3]

[0] http://minimaxir.com/2017/06/r-notebooks/

[1] http://kitchingroup.cheme.cmu.edu/blog/2017/01/29/ob-ipython-and-inline-figures-in-org-mode/

[2] https://github.com/gregsexton/ob-ipython

[3] http://orgmode.org/worg/org-contrib/babel/