Re: Idea For Semantic Text-Based GTD Application

Hello Maciej,

On ג', 2013-07-02 at 12:09 +0200, Maciej Piechotka wrote:
On Sat, 2013-06-29 at 17:52 +0300, אנטולי קרסנר wrote:
Hello everyone,

This is a draft of the Quick Start part of a tutorial I'm writing for a
data definition language I made.

The language is currently called Idan. It can be used by anyone,
including non-programmers, to define data models (classes, properties,
objects) and then define data accordingly, all in simple syntax and
plain text.

Once the language is ready I'll write the software for it, which can
read files and manipulate them.

*** Motivation: ***

Data models are usually written by the programmer, and a user can't
change them. If you want to have a customized system for outlining and
todo-list or task dependency hierarchies, either you use plain text or
Emacs org-mode.

Org-mode is great, but it means you need to use Emacs key combinations.

TaskJuggler language exists too, but it's aimed at somewhat technical
people who need the tool for serious usage.

Idan is simple enough for anyone to use, with Python-like syntax and
minimal clutter, and the software will allow connection to RDF, and all
kinds of reports and queries, thus allowing to have all the GUI you
want, combined with the ability to alter the model by hand and see
immediate results.

Text formats for task lists already exist, but Idan aims to be a
general-purpose model definition language, and has features for
out-of-the-box export to databases and external languages such as RDF.

Sorry for sounding negative - I've never used org-mode or TaskJuggler
and I don't know how to use them. My 'complains' are probably simply
unfamiliarity with this class of tools.

That's okay, me neither to be honest. I'll give some examples now.

Unfortunately I fail to see what problems you are trying to solve. Could
you provide a scenario where it would solve some problem (what user
would be doing from POV of user)? Possibly 2 to show the generality of

Of course.

One notable example is the increasing popularity (at least it seems to
increase) of text-based task handling and GTD techniques.

Many blogs and websites mention the issue, like this one:

Also, some smartphone apps (especially proprietary ones) use a simple
text-based approach:

I don't have other concrete examples, only tasks and project management.
But I can explain the concept in general.

Imagine you have many tasks, and you can't remember them. You decide to
find a desktop app which can store your tasks. You start with a plain
text file, but you realize it cannot sort your tasks by date or by tag,
and automatically filter tasks based on location or completion status.

You go to Gnumeric or LibreOffice Base. But now your long text
descriptions of tasks look ugly there, and you can't make the
spreadsheet display a clear hierarchy of task dependencies.

Okay, you decide to try a to-do list desktop application. The problem is
that each person has a unique mental model, and no app fits everyone's
usage patters. But most people are not aware of that. You try one simple
app, and discover it doesn't support task dependencies, and remove it.

Now you install several new apps and try them. One supports
dependencies, but doesn't support tasks with more than one "parent"

You try another one, but it doesn't support tag hierarchies.

Then you try another one, but it doesn't support sync with your mobile

At this point we reach an ironic situation: On one hand, tasks are a
very simple data structure, and the minimal technology required for
managing them is pen and paper. In the computer, simple Bash scripts can
be enough, or even a tiny C or Python library. No special technology is

On the other hand, finding the perfect app for you may be difficult, and
even impossible if you have serious usage patterns and need topics
hierarchies and task hierarchies and task sharing.

The solution offered by Idan to this kind of problem is to move the
modeling process from the program to the user! Or at least to a person
who is not necessarily the one who writes the code.

Programming languages model two kinds of data:

1. Helper utilities which don't correspond to any real object, and exist
only for the program. For example, I/O streams in C++, or error

2. Computer representations and descriptions of real life meaningful
objects, which are usually read from files and written back to files.
For example: e-mail, notes, tasks, contacts, documents, source code,
pictures, movies, music.

The first kind is in the responsibility of the programmer, and nobody
else should care. But why should the programmer be responsible for the
second kind? Music, video, source code and many other file types have
specific formats and encodings. Then why don't tasks have a format too?

The issue of semantic data storage and sharing exists for long time, and
one of the common solutions is RDF, with Tracker being the main semantic
datastore for the Gnome desktop.

But RDF is a professional solution: It's used after a clear well-thought
ontology has been designed, and cannot be used easily by

With Idan, you can define your own model and have your data, e.g. tasks
and projects, managed *your* way. Once you write the files, the
software's job is as simple as inserting the data as RDF into a
database, and showing query results.

It also means more work can be done in parallel to programming, so
contribution to free software can be done by more people, and more work
can be done by people who are not the module programmers.

I got the idea after trying many many many Personal Wiki apps and
personal diary apps and GTD apps and project management apps, and
realized they all have the same problem: Their data model is limited to
what the programmer wrote, while in most cases (the exception being the
cases where special algorithms and GLPK are used) the algorithms and
simply filters, sorting, merging, matching, etc. which can easily be
performed on a user-defined model.

If you have a few minutes to go over this file and tell me what you
think, I'll be thankful. It's s short quick-start tutorial. A primer.

Sorry for complaining but usually it is much better idea to put the
source code then binary file in repository. In that way not only you can
get contributions but also vcs are handling text-based formats much
better then binaries.

I totally agree, I never put binaries in the git repo. The file in the
link is a PDF file. If I had web hosting, I'd just post a link to the
HTML version of the document.

When code is available, you can be sure it will be available freely on
Gitorious, including the source (CherryTree file) of the tutorial and
all other text documents :)

