On Sat, Dec 7, 2013 at 5:35 AM, Edward K. Ream <[email protected]> wrote:
We can both agree that scripts/programs can do anything.
>
> The question is, how easy and natural is it to do so?
>
Imo, org-mode users, really and truly, have not grasped the essence of
Leo. To put it another way, they have not grasped the true potential of
integrating programming and outlines.
Leo came about from the realization that "programs are outlines in
disguise". My initial formulation used literate programming term:
"webs are outlines in disguise". I see no deep understanding of this Aha
in org-mode or org-babel.
There are many reasons why I think the Emacs world is clueless about
outlines:
1. org-babel still thinks literate programming is pretty cool.
Let's disregard the horrible syntax--embedding visible sentinel comments in
code.
The real problem with literate programming is that it is extremely bad
style. Section references are essentially text macros (not elisp macros).
Clearly, the only justifiable use for sections is when functions or method
calls can not be used:
A. In Python, to group imports.
B. In html, to have clones make up for the lack of any organizational
capabilities in html itself.
This is important! Classes, methods and functions are the proper units of
encapsulation. In general, using code fragments is very dangerous because
external variables "bleed into" the code.
Every Leo node is a perfect place for comments, so there is almost zero
need for yet another "place" to put comments.
2. org-mode support for programming is feeble.
Org-mode (or org-babel) supports some markup based on noweb (which is Leo's
starting point) but there is *no* integration of that markup with outline
structure. No @others. No awareness of indentation. No "inheritance" of
indentation. No "inherited" directives.
3. Emacs has no notion of using outlines to study other people's programs.
No importers. And even if there were importers, the horrible org-babel
syntax would instantly muddy everything.
To summarize, Emacs has emulated a few of Leo's surface features, with no
real understanding of their true power:
- You think org-mode has @button nodes? I don't think so! It's left to
Emacs users to reinvent what is truly a clever idea: bringing scripts to
outlines. The fact that some people have done so does *not* mean that
org-mode provides *any* support for doing so.
- I've repeated several times that Emacs has nothing like:
for p in c.all_positions():
<< do something >>
As a result, there is *no* easy-to-use integration between Emacs scripts
(merely warehoused in org-mode outlines) and the data contained in those
outlines. Just for example, @test isn't going to be an obvious thing to
do. That doesn't mean that @test couldn't be done in Emacs, but afaik it
hasn't. And it would be *much* harder to do without p.h and p.b and the
rest.
In short, Leo's innovations came about because certain *crucial* things are
*easy* to do in Leo. Yes, people *do* use Emacs outlines in interesting
ways. It can be done. But without a proper outline-oriented conceptual
framework it will be much harder to invent Leonine ideas. And it will be
considerably harder to implement outline-oriented Ahas without a proper
outline-oriented api.
Which is why I expect the Emacs world will always be playing catch-up with
the Leonine world.
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 [email protected].
To post to this group, send email to [email protected].
Visit this group at http://groups.google.com/group/leo-editor.
For more options, visit https://groups.google.com/groups/opt_out.
