vnlog VS jupytext.vim

An incomplete list of other similar tools: https://github.com/dkogan/vnlog/#description

For simple analyses (i.e. what most people do most of the time) doing this on the commandline gets you there faster. I use vnlog (https://github.com/dkogan/vnlog/). By the time you fired up your editor to write your Python code, I already have analyses and plots ready.

Alternative very appropriate for some uses cases: `vnl-join` from the vnlog toolkit (https://github.com/dkogan/vnlog). Uses the `join` tool from coreutils (works well, has been around forever), and `vnlog` for nice column labelling

There's also https://github.com/dkogan/vnlog/ which is a wrapper around the existing coreutils, so all the options work, and there's nothing to learn

I found using shell as an interactive environment to be pretty productive using https://github.com/dkogan/feedgnuplot and https://github.com/dkogan/vnlog. The filesystem becomes your state (instead of in memory state of your Python interpreter) which forces you to write Unix-style tools. Plotting with feedgnuplot spins up an interactive Qt plotter which I often used to explore 3D plots. It's not "inline" and fancy and does take a bit of grokking but I eventually found it more productive than Jupyter, especially as my development moved away from Python.

Similar, but using the ACTUAL awk, sed, join, sort tools you already have and know about: https://github.com/dkogan/vnlog/

Write space delimited tabular data (ideally in vnlog format) and plot it using feedgnuplot. Also helps decouple concerns (data generating application focuses on generating data).

I use feedgnuplot in conjunction with vnlog all the time at work! It’s a great pipeline.

I have a text file in a known location. It's backed up on git.

I can open and edit that file quickly using bash. From within VIM I can quickly commit to reduce the # keystrokes. More details: https://github.com/jodavaho/bashlog

(Really though, you can just save as an environment variable your file location)

The text file is structured with space-delimited text, like this: https://github.com/dkogan/vnlog

My current structure:

"# date item amount"

Easy to open, easy to plop down today's date and the item / amount. Save multiple date/item entries and add them inscripts ... Easy to save. Done.

The work came in building stuff to plot it:

I have other files that link "items" to goals or other metadata like categories, etc. Like a relational database, but easily edited in text.

For example, to make a link from daily items to Key Results

"# item okr"

okr is structured like this: ...

For example:

2020.Q4.01.01 is workout 90x (1/day)

2020.Q4.02.02 is get through 26 textbook chapters

2020.Q4.02.03 is 100 h studying literature

The categories are usually Fighting (I box), Tech, Mental health, and Social, but YMMV

Another example is "workout-mapping.vnl" with structure:

I tried plugins like jupytext.vim but it was not enough mature in these old times :-)

You can also use jupytext.vim to easily open and edit notebooks. Then you can use a REPL program to evaluate the different cells individually. The only downside to me is that you can’t save the output back to the notebook (images etc.).

Editing *.ipynb files can also be edited with jupytext.vim, which automatically converts *.ipynb files using jupytext which you open them in Vim. I haven't tried this yet (it's on my todo list), but it looks pretty solid.

For editing notebooks in vim, I've created https://github.com/goerz/jupytext.vim. Note that this does not allow to run any cells, it just edits the inputs.

The motivation behind this was to have some basic interaction with existing ipynb files on a remote server without having to run the jupyter server (and set up port forwarding etc.) It's worth noting that the `jupytext.vim plugin is most useful if you're actually not running `jupytext` within jupyter; If you are, you could just directly open the .py or .md files linked to any .ipynb in your editor.

I've used `jupytext.vim` to edit existing notebooks and then run them through `jupyter nbconvert --to notebook --execute`. It's also great for refactoring: moving code from a notebook files into a module, between notebooks, or to create a new notebook as a variation of an existing one.