0: https://code.visualstudio.com/docs/python/jupyter-support-py

[0] https://docs.spyder-ide.org/current/panes/editor.html#code-c...

  # %% [markdown]
  # Another Markdown cell

  # %%
  # This is a code cell
  class A():
      def one():
          return 1


  # %% Optional title [cell type] key="value"

  ```{code-cell} LANGUAGE
  :key: value

  CODE TO BE EXECUTED
  ```

  ---
  kernelspec:
    name: javascript
    display_name: JavaScript
  ---

  # Another markdown cell

  ```{code-cell} javascript
  // This is a code cell
  console.log("hello javascript kernel");
  ```

The vim plugin I was talking about was vim-slime [0], which seems to date from 2007 and does have regions delimited with #%%.

Slime comes from Emacs originally, but I could not find if the original Emacs slime has regions.

Matlab also has those, which they call code sections [1]. Hard to find when they were introduced. Maybe 2021, but I suspect older.

None of those stores gge output of the command.

[0] https://vimawesome.com/plugin/vim-slime

[1] https://www.mathworks.com/help/matlab/matlab_prog/create-and...

  # %%

  "^# %%"

Org-mode supports code blocks: https://orgmode.org/manual/Structure-of-Code-Blocks.html :

  #+BEGIN_SRC <language> and 
  #+END_SRC. 

Notebook interface; Markdown + MathTeX: https://en.wikipedia.org/wiki/Notebook_interface ;

  $ \delta_{2 3 4} = 5 $

  $$ \Delta_\text{3 4 5} = 56 $$

whether or not it's better for you depends on your use case for notebooks — i use them mostly for prototyping and exploratory data analysis so separating the code from the output might be more convenient for me than for you

I wrote a small vscode extension that builds upon this to automatically infer code blocks via indentation, so that you don't have to select them manually: [0]

[0]: https://github.com/kylebarron/vscode-jupyter-python

0: https://bsky.app/profile/jdaw0.com/post/3ljyl6kbeys2a

there's a trillion dollars in it for you if you can prove me wrong and make one that does the job better than modern transformer-based language models

Modern LLMs solve the huge problem of turning natural language from non-experts into the kind of question an expert system can use… 95% of the time.

95% is fantastic if you're e.g. me with GCSE grade C in biology from 25 years ago, asking a medical question. If you're already a domain expert, it sucks.

I suspect that feeding the output of an LLM into an expert system is still useful, for much the same reason that feeding code from an LLM into a compiler is useful.

The Chrome version of the original extension (other than the Firefox version) embedded Google analytics.

edit: looked it up. Source: https://github.com/iamadamdev/bypass-paywalls-chrome/issues/...