[Top][All Lists]

[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]

Re: yet another todo editing system

From: Joe Corneli
Subject: Re: yet another todo editing system
Date: Sun, 08 Jun 2003 07:32:57 -0500

Dear Thi,

Well, your point of view seems well-informed.  Mine certainly isn't;
consequentially I probably stand to benefit from wading through a
certain about of "verbiage" and _not_ discarding it.  True enough,
education in the ways of free software wasn't what I was explicitly
looking for - but implicitly it was, at least in part.  I'll take it
when I can get it.

What follows isn't _very_ technical, but its a reasonable overview of
what I want compared with what is out there.  It doesn't look like there
is anything _too_ hard -- but neither does it look like there is
something that does _exactly_ what I want.  These are things I could
use advice on but that I don't necessarily _need_ advice on in order
to proceed.

My methods for finding relevant packages were: (X) seaching EmacsWiki
for 'todo' and following links that came up, particularly links at


(Y) reviewing what I learned from a webpage with lots of comments by Kai
Grossjohann that I randomly found during a websearch yesterday at Google
groups for 'emacs rmail email "HTML mail"' -- the tenth item returned
turns out to be an interesting discussion of various todo modes, the
long link is this:


and (Z) downloading and installing everything that seemed particularly
relevant, trying it out, and browsing the documentation.  

Results of this investigation: the package hyperbole seems to supply a
good bit of the same functionality as my "todo" program -- in particular,
if I made a buffer "example" that looks like this:


and I had a file "list" in the right path that looks like this:

    Lists are the basic building blocks of Lisp
    They are also the basic building blocks of most Todo modes

then hitting "C-h h a" when my cursor was on the word "list" in the
buffer "example" would cause a new buffer containing the file "list"
to open up in Emacs.   You can see how this can be used to browse
one-word lists.   If I hit "C-h h a" when my cursor is on the line

    Lists are the basic building blocks of Lisp

in the buffer "list", then who knows what will happen.  Presumably I
could write some macros that would get my files to open up so that
hyperbole will automatically parse each line as a "button", so that I
could get the above-quoted line to point to a file "lisp", say.  I
haven't found the details yet, but this doesn't seem like it should be
too hard. I'll have to dig further into the documentation for hyperbole
is all.

For now, it looks like this combination will provide essentially the
same information as the lists that I _exported_ from my todo program.
(Which, for those of you new to this "thread", is available at


together with several examples and a bit of documentation.) 

What I'm not seeing here is the neat "up" feature that my program 

Description of todo's "up feature":

When you are viewing a list and you submit the command "up", one of
three things happen: if the current list has exactly one "client", that
client is displayed and gets the focus of the program.  If the current
list has more than one client, you are prompted with a list and told to
choose one.  Assuming you manage to do that alright, focus shifts to the
chosen one as above.  Finally, if the current list has no clients you
get an error message.

Clientele information is developed in real time as users add
information to the "todo database".  Each list with clients contains
a "hidden" link to the list of clients, and this list is adjusted
every time the user does something like add a link from file A to 
file B  or delete a link from file A to file B.

This feature is useful for figuring out who cites what.  For example,
what definitions in math dictionary rely on the definition of a group,
or which papers in an annotated bibliography refer to John Doe, 1984.
It might also be useful for doing mathematical computations (assuming
someone wanted to do computations within the framework of the todo
database for some reason).

This "up" business seems serious, but probably by no means fatal.

On to something new. Here is something I would _like_ to have in my
ideal list editor: the ability to take a list element such as

    Lists are the basic building blocks of Lisp

and generate from it a new list something like

    are the 
    basic building blocks 

where presumably each element of the new list is defined by something in
the extant database of entries (or if not defined at least related
somehow, perhaps just as a representative of a semantic category in the
case of "are the").   I don't see much problem with writing a function
in Emacs that would break a string up in this way (or any number of
other ways) -- so this probably isn't a sticking point, assuming that
everything else I've mentioned so far works.

The example above reminds me of another feature of my program: the
ability to describe each element of a list with a one-letter tag.  Maybe
each element would be marked up with a hint as tothe part of language
that it comes from:

      <N> Cat
      <V> Run
      <a> Fast

or some such thing.  These tags can be used (at least in theory) to
generate markup in the exported document.  Maybe I want to export to
colorful HTML and get each noun to be green, each verb to be yellow, and
each adverb to be blue.  Figuring out how to do this with hyperbole --
and figuring out how to export the files once they are tagged -- seem to
be the last of my problems with "porting" my program.  Porting is in
quotes, because except for exporting to formats that use only very
trivial markup, I haven't yet gotten around to getting this done in my

Anyway, it doesn't seem likely to be too hard to export lists once 
they exist, so I don't think this will be a sticking point.

That means the only thing that poses a real challenge is "up", and that
should be pretty doable.


PS. Another question is whether it mightn't be nice to make everything
colorful, a la outline more for example; I'll plan to worry about
that later.

reply via email to

[Prev in Thread] Current Thread [Next in Thread]