Monday, May 2, 2016

Leo 5.3-final released

Leo 5.3-final is now available on SourceForge. Leo is a PIM, an IDE and an outliner.

The highlights of Leo 5.3
  • Leo now supports Jupyter Notebook (.ipynb) files.
  • @chapter is now allowed anywhere. No need for @chapters.
  • Faster spell checking.
  • The rst3 command supports @rst-table.
  • The show-invisibles command now uses native Qt characters.
  • Dozens of other improvements and bug fixes.
Leo is:
  • An outliner. Everything in Leo is an outline.
  • A Personal Information Manager.
  • A browser with a memory.
  • A powerful scripting environment.
  • A tool for studying other people's code.
  • A fully-featured IDE, with emacs-like commands.
  • Extensible via a simple plugin architecture.
  • A tool that plays well with IPython, vim and xemacs.
  • Written in 100% pure Python
  • Compatible with Python 2.6 and above or Python 3.0 and above.
  • A tool with an inspiring and active community.
Leo's unique features:
  • Always-present, persistent, outline structure.
  • Leo's underlying data is a Directed Acyclic Graph.
  • Clones create multiple views of an outline.
  • A simple, powerful, outline-oriented Python API.
  • Scripts and programs can be composed from outlines.
  • Importers convert flat text into outlines.
  • Scripts have full access to all of Leo's sources.
  • Commands that act on outline structure.
    Example: the rst3 command converts outlines to reStructuredText.
  • @test and @suite scripts create unit tests automatically.
  • @button scripts apply scripts to outline data.
  • Outline-oriented directives.
Simulating these features in vim, Emacs or Eclipse is possible, just as it is possible to simulate Python in assembly language...

Links

Friday, April 29, 2016

Leo 5.3-b1 released

Leo 5.3-b1 is now available on SourceForge. Leo is a PIM, an IDE and an outliner.

The highlights of Leo 5.3
  • Leo now supports Jupyter Notebook (.ipynb) files.
  • @chapter is now allowed anywhere. No need for @chapters.
  • Faster spell checking.
  • The rst3 command supports @rst-table.
  • The show-invisibles command now uses native Qt characters.
  • Dozens of other improvements and bug fixes.
Leo is:
  • An outliner. Everything in Leo is an outline.
  • A Personal Information Manager.
  • A browser with a memory.
  • A powerful scripting environment.
  • A tool for studying other people's code.
  • A fully-featured IDE, with emacs-like commands.
  • Extensible via a simple plugin architecture.
  • A tool that plays well with IPython, vim and xemacs.
  • Written in 100% pure Python
  • Compatible with Python 2.6 and above or Python 3.0 and above.
Leo's unique features:
  • Always-present, persistent, outline structure.
  • Leo's underlying data is a Directed Acyclic Graph.
  • Clones create multiple views of an outline.
  • A simple, powerful, outline-oriented Python API.
  • Scripts and programs can be composed from outlines.
  • Importers convert flat text into outlines.
  • Scripts have full access to all of Leo's sources.
  • Commands that act on outline structure.
    Example: the rst3 command converts outlines to reStructuredText.
  • @test and @suite scripts create unit tests automatically.
  • @button scripts apply scripts to outline data.
  • Outline-oriented directives.
Simulating these features in vim or Emacs is possible, just as
it is possible to simulate Python in assembly language...

Links

Saturday, March 19, 2016

Leo 5.2-final released

Leo 5.2-final is now available at SourceForge.

Leo is a PIM, an IDE and an outliner.

The highlights of Leo 5.2
  • Easy install with PyInstaller packaging
  • c.cloneFindByPredicate
  • clone-find-marked commands
  • decorators create all Leo commands
  • find-def and find-var
  • help-for-keystroke
  • --ipyhon command-line option works with latest IPython versions
  • Optional line numbers in the body pane
  • show-invisibles uses Qt characters
  • Themes
  • Wildcard file names on Leo's command line
Links

Tuesday, March 15, 2016

Leo 5.2-b1 released

Leo 5.2 b1 is now available on SourceForge. Leo is a PIM, an IDE and an outliner.

The highlights of Leo 5.2

- Easy install with PyInstaller packaging
- c.cloneFindByPredicate
- clone-find-marked commands
- decorators create all Leo commands
- find-def and find-var
- help-for-keystroke
- The --ipyhon command-line option works with latest IPython versions
- Optional line numbers in the body pane
- show-invisibles uses Qt characters
- Themes
- Wildcard file names on Leo's command line

Links

Leo's home page
Documentation
Tutorials
Video tutorials
Forum
Download
Leo on Github
What people are saying about Leo
A web page that displays .leo files
More links

Edward K. Ream
March 15, 2016

Tuesday, November 24, 2015

Why Leo is Noteworthy

This post discusses what I think matters most about Leo. This post assumes you are an experienced Leo user. It does not try to duplicate Leo's Tutorial.

Leo is a superb tool for understanding, studying and organizing any kind of complex data, including computer programs. The first great Aha in Leo's history was that webs (literate programs) are outlines in disguise. Leo's importers (@auto) make it easy to studying other people's programs. Leo's always-present outline structure clarifies overall program structure and makes many kinds of comments unnecessary.

