Re: Idea For Semantic Text-Based GTD Application

Thank you for sharing your opinion.

I agree a general-purpose structured language is not suitable for
end-users. I looked at some existing languages and examined their
nature, and I couldn't find any easy one. The most simple
general-purpose is probably the Turtle notation for RDF, but it's still
too complicated for end users.

Thus, I decided that my language will not have full expressive power. It
will define general entities, but once concepts like tasks and calendars
are defined, the usage is as simple as defining which properties you
want your tasks to have.

And it only becomes easier and easier: Once a standard set of properties
is written (due date, name, title, description, topic, location, etc.),
most people won't even need to write code. If they want, they may choose
the properties required for a task, and this way simplify the view by
hiding what they don't use. Or just choose the properties they want from
the list.

For example, some people don't arrange tasks as a graph, just as a list.
So they can ignore the dependency features and just see a simple list.

Once standard simple query tools are defined, and use the standard
properties and classes, even most queries will become easy to write.

And the best part: Everything too advanced from the user can be
downloaded from a repository. Once people start writing definitions, the
end users who are not programmers can simply download the tools, instead
of trying to write them.

With time, people with all kinds of workflows and technical skills and
fields will create a database of free definitions, tools and settings,
making the experience of end users convenient, both in the workstation
building process and during daily usage of it.

So, while I try to provide wide and expressive range of concepts, the
actual usage of the language for time management and related life
hacking will quickly become very simple, even for non-programmers. Like
I said, they basically just need to choose properties, and choose the
visualizations they want to see. And with a wide range of properties and
views, I hope every user will be able to create a personal setup.


On ד', 2013-05-29 at 11:26 -0400, Jasper St. Pierre wrote:
I'm not sure. Obviously, we'll see how it works out in practice, but
research has shown that even "basic" structured text languages are
hard for end-users and consumers to grasp. To most people, the
flexibility in text is its lack of structure, which allow people to be
creative and express themselves.

org-mode doesn't enforce any structure beyond some basic syntactic
elements to mark free-flowing text as items (bullet points), and while
it comes with a stock set of keywords (TODO, DONE), these aren't
hardcoded at all and most complex org-mode flows add their own
keywords or things like that.

The actual words, and the order of them, doesn't matter. So I feel
that a structured text-based approach would simply fail because it
doesn't allow for such flexibility.

New research is always welcome, and if you manage to get random
end-users to fluently understand your language system through
concentrated user testing, I'll gladly welcome it.

On Wed, May 29, 2013 at 11:02 AM, אנטולי קרסנר <tombackton gmail com>
        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
        * 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
        fail to satisfy most people. At the same time, plain text
        seems to
        become more and more popular. After reading I made these
        * 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
        of "everyone is like me" and "one size fits all", which is why
        tools fail to become widely popular.
        * Emacs Org-Mode is quite successful as a GTD tool, thanks to
        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
        system, and the convenience, ease-of-use and efficiency of a
        visual tool
        Therefore, I decided to create a language for definition of
        and classes, intended for be used for describing tasks,
        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
        processing and visualization, similar to Org-Mode.
        On top of that there may be task/project-related definitions,
        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
        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
        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
        approach which is then used to describe semantic entities and
        them to program objects. This would supply both the
        flexibility of text,
        the convenience of GUI and automatic translation to RDF, which
        instant Semantic Desktop integration (using Tracker and
        *** 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
        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


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