To the format:
 - Do you and if you do how are you trying to internalisation? Should
user use Task even if (s)he does not know the English? Or maybe the idan
files are paired with gettex translation?

Very good question. I plan to support i18n directly, without making the
user touch technical tools like gettext. Currently identifiers contain
only English letters, but it's just for simplicity of the draft. I'll
investigate the option to allow any characters (except for comman,
space, etc.) without making the code ambiguous in any way.

I do want to allow people to name classes in their own language. Of
course, for serious shared models, it would be possible to define both
English names and translations, and this can be done by pointing to
Wordnet names, or using gettext.

 - Possibly a small thing but I would change <> to * or many prefix (for
example "many Topic topic" instead of "Topic<> topic")

I knew people would say that :D

The reason I use <> is that the <> can be used to specify cardinality.
For example, in the following code:

class Community
        Person<3:7> leader

It means there can be between 3 and 7 leaders. <> is simple the result
of omitting the numbers, thus resulting in unlimited cardinality. It's
somewhat like Slices in Python, in which [:], IIRC, is used to create a
whole-array slice.

Thanks again for the input!

Soon I will upload the whole tutorial draft.


Best regards

Thanks in advance,


On ג', 2013-06-18 at 05:32 +0300, Luc Pionchon wrote:
On 17 June 2013 09:43, אנטולי קרסנר <tombackton gmail com> wrote:
Hey Luc and list,

I've been planning and designing a language for data modeling and
description, somewhat based on concepts borrowed from Python (which I
learned in the process).

I'm now writing a tutorial, and it looks quite simple and
straight-forward, and the language is very simple. Very soon I'll finish
the tutorial and I'd like to have it reviewed and hear comments and
advice. Is anyone interested?

if you publish it somewhere, I'll have a look

With a polished language I'll be able to proceed and write a parser and
command-line tools, which can serve (with their underlying library) as a
base for larger systems and GUI app integration (Gnote, GTG, etc.)


On ד', 2013-05-29 at 21:10 +0300, Luc Pionchon wrote:
Hi Anatoly,

if you really get such simple enough language, you certainly will get
some users.

I see you are planning for more usages, though about TODO apps, did
you see todotxt [1] which is basically a text based todo/GTD. They
have a relatively simple language [2]. Is it similar to what you are
thinking about?


I think you should go ahead and start to write examples, so people
could grasp it, and you will also get a better view of the

Don't care much about "user testing", it's up-side down business
thinking. Do something useful, and you'll get some users.

go ahead!
In any case that is certainly a good learning experience

On 29 May 2013 18:02, אנטולי קרסנר <tombackton gmail com> wrote:
Hello everyone,

I'm an individual not working on any Gnome module. I'll try not to get
into much detail (likely to fail on this one), but here's the idea I

After reading about existing GTD software tools I made the following

* There are GUI tools
* There are plain-text solutions
* There are pen-and-paper solutions
* There are text-based applications

GUI tools have lots of features and visual widgets, but they somehow
fail to satisfy most people. At the same time, plain text seems to
become more and more popular. After reading I made these conclusions:

* Each person has her own way of thinking, her own way of how the brain
works. Therefore, each person should have a personally tailored solution

* GUI tools, and GTD tools in general, tend to make the false assumption
of "everyone is like me" and "one size fits all", which is why most
tools fail to become widely popular.

* Emacs Org-Mode is quite successful as a GTD tool, thanks to its
flexibility and extensibility, but lacks an intuitive interface, which
limits its adoption despite the success of Org-Mode

* A next-generation tool should have the extensibility of a plain-text
system, and the convenience, ease-of-use and efficiency of a visual tool

Therefore, I decided to create a language for definition of properties
and classes, intended for be used for describing tasks, timelines,
projects, etc. This language is easy enough for non-programmers to use,
and yet is expressive enough for practical use. It borrows concepts from
RDF, OWL and scripting languages.

On top of this language there will be a set of text-based tools allowing
easy manipulation of the text. It means users can edit the files in
plain text, but also have convenient tools and utilities for easier
processing and visualization, similar to Org-Mode.

On top of that there may be task/project-related definitions, a
specialized text editor and/or Gedit plugins, and a flexible GUI app
which replaces the "one for all" concept with a "personally tailored to
a user's mental model" concept, which seems to work very successfully
with plain text and Emacs Org-Mode.

Existing free software I found:

- Gedit (Gnome's plain text editor, extensible with plugins)
- Emacs Org-Mode

That's all. All other tools, including all GTD and To-do apps for
Gnome/GNU, are either scripts intended for power users, or have a
limited scope which is not flexible enough to customize.

An existing GUI app for GTD called Getting Things Gnome (GTG) has great
potential, but I'd like to back it up using a flexible text-based
approach which is then used to describe semantic entities and attach
them to program objects. This would supply both the flexibility of text,
the convenience of GUI and automatic translation to RDF, which means
instant Semantic Desktop integration (using Tracker and Zeitgeist).

*** The Question ***

My question is, what do you think? Does this idea sound useful? To me
personally, it seems to fill the gap between plain text (which has no
visualization and productivity utilities) and convenient GUI (which
current is mostly not flexible enough).

NOTE: Non-free software already exists, which uses plain text as a
backend, such as Taskpaper:


desktop-devel-list mailing list
desktop-devel-list gnome org

desktop-devel-list mailing list
desktop-devel-list gnome org

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