Leo is a superb browser for code and data. Unlike many other folding editors, Leo remembers which nodes were expanded when you last saved an outline. This is surprisingly important. And Leo's clones let you organize any data as you want, even if all folds are collapsed.

Leo is a uniquely powerful scripting environment. This power comes from three sources: Leo's API, Leo's ability to compose scripts from outlines and Leo's underlying data structure, a Directed Acyclic Graph, the basis for Leo's clones.

Leo's API consists primarily of generators, such as c.all_positions(), p.self_and_subtree(), etc. and properties, such as p.b, p.h, p.gnx and p.v.u. Leo's API makes it trivial to write scripts to access or change any node. AFAIK, these capabilities are unique. Simulating them in vim or Emacs is possible, but so is simulating Python's capabilities in C...

Afaik, no other scripting environment allows you to compose scripts from outlines. @file, @clean, @auto, @others and section references and definitions make this possible. Section references and definitions are modeled on the noweb language, but all of Leo's script composition features are fully integrated into Leo's outline structure.

Leo's outline nodes have headlines (p.h) and body text (p.b) and extensible information (p.v.u). Headlines are descriptions (meta-data) of the data in p.b and p.v.u. Scripts can rapidly discover and categorize data using metadata. Leo's @ convention for headlines (@clean, @file, @auto, @html, etc.) show how extensible this node typing is.

So much for the theory. The following also are important in practice:

The invention/discovery of @clean earlier this year completes Leo in some sense.

Acknowledgements: Working with Leo's community of Leo's developers and users has been a great pleasure for over 20 years. My only regret is that Bernhard Mulder and Bob Fitzwater are no longer with us. Both made essential contributions. Bob Fitzwater was my mentor. He gently pushed me to consider design, not just "bit twiddling". Bernhard Mulder contributed two of the most important elements of Leo: Leo's traversers (generators) and the original @shadow algorithm. Neither @clean nor the revised Mulder/Ream algorithm could possibly have happened without him. I miss both these great thinkers. Both would have been proud of what they helped create.

A successful software tool is one that was used to do something undreamed of by its author.' -- Stephen Johnson
Leo is a wild success on this score. I foresaw none of these developments 20 years ago: Leo's minibuffer, @button, @test, @auto, @clean, Leo's plugin architecture, the rst3 command, the Leo bridge and the IPython bridge. Surely many other features and uses could be added. None of these would have happened without Leo's community of brilliant people. These features create the Leonine world. Who knows what will be the result...

Edward

P. S. As I write this, I see that @button is nowhere mentioned in Leo's History Chapter. That's crazy: @button is arguably the most brilliant scripting idea ever created anywhere. Many thanks to 'e', whoever you are. I'd like to thank you by name. @button lead directly to @test.

EKR

My last lecture: Reading List

If I remember correctly, in Larry Niven's novel Ringworld, one of the characters says something like "our scientists have proved that God does not exist". At the time I wondered whether how such a statement could possibly be proved (or disproved).

Years later, after reading several books by Stephen Jay Gould, including The Panda's Thumb, it gradually dawned on me that Charles Darwin did, in fact, begin that proof, by showing that the Argument from Design is fallacious. Yes, it's natural to believe that plants and animals are designed, but in fact the "designer" is evolution, not a supernatural being.

In fact, the evidence for atheism is overwhelming. For those who still believe in belief, I recommend the following books:

These ideas may seem profoundly threatening. That need not be so. Atheists, like everyone else, feel love, beauty, spirituality and other selfless or transcendent emotions. Atheism does not diminish these aspects of life, it simply explains them as arising from evolution. People don't need non-existent beings to be happy, to live morally and with a sense of purpose. We create our purposes. Nothing else does.

Enjoying the discoveries of science is one my great pleasures. In particular, the theory of evolution is the most beautiful, elegant, fertile, powerful and successful scientific theory ever created:

My last lecture part 2: dealing with the world as it is

This is part 2 of My Last Lecture. It describes my dealing with the world as it is.

The practice of mindfulness promotes an equanimous, happy and compassionate life. It creates a visceral sense of connection and compassion with others, even those whose beliefs and actions we profoundly disagree with. Here are some resources:

A compassion meditation for time of war. I remember weeping during this meditation as my anger about 9/11 shifted.

Practicing Mindfulness: An Introduction to Meditation by Professor Mark W. Muesse. This superb introduction might be the only guide you will ever need. I have gotten great benefit from two contemplative practices discussed my Prof. Muesse:

The Impermanence of All Things. This leads me to appreciate what is here, right now

Just Like Me. For me, this practice reinforces the compassion developed in "A compassion meditation for time of war" mentioned above.

In addition, I recommend two more practices:

Mudita is my primary antidote for envy. Mudita is the delight in other people's well-being, accomplishments and good fortune. I cultivate mudita by going where people are enjoying themselves, say by riding a bicycle around Madison on a beautiful summer day. If you want to be happy, practice mudita and compassion. If you want to suffer, envy others and enjoy schadenfreude.

Laughter yoga. A great way to connect with people and to remove barriers to joy.

That's it. In the long run, we can't know whether our actions are solutions, mitigations, or entirely useless​, ​but in the short run​​ they certainly will have some effect.