Nesting is besting

FEBRUARY 25TH, 2016 — POST 052

I can’t seem to find a to-do list app that works for me. I first tried Wunderlist, then Remeber The Milk. For a long time I was trying to get Gneo to work but, despite good design, it always felt too laborious. The Evernote round trips that (barely) made it viable on desktop always had too much friction. I dipped into OmniFocus on OS X but I’m priced out of the market at $60. The one that has stuck the longest with me is the default Reminders app, one that with a few mumbled words into Siri can keep track of my tasks. I think part of my problem is I don’t know what I want from a to-do list app. In any case, I’m still on the lookout for something that instantly clicks with me like so many of my favourite apps have done in the past. In that vein, I downloaded Todoist yesterday. Whilst the app itself seems fine, it hasn’t (yet) clicked for me and for the premium price tag of $49/year I can’t see myself sticking with it. It does however implement a feature that I love. Tasks can be given a parent task: you can create (seemingly endless) subtasks. This concept is in no way unique to Todoist, it is applicable in conceivably any instance where information is presented linearly. The concept is nesting.

Nesting is a basic concept in computing in which one piece of information is placed, “nested”, within another piece of information. As it applies to programming, it is a simply how things are done. Even with minimal HTML knowledge, I understand the opening and closing of tags is an example of defining primitive nests and their necessity in coding.

<body>
<div>
<p>
</p>
</div>
</body>

But this isn’t the application I’m interested most in. Specifically, when nesting is a software feature, giving the user the capacity to play a linear string of information like a contracting and expanding accordian, is when I’m usually hooked. What’s really surprising is how few applications implement it.

To understand the significance of nesting for me, I like to look at the typewriter. Into the typewriter one feeds a single sheet at a time. The typing is done directly onto the page, in a sense the piece of paper is the interface, and the user formats on the fly. The user works within the confines of the sheet of paper because that’s all the machine can do. The sheet of paper is the specific format for the typewriter platform. A surprising amount of modern computing has been inherited from the typewriter. We know well of the inefficient yet ubiquitous QWERTY layout, or the staggered staging of the keys (notice that even though our fingers articulate linearly, the keys of a typical keyboard are set diagonally). However, the sheet of paper format, completely unnecessary when dealing with a digital document, has persisted: most notably in one of the highest selling pieces of software Microsoft Word. In Word, the user composes to a single page with the implicit purpose to be printed. When an overwhelming majority of .doc and .docx are transmitted digitally over email and never wear so much as a sprinkling of toner inside a printer, why must a user be forced to work within the confines of the sheet of paper? If the platform of computing offers radically divergent possibilities for text input, why are we using the same format as pre-computational platforms?

Nesting is a feature of a format specific to a digital platform. Basically, the nestable file can’t exist outside the computer, at least not as richly as it can inside the computer. One of the earlier implementations of nesting that can still be enjoyed today with ease on (almost) any standard computer is in a linear text editor from 1991: Vim. An improvement upon Vi from 1976, stepping into Vim today as someone who, by circumstance, was raised in Word is the closest thing I’ve found to a cyber time machine. Nesting in Vim is referred to as “folding”, it’s a little more primitive. Instead of information being embedded within other pieces of information, information can be collapsed and expanded on the fly. Ideal for coding, these folds allow large chunks of text to be folded into a single line to prevent the user from having to constantly scroll passed when navigating the document. A lot of writers and programmers still use Vim because of its extensive feature set. However, the impossibility of mobile use has kept it as little more than a curio for me.

The main benefit of nesting to me is when I’m screenwriting. The ability to collapse scenes, sequences, or acts is incredibly valuable. Additionally, if it’s a true nest, and not a fold like Vim, then rearranging scenes becomes trivial: moving the slugline moves the everything nested within it. However, nothing I’ve come across can do this and appropriately handle Fountain, the Markdown-esque language for screenplays.

OmniOutliner has the one of the more robust nesting system I’ve seen in a consumer-friendly text editor. In fact, that’s really the app’s central feature. However, composing long strings of text is bothersome as the striking the Return key creates a new entry in the nest, not a line break. Slugline, a screenwriting app designed for Fountain, allows nesting in the sidebar in which all sequences and sluglines are listed for easy navigation but still requires composition to occur within the confines of a single page (one step forward two steps back).

Innovation has largely slowed in text editors. Everyone wants to dress them up pretty, have them support Markdown, give Dropbox or iCloud sync and call it a day. However, the compositional paradigm, even in apps like Ulysses (which I use every morning) or iA Writer, seemingly don’t want to disrupt the historic linearity of writing. Even if I’m no longer composing to the single page, I still feel text editors can be improved upon.

Please, just let me nest.

Read yesterday’s

Twitter

Show your support

Clapping shows how much you appreciated Daniel Holliday’s story.