The following are various thoughts about IPython that I had soon after 
returning from vacation.  They seem relevant to the question about where 
Leo is going.

TL:DR: IPython doesn't need Leo's features.  Leo *could* use IPython's 
typing completion.

- IPython is a super successful project.  Fernando Perez has gotten grants 
totaling millions of dollars.  The design of the IPython core and the 
newly-separated Jupyter notebook <https://jupyter.org/> are brilliantly 
simple.

- Adding outlining to IPython might not be a good idea. In any case, the 
IPython community will choose which enhancements make sense.

- The Jupyter notebook takes the simplest possible view of literate 
programming.  Notebooks can intersperse documentation cells with code 
cells.  No LP-specific markup at all.  No tangling, or rather, the 
documentation cells are automatically rendered.  The disadvantage is that 
links are a bit clumsy to insert, and there is really no document-level 
organization, but this doesn't seem like a big drawback, because the 
example notebooks I've seen <http://nb.bianp.net/sort/views/> tend to be 
pretty short.  You can quibble about these design choices, but the fact 
remains that the IPython/Jupyter notebook is very easy to understand.

In short, IPython will do just fine without Leo.  But Leo could be extended 
to handle .ipynb (Jupyter) files.  That's on the list.

More interestingly Leo *could *use IPython's scheme of basing code 
completion of live objects, provided users are willing to execute the code 
in an outline.  Yes, this could be dangerous, and people must be aware of 
the dangers.

The general idea is actually very simple.  When doing typing completion, 
Leo would create a *completion namespace* by scanning the present outline 
for an *enclosing context*.  Because the user is likely to be altering the 
present node, the enclosing context would probably not include that node.  
Modulo this complication, the auto-completer would simply look up the tree 
for the enclosing @<file> node, write the node to a string, and execute the 
string.  The result would usually be *definitions* of top-level functions 
and classes.  Voila: Leo's typing completion would have the same kinds of 
features that IPython has.

Edward

-- 
You received this message because you are subscribed to the Google Groups 
"leo-editor" group.
To unsubscribe from this group and stop receiving emails from it, send an email 
to leo-editor+unsubscr...@googlegroups.com.
To post to this group, send email to leo-editor@googlegroups.com.
Visit this group at http://groups.google.com/group/leo-editor.
For more options, visit https://groups.google.com/d/optout.

Reply via email to