Action Journaling (AJ) is a way to quickly render journal entries and todo lists into plain ASCII text. I’ve worked on various aspects of these ideas since 1995, starting with “Marked Text” (MTX) a format for generating HTML. (To give credit, my original inspiration probably came from Setext, which was popular at the time.) The original mtx2html was implemented in HyperCard (wow!) and then ported to Perl (which remains my language of choice today).

action-journal-example

Roll forward to the mid-2000s when I began using a paper notebook. I gradually developed an ad hoc system of marginal checkboxes and other symbols to indicate the status of entries. In 2012 I added an AJ prototype to our PTM development. I recently decided to harmonize my paper symbology with the ACSII-based system described below.

Why use ASCII? Because plain text (encoded as ASCII) remains the most versatile and portable format for digital information. Standardized in the 1960s, it underpins most communication and data exchange today. (Note that newer encoding schemes such as UTF-8 have ASCII at their core.) The basic challenge was to map my paper symbols to punctuation characters in a visually meaningful way. At the same time the format had to be machinable and compatible with many types of software. This includes maintaining a valid order when sorted. The symbols below are as close to a “best fit” as I’ve achieved. Other variations are possible of course.

The role of whitespace is fluid at this point. A basic AJ engine would probably delete blank lines, tabs and leading spaces; then either combine unmarked lines with the line above or add the default (.) prefix. Both approaches have merit and this choice is left to the specific implementation or personal preference.

AJ is compatible with the fundamental concept of “Do, Defer, Delegate, Delete” found in popular time management techniques such as Getting Things Done (GTD). The relevant symbols are starred (*) below.

Prefixes

Except for deletion, these must appear as the first character on a line.

. = todo
! = priority
? = unsure or need more information
` = non-action note or FYI item
~ = done * (sorts to the end of the list)
> = defer * (move to another list)
< = delegate * (assign to someone else)    
    delete * (use ~ to preserve item)

(ASCII sort order: ! . < > ? ` ~ )

Note that many pen & paper journalers draw lines through unwanted items and these deleted entries remain readable. In the above format deleted items are completely gone unless captured by a backup or log. An alternative is to mark them with the ~ done symbol.

Ordered Lists

Sometimes activities must be undertaken in a specific order. To specify an order use digits after the leading symbol as shown here.

.1action
 .2action
 .3action
 ...
.9action

If there are more than 9 steps, pad with zeros to force the correct numerical sort order.

.01action
.02action
 .03action
...
 .99action

To simply indicate what you intend to do next use the priority (!) prefix.

 !do next
 .action
.action
~done
 ~done

Suffixes

The following line endings are useful as targets for filtering email, searching for essential entries, or just adding emphasis.

?? = Pending Question
!! = Important/Critical
-> = Action Taken/Resolution

I’m sure you can come up with others.

Compound Notation

PTM uses a three part format to fully specify activities and their context.

project.task.action

(The default delimiter is a dot (.) but can be replaced with !?~ etc.)

An Action is a discreet item that can be acted upon. A Task contains one or more activities. (A task without activities is just an idea waiting to be fleshed out.) A Project is a collection of tasks required to achieve a higher-level goal. For the purpose of data exchange PTM uses this structure for import and export. Notice that sorting can occur on either the task or action level. Otherwise it will be alphabetic/lexa.

 @Project X!Task A.action
 @Project X.Task A!action
 @Project X.Task A?action
 @Project X.Task A~action
 @Project X.Task B.action
 @Project X?Task B.action
 @Project Y.Task C~action
 @Project Y~Task C.action

For compatibility with PTM and various file systems these project prefixes are equivalent.

 Project X.Task B.action
 .Project X.Task B.action
 @Project X.Task B.action

When working with a single project, this shorter form will suffice.

!Task A.action
 .Task A!action
 .Task A?action
 .Task A~action
 .Task B.action
 .Task B?action

You can also cut and paste todo lists from any plain text app.

!action
 .action
 ?action
 ~action

Note that each of the examples above will sort differently. Project and task status is determined by the first line where the item appears. Software should clean up subsequent items that do not match. In general it is assumed that a task cannot be finished until all its dependent actions are done. Likewise for projects and tasks.

Additional Considerations

Not all handwritten journal conventions translate completely, the Defer (>) and Delegate (<) symbols for example. In a paper journal there can be room to the left of an item to add the name of the new owner of that task or action.

joe < [x] action

In this example the original entry was just “[  ] action“. Later when I decide to delegate to Joe I add the “joe <” designation. (This makes visual sense on paper.) When the handoff is complete I check it off with an “x”.

There are similar considerations with Defer.

june > [x] action

In ASCII format these might translate something like this.

<action -> give to joe
>action -> bring back in april

And when complete.

~action give to joe
~action bring back in april

Notes (`) are non-actionable and relate the parent task. It is likely some software might strip them out of the list and store them as task metadata. A contact phone number is a good example.

`Call Lisa at 555-4444 with questions

Metadata

In addition to line-oriented notes AJ supports the generalized tagging convention found in Notational Velocity and other open-source software…

@due(2016-07-01)
@done(2016-04-15)
@remind(2016-05-06 08:00)
@link(http://notational.net)
@tags(todo lists, plain text, ASCII)
@time(01:45)

The generalized format is…

@name(value)

Tags can appear in place of notes (`) or at the end of a line…

.action @due(2016-07-01)
~action @done(2016-04-15)
@note(Call Lisa at 555-4444 with questions)

Items that begin with an at-sign (@) not followed by a value in parentheses are assumed to be project names. This is another PTM compatibility tweak (see above).

Use and Share!

Action Journaling (AJ)™
Designed by Richard Rathe
 People : Tasks : Meetings® (PTM)
 Attribution-ShareAlike License
Version 1.2 Updated June 2016
 Working Document Subject to Change