[Edu-sig] 'Leo' => folding editor for Literate Programming

[Jason Cunliffe]

Hi Arthur

> The article seems to position Leo as a serious production programmers tool.
> A learning curve it seems to me worth tackling after one has become a
> serious enough programmer.

Yes. But but besides the exisiting professsional needs of large coding projects,
I do believe Leo offers a valuable emerging new paradigm, one which may find its
best home with beginners and people in small collaborative groups.

Actually it is not a so new.. StorySpace, Hypercard, Smalltalk.. etc
As you know I am easily enthused. But I was not trying insist or impose a
meta-tool like this on beginners, though some may love it. Nor on people happy
and productive with reliable flat text files. KISS works. One of he strongest
arguements against LEO is that is makes files main dependant on the application,
or at least noe wihdih wknows what to do with the format. It is not restricted
to that, as you will see if you sue. You can 'flatten', import adn export in a
variety ofways. Just like Photoshop from a multi-layered image complete with
masks, paths, and macros.

1. I was thinking towards the needs of embedding code within other structured
con-text. Like a good textbook, web how-to article, and so on. All of those
could now be managed in a way which pemits lineaer flat files but also allows
incremental versions to be run dynamically within the surrounding text.

2. It might make collaboration easier.

3. It might help the transition from concept to pseudocoide to source code
easier.

4. It might encourage people to more freely step out and into their code. That's
usful for both analytic and creative parts of programming. There's a good reason
why many people love text-folding and colored syntax highlighting. It makes it
easier for them, though not perhaps everyone. Mathemtica's revolutionary
'Notebook' interface is a good example of how one can combine hands-on
programming with document structure and publishing/presentation needs.

Blogs are contemporary example of similar trend. Distrubuited publishing via RSS
and XML-PRC mechanisms. Expandable code cia short form presetation of articles
with "more..." and "comments.." links. Better separation [and integration] of
form and content. XML, CSS, theme, author, style/idnetity, calendar-based
sequences of related and un-related content provide a ean way for people to
follow the progression.

5. XML for better and worse is here to stay for at least a generation. The need
to handle that alone is good argument for tools like LEO. Suppose you want to
start discussing a pprblem and then build data model with your class. You can
start with simple needs adn observations, collect several versions from stuents,
merge adn improve the best candidates, write parser code and methods for
handling the models etc.. Tedious and hard to do with regualar editors. Perhaps
not solo, but in a group class siutatnio wher you want ot build up the workabee
able to review it, pehaps extend with anouth school or class. You could use CVS,
but here is a tool in Python for Python. sweet and manageable.


> Can't help using myself as an example.  My position has been that time that
> might be spent learning programming tools is much better spent, at my stage
> of things, learning programming. And I am pretty well convinced that the
> type, cut, paste and run text editor with which I have become somewhat
> facile is all the tool I need at this point.

I do not doubt that. Once one can type even modestly well on a QWERTY keyboard,
all other keyboards layouts are a painful distraction even if they are
theoretically much better!

But there is often great value in approaching problems from several
perspectives. That's what my favorite Math teacher was good at when I was 14.

If you were starting out without the habits you have now, you might be very
appreciate of a tool which lets you go smoothly from high level to low level and
back. Like the Zoom in a graphics app. Unthinkable now without it. Or resize on
for windows, scrollbars, etc. What about indentation in Python. Expressly to
clarify and simplify the code while imposing a consistent structure. Ditto
docstrings. LEO appears to be a healthy product of those initial design
decisions.

The best argument I can make for LEO-like interfaces is that in the *right*
hands they can improve thinking, design, understanding and presentation.

It will take time to get these tools into a really good balance netween power
and simplicity. The fist adn 2nd generation of Web development has sadly sold
people on an extremely chaotic model where linsk typically take you *away* from
the context. The rapid growth of Community Wikis alongside individual Blogs show
people want better management of gathering and sharing their ideas, discoveries
and work. I consdier the 3rd gernation of the Web now playing out. I think it
much healthier than what came before.

> Nor will I let myself buy new golf clubs til I break 90 with some
> consistency.  Because I know the clubs ain't the problem, and only when I
> become better will I be able to take advantage of what is better about
> better clubs.

Granted. But remember, LEO is free btw, unlike those shiny new gold-plated
titanium tipped, dayglo golf clubs you don't really need!

./Jason