I have used Leo for a long time but I probably only use 1% of Leo features 
:-) I have been using it to do book keeping in Python. I created some 
simple classes and as things happen I add instances to record the new 
events. I use the outline to organize these by time periods. I write Python 
functions as needed to query the database (of Python instances). I use 
Leo's scripting capability and the handy script-button to run queries and 
send the query results directly into the log pane. I could do all this 
within Leo. It is simple and it just works and I am very happy with it.

While I was helping with the scroll bug I poked around Leo code base a bit 
and I am impressed by how the source files can be referenced from a few Leo 
files. The files loaded quite fast. When I do find in an outline I am 
essentially grepping all the files. Navigating through the nodes take a bit 
getting used to as with cloning node/file correspondence isn't assured, but 
I can see that it is a powerful way to organize for the creator who is 
intimately familiar with the structure of things. Also it is impressive how 
source code can be re-orged on a large scale fairly easily so logistics 
does not stand in the way of pursuing clarity through the best organization 
possible. I also like the cweb idea in general so I am definitely 
interested in using Leo more as a development tool and write my own code in 
outline/cweb style.

Currently I use Emacs. I can use it as a complete IDE since I can run 
inferior processes. I can do REPL style code development and debug. I also 
use it as my gui to visualize and navigate through large data structures. I 
use tree-buffer to visualize tree type structures and associate actions 
with tree nodes that allow me further explore the underlying data. If I 
need to look at a data table I just dump the output into an org-mode buffer 
and run org-table on the output. I use w3m to render html text in any 
buffer. I can create buttons to help me remember complex actions. I have 
not used the org mode's outlining capability, since I know Leo is an 
excellent outliner. I am wondering what kind of work flow I can use if I 
want to start using Leo as the source code editor? The simplest thing to do 
is to probably use @file trees. But if I then do REPL in Emacs, I will be 
looking at a lot of sentinels. I assume that I can edit the code in Emacs 
without ruining the outlining as long as I don't touch the sentinels. Now 
if I use @asis trees instead so I don't see sentinels -- does that mean 
that I won't be able to edit the code in an external program and have the 
changes reflected back in Leo?

I also use Vim because of its lightweight. It starts up quickly and uses 
very little resource so I can run as many copies of it as I want without 
thinking. I use it to look at large code bases in conjunction with cscope 
and it works very efficiently.

Because of the scroll bug I have also been keeping notes in Vim instead of 
Leo, using VIm's fold capability. I am thinking of moving these notes back 
to Leo. Is there a way to automate the conversion of Vim folds into outline 
nodes?

-- 
You received this message because you are subscribed to the Google Groups 
"leo-editor" group.
To view this discussion on the web visit 
https://groups.google.com/d/msg/leo-editor/-/6tKTlOV5hlcJ.
To post to this group, send email to leo-editor@googlegroups.com.
To unsubscribe from this group, send email to 
leo-editor+unsubscr...@googlegroups.com.
For more options, visit this group at 
http://groups.google.com/group/leo-editor?hl=en.

Reply via email to