Grading with Tinderbox

Last semester, I spent a few weeks creating an analytic grading rubric using Tinderbox. I don’t generally use rubrics, but they are very popular with some of my colleagues, and I thought I’d see if I could come up with one that could actually work for me and my students.

The rubrics I’d tried in the past were completely non-starters. For me, evaluation should involve plainly written comments about what works, what doesn’t and why. I also want to suggest how things could be improved. Paper rubrics are invariably too constrained and inflexible to support this kind of feedback.

Software tools seem as if they should provide the consistency of a rubric and the flexibility of individual comments. Yet, the systems I’ve tried—and I’ve tried both ad hoc and commercial options—have all been as unwieldy as the worst of the paper rubrics. Getting my comments out of the systems so I can hand them back to students is also too often a chore.

Whether I’ve come up with something better using Tinderbox is an open question, but I do have a working rubric and have learned a lot putting it together. So I’ve decided to explain how it works.

An Overview of the Rubric

To get started I think it would be useful to show the rubric in use, and so I’ve put together a demonstration file that is a stripped down version of my course planning project. It contains the rubric, a student note (my name, fake ID number) and nothing else. In the video below, I use this demonstration file to walk through the process of creating an evaluation sheet for the student’s essay, selecting the appropriate descriptions of their work for the various criteria and then reviewing the comment sheet that results.

I’m fairly certain that all of this will look fairly boring. This is a good thing in practice—a rubric that is fireworks will be a distraction and a lot of the utility of what I’ve made comes from its flexibility which I don’t really show—but alas, demure adaptability makes for bad video. The excitement will come (maybe?) in subsequent posts when I explain how I use rules, agents, and export templates to make everything work. For now though, you’ll just see the following:

  1. A note is created and then automatically converted to a rubric container and renamed.
  2. The rubric container is expanded to reveal the evaluation criteria containers. For each criteria, one child is selected as a comment by ticking it’s checkbox. In one case, the criteria grade is revised manually and the criteria titles are updated as a result.
  3. The main rubric’s key attributes now show the final grade for the assignment. The hover expression will also show the final grade.
  4. A general comment is added for inclusion on the comment sheet.
  5. The preview pane shows the comment sheet that will be exported. Both the general and criteria-based comments are organized using additional, organizational text. Everything has been properly formatted.
  6. The selection for the first criteria is changed and revised. The changes are reflected immediately in the comment sheet.

(There is no sound with the video. The silence feels weird and peaceful I think.)

What I Wanted

My rubric isn’t fancy, but it uses techniques that are basic enough for me to understand and are exposed enough for me to adapt on the fly. I’m sure there are more elegant ways to do some of what I’ve done. That said, what I built does what I hoped it would in the four areas that mattered the most to me.

First, I wanted to select comments not number grades. I did, however, want the rubric to translate my selections into numerical point values. I also wanted it to compile these values into a grade breakdown and to use them to calculate the overall grade for the assignment. I wanted both of these things to happen automatically based only upon the text I selected.

Second, I intended the comments I selected while grading to be given back to students as part of their feedback, and so, I wanted my rubric to be flexible enough to allow me to revise or add to the prepared text in order to respond specifically to individual students’ work. I also wanted to be able to deviate from the basic grade breakdowns when necessary.

Third, once the grading was done, I wanted my rubric to export document files containing comment sheets that I could return to students either electronically or in hard copy. I wanted these files 1) to compile the comments I’d selected and written and 2) to organize and format them in a useful way. I also wanted the resulting files to be named so as to allow bulk upload to my college’s course management system.

Finally, I wanted the rubric to be able to travel from semester to semester. In other words, I needed to be able to revise the criteria, descriptors and grade calculation quickly and easily in order to adapt the rubric to new assignments and new classes. If I had to dive under-the-hood regularly, I wouldn’t do it and the whole project would be a waste. I know myself.

The Plan for Posts

Over the next week or so, I’m going to post a short series that explains how my rubric works. I think I can do everything in four posts, so my planned progression is:

If I need to break one of these posts apart to have more room, I’ll update this list to account for the change. That way it can serve as a table of contents.

Finally, before moving on, I want to acknowledge that Mark Anderson’s TbRef and his responses to questions on the Tinderbox user forum made the difference between success and failure. Mark Bernstein’s “Actions and Dashboards,” which can be found in the Tinderbox Help menu, was my go-to resource for generating ideas and solving problems. I also relied heavily on other people’s questions and posts at the Tinderbox user forums and the backstage group. So thanks to all.

Next post: setting up the prototypes.

“Oops!” with Agents

Tinderbox agents have queries. They also have actions. The first culls notes from a project, gathering up those that you want. The second makes changes both small and large to those same gathered notes. This combo makes agents a powerful tool.

I just did something stupid though.

I’ve built up a large TBX file that has entries for each of the books in my library as well as my book logs, various reading notes, subject bibliographies and it’s all cross-linked with teaching files that I keep in DevonThink. There’s a lot going on there.

Well, just back from vacation and apparently still suffering from a serious case of lazy-brain, I opened up the file and started fiddling with an agent that pulls together a extensive cross-section of notes and does a couple basic maintenance actions on them. While doing this, I wanted to look at a set of notes with a shared prototype for a minute and decided just to update the query on this agent rather than making a new one. Because I was there and lazy and, well, it made sense at the time.

The problem is I didn’t didn’t pay attention and updated the agent’s action not the query. That simple mistake turned a benign housekeeping agent into a radical revisionist. By pressing the tab-key to register what I thought was a new query, I set this agent loose to quickly and quietly gather up its huge, cross-section of notes and to change every single one of their prototypes. Worse, I watched it happen and thought: why are all my note’s badges changing like this? When what I’d done finally registered, my heart sank. Having an agent take lots of different things and make them all the same is easy. Having an agent distinguish between notes that are suddenly all the same and to make them different again is–if it is even possible–far beyond my capacities.

Fortunately, I only messed up prototypes. I have a lot of them in this project but not dozens and they aren’t complex. So after fifteen or twenty minutes of donkey work, all my notes’ prototypes are, I think, back to normal. Mostly. (Maybe.) In other words, things could have been much much worse.

Still this deserves a note to self: pay attention when fiddling with existing agents because they are powerful and things can go very very wrong.


A first beta of the new StorySpace has been posted for people in the Tinderbox Backstage and I’ve downloaded it with blind excitement.

“Blind” because I’ve never used StorySpace before, but I am currently straddling the divide between linear and hypertext writing and feel very unsure of which way to go with a couple of stalled writing projects. Linear writing means these projects will never be published. Hypertext writing makes publication easy. I worry though about the way it tempts me to avoid the fruitful challenge of ordering material. Overcoming that problem has been key to all my successful writing in the past. How do I work without it? Or beyond it?

“Excitement” is less complicated: curiosity in this case feels like hope.

Web Dialogue: A Sample

Mark Bernstein has a long post collecting various thoughts and questions about writing with links. In the longest segment of the post he takes a basic component of most narratives–a passage of dialogue–and then proposes a few seemingly minor transformations that someone writing a hypertext narrative might be expected to do: break the sequence into pieces, resequence the pieces, link to create an opportunity for one sequence to return to the other.

His post arrives as my summer days are dwindling and when I should be finishing up last bits of planning for my courses. But it also made me curious about what these transformations might look like behind the scenes and what would it take to actually do them. So last night I sat down and wrote up something just to see.

My TBX Map
My TBX Map

To get started, I jotted down ten notes that together made a short conversation/conflict. I then resequenced that conversation twice: once to work from the middle backwards with a possibility of either returning to the original chronological sequence or of continuing to the end more quickly, and once to create a completely independent, achronological version.

A Limitation: No Off Switch

All the links in the dialogue are web links and are always on. But not being able to control for repetition is a problem. Yes, repetition can be expressive. It might highlight the looping, unordered manner we speak to one another. In other words, a sequence with possible repetitions might offer an image of “conversation,” the genre of casual spoken exchange between people.

But I wasn’t much interested in that. I wanted to represent an actual conversation and that seemed to mean limiting possible repetitions as I made links. To manage this, I created every note in triplicate and linked from each version sequence separately. Doing this, I began to wonder to what extent it’s even useful to try to create the option of moving between versions mid-stride in a text that doesn’t aim to be a game narrative.

Weren’t the most meaningful choices made at the outset when a reader set off down one of the three available paths? What does the option to switch paths before the end of the convo add? (Note: not rhetorical questions)

Web Expectations

Putting together this dialogue, I worked against expectations I derived from the linear printed book. Reading the dialogue online though, I began to wonder if the relevant expectations–maybe the most important even–actually derived from the web.

I’m struck by how differently the text in TBX and the text on the web read. (I had the same experience with Faulkner.) The web naturalizes disorder. So much so that I find it hard to recognize the achronology of the jumbled versions of the conversations when reading online. Without trying to, I smooth out the problems and jumps. Yes, there are a couple off-tune transitional words that clang badly, but they are easy to delete (because they’re unnecessary).

Overall, I think it’s hard to notice or track differences between the versions. It’s a strange effect.

…or is my dialogue just not very “hyper-textual”?

Back to work, alas

And that’s it. This dialogue was maybe a bit of a throwaway exercise, but it was an interesting one to. And also a nice distraction as school obligations begin to pick up and take over.

Faulkner Online: Breathless First Impressions

The Faulkner hypertext that I’ve been making in Tinderbox and that I’ve spoken about a few times is now online.

It’s far from perfect, but that’s fine. It’s my first stab at this kind of writing and I wrote it as an experiment. I wanted to discover what was involved in writing something that 1) could be read in various sequences, 2) by someone sitting at a computer. I also wanted to find out 3) if I could, at the end, when the writing was finished, produce something that could be posted online. Or was that all-important final step beyond me?

Importantly, none of these had anything to do with Faulkner. So why choose him as a subject? Well, because I already had a text close at hand. Working with it, I expected I’d be able to focus on the three concerns above right away without worrying too much about the basic writing problems involved in going from nothing to something.

As it turned out, this choice had one additional advantage: I know what it took to pull material from so many different sub-field of research into a coherent, linear structure. I remember the difficult choices required and the pattern I struggled to develop and then to work within. Making the hypertext involved breaking that pattern, undoing those choices in order to create a different structure. The difference was vivid as I worked, sometimes to the point of being overwhelming.

The Hypertext

What I have online right now is not in the end what I expected and my worries are not those that I had anticipated. Still, it’s a first ever attempt to do something like this and I’m fine with it.

My concerns? The hypertext is incomplete if by complete, I mean “containing the information in my dissertation.” I did have dreams early on of having everything, but it was a waste of time to work toward that. I could lose my life rewriting and reordering a text I was done with (concretely and intellectually) years ago. Then a few days ago, I realized I was avoiding number three above: export. Deep down, I didn’t expect to be able to come up with anything usable from my Tinderbox file and that was going to be a crushing blow. I was avoiding the moment when it would hit.

So I bit the bullet, cut materials, linked back from dead ends where I found them, left quite a few long notes I’d planned to break up whole, and then last night (less than 24 hours ago!) sat down to see what I could get out of my Tinderbox file.

It was a revelation.

Tinderbox’s export is jaw-droopingly, amazing. I have never written HTML to create a web page, much less a site. Yet with an HTML/CSS book at hand as reference and few hours work Tinderbox spit out the pages currently online. Are they beautiful? No. But that’s me not having any sense of web colours and fonts (because zero practice, duh). And better yet, export is so easy that revisions of the site are no big deal. I made several before going to bed.

All of which means I now know that I can write in Tinderbox, and Tinderbox will give me sturdy, legible pages to post when I’m ready. That’s a game changer!

Source v. Hypertext

I’ve noticed that the hypertext makes the contribution I offer in my dissertation implicit rather than overt. For my project, I didn’t discover a lost text or dig through a trove of recently discovered letters or manuscripts. I took three marginal segments of Faulkner studies coordinated their linked parts and set the whole within its biographical and historical context. The result was a clarification of how an important but misunderstood part of his development as a writer worked.

Here’s the thing: the hypertext links I created often replaced the transitional material I had used to explain and coordinate material. As a result, what had been a slide show became a room with various things on separate (but related) display. Illustration was in a sense replaced by collage. That’s interesting but leaves the hypertext feeling a bit obvious to me.

I do, now that I’m done, have some concerns about the scholarly apparatus of the hypertext. I adapted my dissertation text with an eye to learning about hypertext, not because of a burning need to create an online Faulkner resource for the globe.I tried to play nice with quotation marks and citations, yes, but I’ve realized that some citations have disappeared in pages I worked on in the early weeks. There are probably others I haven’t noticed, and so, I’ve felt compelled to point out in the hypertext that the dissertation is the scholarly statement not the web site, a hedge but one I can’t live without.

First Impressions

  • Clicking through things last night, I realize that I agonized over structural questions as I was putting this thing together but that on the web, structure is hard to make present. For the moment, the posted text feels like a “resource” rather than an “argument” to me. Perhaps this is inevitable given that as I created possibilities for where to go next, I had to create links for those who arrived without info they needed and I couldn’t assume they had. The result is a link structure that feels very flat to me. The “hubs” I’d created, which allowed me to assume that, whatever path readers took to get here, beyond this point they know at least x, y & z, are largely non-operative. I’d like to think that’s a product of the last few days rapid link-building aimed at closing down the loose ends, but it may not be.
  • The hypertext reads online as much smaller than it is. Shockingly so. This is exciting—because it means there is more space than I imagined to write within—but also, I feel stunned: how much do you have to write to create work that feel large?
  • What I have now, feels readable and navigable (not to be confused with interesting or useful!), which makes me very happy. Until last night I had no idea that I would ever get to the point where I had something I could post a link to.

So yes, I’m very very happy. The experiment is done. I now know that Tinderbox HTML export is unbelievably, mind-blowingly easy and effective.

And so I feel free to sit down and write for real.

Wow. I’m going to say that again: I feel free to write. What a great day.

Honest Links

I’m working on Faulkner. That text is an argument but also a description of a situation and a history of its context.

Working, I’ve discovered that links can lie.


The jump from one thing to the next can suggest a logical connection between the things without specifying it. And the lacunae can be masked by the page change and clever writing.

Definitely a temptation to avoid.

The flip side of this: any page text will likely be (should be!) the target of multiple links, each suggesting a different logical relationship with that text. So specifying the nature of a connection can be hard.

The goal: honesty without logical constriction.

Faulkner Hypertext

Last year was a busy one at school and I had to set the Faulkner hypertext I was working on aside in the Fall. Now with most of the moving boxes unpacked at our new home and summer well under way, I’ve had time to go back to that project.

I’m happy with what I’ve found and have started working again. I’m making good progress, my goals are more reasonable than they were and I have a schedule. I also think I’ve wrapped my head around basic export enough to be confident that I can get something simple but functional out of my project file. (Seeing how effective the very simply formatted Depression Quest was, helped me get over some export fears.)

So I’ve decided that the week of August 10th, whatever I have is going online. If I can stick to my writing schedule and things keep going well, it will be a legitimate first (and maybe last) version of everything. If I can’t, then whatever I do have will benefit from having others look and give feedback. Either way, that week, something’s going up.

Setting Attributes with On-add Actions

In my admin file, I want to keep track of where information in a note came from: at what meeting, from which organization, on what date, etc. But I also don’t want to have to remember to enter all of this information when I create notes. So when I make a container note for a meeting, I immediately set the on-add actions to enter this information automatically. For this last video in the series, I’m going to explain how I do this.

To Create an On-add Action From Scratch

If you want to set attributes automatically when you create or add notes in a container, you simply:

  1. Open the Inspector (cmd+1)
  2. Select the Action Inspector
  3. Select the Action tab
  4. Begin typing an attribute name, select it from the dropdown to complete it
  5. Assign a value for the attribute using “=” followed by the value in quotation marks
  6. Tab or click away to make sure everything registers
  7. Shift+Tab and then Tab existing notes to apply the action. (It will apply automatically to new notes.)

Note: in the video you will see that I place parentheses around my attribute values. I’m not sure where I picked up that habit, but I learned recently on the Tinderbox forum that it isn’t necessary. The quotation marks are sufficient.

Creating On-add Actions for Additional Notes

Once you have one on-add action written, you are living on easy street. Need to set attributes on another set of notes? Then simply:

  1. Open the Inspector (cmd+1)
  2. Select a nearby note and copy-paste the action to the new note
  3. Edit the bits that should be different
  4. Tab or click away to make sure everything registers
  5. Shift+Tab and then Tab existing notes to apply the action

And that’s it. So there’s nothing to remember. Figure out how to do this once, and when you need to set attributes the next time, open an inspector for an old note, and copy-paste what’s there.

What You’ll See

This video is longer than the others I’ve posted because I shows how to create and apply an on-add action to existing notes as well as how to revise and apply this action to additional notes. I include all of these steps because I think it is worth showing how little time the entire process requires. For a more automated approach to be worthwhile, it would have to be something I could imagine, write and revise more quickly than I can use this less automated approach.


Working Auto-manually

This system isn’t automatic in the sense that I type something once and forget about it and everything I want happens magically. It’s low-level automation that ensures consistency without being overly complex or abstract. It requires some work on my part, but I find that this work keeps me in touch with my materials. Neither do I have to know any complicated, conditional syntax or how to fetch information from other notes. I just enter the values I want to set directly.

Because the actions are so simple to manage, I also don’t feel much pressure to predict all of the attributes I will eventually want to set. In my admin file for example, I started out setting only two attributes. I added to these slowly over time, and my basic meeting containers now set five. Each time I realized I wanted to set a new attribute, I simply added it to my list, did some copy-pasting and some shift+tab/tabbing, and in fifteen twenty minutes everything was up to date.

Adding to Attribute Values

Finally, as I move notes around, the on-add actions I show here can create problems. If I’m not careful for example, a new container’s on-add action will replace the attributes set by the note’s previous container. I asked how to deal with this on the Tinderbox forum, and it turns out the solution is pretty straightforward.

If I type:


this action sets the attribute value to “A,” replacing any existing value.

But if I the attribute is a set, and I type:


this action adds “A” to the existing value of $CollegeOrganization without deleting any previous value. And because the attribute is a set, I can’t get duplicate values. So everything stays tidy.

Creating and Setting Key Attributes

Right off the bat I should say that I’m still learning how to use attributes. Outlines, map views, links, these I understand, and I see how they help me. Attributes feel very different to me, and I’m a bit intimidated by them. [note]Attributes remind me of databases. The problem is that to me databases seem like sticks of dynamite threatening to blow everything I know into pieces. They promise big returns, but I never trust I’ll be able to implement them in a way that delivers on their promise. Tinderbox substantially lowers the stakes of a database-based (!) approach by reducing the requirement to plan extensively in advance, but my anxieties remain. As a result, I actually find imagining and making attributes more challenging than writing the action scripts that affect and use those I already have.[/note] As a result, I think I tend to use them more casually than many people who use Tinderbox do.

Two Ways of Using Attributes

For now, I mostly use attributes in two ways: as labels indicating stable information that I will use to identify notes visually; and as “tags” to temporarily keep track of time-sensitive information through an agent. The first use is straightforward. If I see “Organization A” in the key attributes of a note, I know the source of the information I’m looking at. The second is a bit more complicated.

Imagine a situation in which I’ve requested some information from a group, course preferences perhaps. To keep track of who has submitted the information and who has not, I would create an attribute called “CoursePreferences,” set it to boolian so I have a checkbox to work with, and then add the attribute to my key attributes. I would then create two simple agents. One would search for boxes that are checked (i.e. a value of “true”); the other, for those that are not (i.e. “false”). [note]I would also limit the agent search to the container with the group members’s notes or by prototype. Otherwise, my agent searching for unchecked boxes would be filled with aliases for every note in my project.[/note] As people submit their material, I would be able to check them off easily and my agents would move their notes automatically from my “checked” to “unchecked” lists. When my “unchecked” agent is empty, I’m done and delete both the attribute and the agents.

For this second situation to be worthwhile, I need to be able to create and delete a user attribute (and to set it as a key attribute) quickly. I give instructions for doing all three tasks below. These are followed by a video that shows what things look like in practice.

Creating an Attribute

To create a new attribute:

  1. Open the Inspector (cmd+1)
  2. Select the Document Inspector
  3. Select “New User Attribute” from the dropdown menu (gear icon)
  4. Enter the name of the new attribute.
  5. Select the kind of value the attribute will contain
  6. Tab or click away to make sure everything registers.

Note: in the video you will see that when I type “Organization” the text goes red. This indicates that the attribute name is already in use or doesn’t conform to the naming rules. Adjust the text to something that shows black, and you are good to go.

Deleting an Attribute

Deleting an attribute is easy.

  1. Open the Inspector (cmd+1)
  2. Select the Document Inspector
  3. Select the attribute to be deleted from the dropdown menu. (Be careful!)
  4. Select “Delete user attribute” from the gear menu.

…and it’s gone. So again, be careful!

Setting (and Resetting) a Key Attribute

Tinderbox 6 has made managing key attributes ridiculously easy. To show an attribute at the top of the text window for a note, simply click the “+” button next to the note title. A pop-up shows all of the current key attributes of the note. Click somewhere in the list, begin typing the name of the attribute you want to add, select it from the menu that pops us, and you’re done.

Remember: If you change the key attributes for a prototype then all of the notes that it controls will inherit the change. That’s a good thing. If the prototype is selected while you create the attribute, you can tick the checkbox to add the new attribute to your key attributes automatically.

If ever you see that a note does not inherit new key attributes from it’s prototype and you would like it to, then you simply click the “+” button and then the “reset” button on the pop-up. This should fix the problem.


Next up: simple on-add actions.

(The next video will be the last in this series. Because I’m out of ideas for the moment. If anyone uses these and has suggestions of things they’d like to see, feel free to drop me an email or send me a tweet. I’ll see what I can do.)

Formatting Shallow Outlines

Outlines and maps are where I do most of my work in Tinderbox, but they function very differently from each other. Effective outlines use a hierarchy of container notes to structure information. Maps organize the notes in a single container using spatial relations drawn onto a flat surface.

Having both tools available to work with the same notes is powerful. Yet, in my early project files, I also found it was easy to wind up in a situation where work I put into organizing my outline limited what kind of work I could do with my maps. (cf. “Boxes within Boxes“)


But there’s a way to avoid this potential problem. Using prototypes and the inspector to adjust typography, you can easily create (or adjust) headings and subheadings that can be used to transform a “deep” outline into a “shallow” structured list that doesn’t limit the scope of the corresponding map view.

In the video below, I use the “Organization Prototype” I created in the last post and  the “Events” prototype that is built into Tinderbox [note]You can install this prototype (and several others) by going to File=>Built in Prototypes… .[/note] to create headings in an outline. To do this:

  1. Select a prototype.
  2. Open the inspector (menu or cmd+1).
  3. Switch to the text inspector tab.
  4. Adjust the prototype’s text attributes to create a heading. (The changes are visible as they are made and affect every note controlled by the prototype you are adjusting.)
  5. Select a second prototype and adjust it’s settings to create a subheading.


Once your headings are created, you can use shift+Tab to “flatten” segments of your outline’s structure without eliminating its organization. [note]The thin lines in my outline are Separators. They are the outline view’s equivalent of Adornments and can be created using the contextual or Note menus. They can be named or unnamed and are a useful supplement to headings.[/note]

Next Post: Creating and Deleting Attributes

Creating and Organizing Prototypes

Prototypes are easy to make and manage. So much so that in my early projects I tried to use them for everything. That didn’t work out so well. These days I have fewer prototypes, but those that remain are one of my main tools for organizing material in my projects.

Making a prototype is as basic as basic can be. You simply:

  1. Create a note (or select one [note]I always make prototypes from new notes so that I know that all the attributes are set to default values. A note that is not new may display the default values without actually BEING a default value. Because default and non-default values that look the same can react differently in certain situations, starting with a fresh note eliminates the possibility of unexpected surprises down the road. Obviously, if I were more on top of things, there’d be no problem with making an existing note a prototype. Also, if I were athletic, I would have muscles.[/note]).
  2. Open the Inspector with the menu or by pressing cmd-1.
  3. Go to the “Properties Inspector” tab.
  4. With the note selected, check “prototype.”

In the video below, I show the process. Near the end, I also point out that the order in which prototypes are displayed in the contextual menu is controlled by the placement of prototypes in your project outline. In other words, you can very easily arrange the contextual menu to suit your needs.



Next post: using prototypes to format shallow outlines.

Tinderbox Videos

I’ve just finished recording four Tinderbox screencap videos and plan to present them as a series over the next week.

The videos start out with simple things but end up with something that can seem (but only seem!) complicated. All of them are about using the inspector, an essential but too easily overlooked tool for working with Tinderbox.

The program:

I hope they’re helpful. And if you find they are, then you should definitely check out Mark Anderson’s Tinderbox Reference File and the Tinderbox User Forum. They are where I go to figure out things that have me stumped.

(Links to the posts will be added to the bullets as they go live.)

Windows to Tabs

I upgraded to Tinderbox 6 when it was released in late summer. There was a lot to love about the new version, but also plenty of things to adapt to. Perhaps the most jarring (and initially disruptive to my work) was the introduction of tabs.

Adapting to Tabs

The switch from windows to tabs in Tinderbox 6 sent me into a tailspin that lasted for several weeks. Somehow I experienced tabs as a brake keeping me from thinking properly as I worked. The problem was clearly conceptual, but I couldn’t identify exactly what it was.

This was, in a sense, ridiculous. Tabs are everywhere on my computer and have become the more-or-less default approach to presenting multiple views within a piece of software. I use them in my browser everyday, and they are certainly tidier and easier to manage on the small MacBook Air that I use when I’m out and about.

And yes, eventually I grew to like Tinderbox’s tabs because, regardless of how I felt about them initially, they were helpful. Full-screen mode on my MBAir was now workable, for example, and the new link-anchor system that appears designed to support tabs seemed much easier to use than the old toolbar-based system. More importantly, to the extent that tabs implied strong boundaries between materials, they offered a very useful tool for bringing distinct but still related materials into productive contact in a non-chaotic way. (This is reflected in my admin file, which consolidates what had been three separate projects in Tinderbox 5. Each of the original projects is consigned to its own tab in Tinderbox 6.)

And yet.

Something about tabs still nagged at me. Then last week, I finally figured out what it was.

Sheets and Screens

In Tinderbox 5, I saw multiple text windows as multiple sheets of paper arranged across a dining room table. Using them I felt as if the software’s frame had slipped away. My project file was unrepresented on the screen. All that was visible were those pieces of it that I chose to work with. I could shuffle, revise, arrange and stack these pieces on my desktop and I could do it however I wanted to. My computer desktop had became a kind of map view but with editable note texts. This was powerful and something I could not reproduce in other software. Not even close.

Tabs present me with a very different metaphor. Although in theory, they could be imagined as stacks of paper, in practice they felt like different display screens. When I switch from one tab to the next, I perceive this as moving from one computer desktop (or display) to another. (I assume I’m carrying this idea over from iOS.) On the small screen of my MBAir, tabs offered an ingenious way to manage and use limited display space. But on my larger iMac screen what I now saw was my project file, drawn inside the software frame, and rightly or wrongly, I felt boxed in.

Sheets and Stacks

Now I learn that the newly available point-one version of Tinderbox 6 reinstates saved window states, and however much I’ve grown to appreciate tabs, I’m very excited. In a sense, multiple windows are back. They work differently, and I’m only just beginning to experiment, but to me it now feels like the old choice between sheets of paper and screens (i.e windows v. tabs) is gone. What I’ve got now is an opportunity to work with both sheets of paper and stacks of paper (i.e. windows and tabbed windows).

I think I like this change a lot and that it is a good example of the workmanship that goes into Tinderbox. Things change but they also get better and more powerful.

Tinderbox: How to Make In-text Links

This is a follow-up to my post about front-of-the-manual tools in Eastgate’s Tinderbox. It explains how I make the in-text links I discussed there. Because it’s sometimes easier to see things done than to read about it, I’m also including a couple of short screen cap videos. I don’t often post videos and have a spotty record with them. The ones here look like black boxes to me…but they play. If they don’t for you, please let me know by email or Twitter.

Links Within the Same Tab

In-text links within the same tab are pretty straightforward. You simply:

  1. select the anchor text;
  2. click the link button in the text viewer;
  3. drag the button’s link animation to another note;
  4. click “create link” in the pop-up that appears.

The video shows what it looks like in practice. (It also shows how to assign a prototype and how I change the badge of an agenda item to a check mark once it is dealt with in a meeting.)


With these links in place, you can move from the meeting container to an agenda item’s note with a single click.


Links Across Different Tabs

Links across tabs are made in roughly the same way although there are a couple extra steps that allow you to find the note you are looking for. To  make these links, you:

  1. select the anchor text;
  2. click the link button in the text viewer;
  3. drag the button’s link animation to the link placeholder in the upper left corner of the window;
  4. click the tab that has the note you wish to link to;
  5. drag the link animation from the link placeholder to a note;
  6. click “create link” in the pop-up that appears.

Here’s what is looks like in practice:


This example also shows the reason I link from meeting containers to agenda items (i.e. what I demonstrate in the first video). In the future when I need refer to information from this meeting I will link to the meeting container and not the specific note I need. Doing so will bring me to an agenda that lets me access the specific information I’m looking for by using the blue links. But it also provides an overview of the context in which the information originally appeared and lets me click to see that information if I decide it’s useful to me.

Finally, if you don’t have multiple tabs open but wish to link to a note that is not visible in your outline, that’s no problem. Once you’ve dragged your link from the source note to the placeholder, you can dig around and find your destination note. Once you do, you drag the link from the placeholder and finish the process.

In-text Links and Maps

These in-text links show up on maps. Because my admin file has many more links than notes, these links often confuse things rather than clarify them in map view. In my course plan, I deal with this problem by using the inspector to make all but one link type invisible. When I think a particular link will add something to a map, I assign it the visible type using the drop-down menu on the create link pop-up window.

Drop-down Menu for selecting link types.
Drop-down Menu for selecting link types.


Deleting Accidental Links

I make mistakes when I create in-text links. When this happens I hit opt-cmd-L to pull up the “Browse Links” pop-up for the note, find my mistaken link, delete it and then try again.

Links to Files & to the Web

I also create links to files in my dropbox (frequently) and to sites on the web (rarely). These links are held in key attributes for a note. I make them by dragging and dropping the file from a finder window (or the url from my browser) onto the attribute’s field at the top of the note viewer.


Front-of-the-manual Tools

A Tinderbox file is like sculpture. You chip away at your project—first here, then there—slowly digging to find the shape of your specific problem and its logic.

It can seem hard because there are a lot of tools at hand. Some of them are complicated. And, in a sense, you are all alone: other people aren’t doing what you are doing and the Tinderbox files they use in their work are very different from the files you need for yours. So even when they offer advice, they can’t really tell you what to do. Not really.

My tendency is to assume that work would be easier if I could just master the complicated tools at the back of the manual. Yet, I find (and too often forget) that Tinderbox’s front-of-the-manual tools—links and aliases for example—are flexible and powerful enough to work wonders. To show what I mean (and to remind myself when I’ll have forgotten in a couple months), I’ve prepared a mock-up of the TBX file I’m using to do my administrative work.

Starting Simply

A lot of administration boils down to managing meetings and reports. So when I created my file, I simply started adding container notes for for each of my upcoming meetings.

Starting with Meeting Notes
Starting with Meeting Notes

Notes for agenda items are placed in the meeting container; the container text is a typed copy of the agenda with in-text links to individual item notes. Basic, non-hierarchical prototypes set “File” as a key attribute allowing me to link to the pdfs of supporting documents that I have stored in the Finder. [note]These pdf files sit in a work specific section of my hard drive that has a stable, date-based filing system so that links to the document files won’t be broken accidentally by moving the file to a new location. Topical organization is done in Tinderbox, not the Finder.[/note]

As more meetings are added to the file, material discussed in earlier meeting often appears on agendas for later ones. Each time it does I link from that later meeting’s agenda item back to the container for the earlier meeting and link the earlier meeting’s agenda item to the agenda item note in the later one.

Cross-links Develop Progressively
Cross-links Develop Progressively

Making these cross-links requires no additional work because I have to go back to my earlier meeting notes when I prepare for the new meeting anyway. I simply make these links when I do. Yet despite being easy to make, their pay-off is huge: these cross-links capture my knowledge of my materials and are are fast and productive in use. When I click, my past work is there, supporting my current work.

Scale & Complexity

Tinderbox allows this very simple system of cross-links to scale easily. In the span of only two months, my TBX file looks something like this:

Complexly Interacting Complexities
Complexly Interacting Complexities

In one sense, this is pure chaos: dozens of different meetings and projects spread across three different organizational units (each kept open as a tab), all of which subdivide into numerous other units. It’s overwhelming. And yet, woven through the noise is a system of links creating sensible paths through the confusion.

Aliases supplement these links by letting me keep a note in the container for it’s original meeting while simultaneously placing it in the container for a new meeting. This allows me to access relevant material both through in-text cross-links as well as through the outline, where I can click on aliases directly.

More importantly, these links and aliases lower the bar for beginning to work on otherwise daunting tasks. When I have something to do or something to prepare, I click on the note for that thing and begin to work my links. I follow them, add to them, do what I can, skip over what I can’t and bit-by-bit I manage to chip away at the task at hand. And the notes, links and aliases I build up preserve the work I do. It’s a powerful system.

But Tinderbox…So Attributes & Agents

In my actual working file, the linking strategy I’ve described is fundamental. Yet once I had a few hundred notes, I saw that some info would serve me better if I moved it to user attributes that I then set to key attributes by prototypes so that I could see it easily. (Committee membership for people, for example.)

Then I had an idea and added a keyword attribute, making it a set. I then went through all my notes assigning keywords, adding new ones when I need them, selecting them from the dropdown menu when I could. This took some time, but I was shocked by how many notes took no keywords, shocked by how many notes weren’t important enough to merit keywords. (That counts as an insight.)

And then I created a few simple agents with a single query: $keyword=(“[one of my keywords]”) to pull out and group topical notes. This is the first complicated difficult thing I do in my Tinderbox file. Up to this point, everything else has been basic “create file, drag and drop, make alias or make a link” file-managment type stuff, most of it done in outline mode. Those links and aliases are still there and still fundamental, but these topical groupings added something new and useful.

The Point

So this is a long post, but my point, I guess, is that I’m drawn to back-of-the-manual tools. They are fancy, impressive, and seem to be where the action is. But Tinderbox’s front-of-the-manual tools are the action too. Links and aliases make sense, are easy to use, and they can do great things, especially in cases where you’re bombarded with information and just need to keep your head above water while you figure out how to move forward.


Update: I have explained how I make the links I discuss here in a new post.

Notes on a Hypertext

For the last few weeks, I’ve been working on the hypertext I took on as a summer project. It’s been an eye-opening experience and I’d like to jot down some observations informally for later. These are in addition to some earlier thoughts.

The Project

I’m making an online presentation of the argument and research from my dissertation, but I don’t want to create an ordinary web site in the sense of a menu or search driven collection of resources. Instead, I want to offer something that someone could actually read and that, as they move from page to page, unfolds only aspects of the story that are of interest to them.

Despite what I’ll say below, things are going well and I’m excited. I have a third (maybe a bit more) of the thing done and the way I’m working is already very different from what I planned and imagined as I began: it seems that there’s life in the beast and so I’m letting it show me what to work on and when. I’ve also accepted that this is an experiment, everything’s new to me, and whatever I might dream up, things are not going to be perfect if I ever want to finish.

Things I’ve Noticed

  1. How do I decide to link: I imagine the questions people will ask as they read then link to the answer. Rinse, repeat.
  2. I’m cutting texts to the size of the screen and adapting language to multiple audiences. This changes the originally academic prose drastically. There are still deep places where academic guts are exposed and the language rumbles along with the mannered rhythms of a conference paper. Those who are interested will find these places easily enough. But hopefully, it will be just as easy for others to read Faulkner’s story in engaging prose without ever visiting these places. If I pull this double-language off, I will be very very happy.
  3. Scale matters. Without enough “nodes” in play, links feel like icing, like an add-on. Once enough nodes are in play though, links serve a purpose and feel essential, like a line thrown out and tied off to keep loose things whole. With enough nodes in play, I have a standard for deciding what works and what doesn’t: does this link keep things from breaking or my head above water? Good. Then, what about this one? When I start asking these questions, a lot of my small-scale, links-to-have-links are deleted.
  4. When linking materials, the complexity eventually settles down, becomes clear and “flows.” But only after a cruel march through spirit-crushing complication. How do I know things are right? A jumble of material suddenly runs like water through a system of canals. How do I know I’m not quite there? Things that used to make sense have become so complicated and confused I’m ready to throw in the towel. It’s brutal.
  5. Words have momentum and writing words in a hypertext is as involved and as intimate as drafting and revising words for printed text. It takes time and effort and attention to detail. I hadn’t expected this and in an act of pure insanity chose to resurrect 100,000 words that I thought I was done with and had stashed away years ago. This too is brutal, and when I’m done, I’m staking the dissertation and scattering the ashes.
  6. I don’t actually care if anyone reads all the pieces of this thing, which surprises me. I want people to read what interests them, to find what they need, maybe something unexpected, and then when they are satisfied, to leave. I imagine myself creating possibilities for useful partial readings, and that feels like a better way to write (which is another surprise).

The Topic: William Faulkner’s MGM Screenplays

My dissertation and the hypertext are about William Faulkner’s screenwriting during his first Hollywood contract at MGM Studios.

Faulkner’s reputation is based upon his novels and short stories, but he wrote in Hollywood for more than twenty years. That first year is special though. He was learning the ropes, and to do so, he adapted his own fiction for the screen, something he rarely attempted again and never with such commitment.

My dissertation looks at how Faulkner changed his source stories in response to Hollywood storytelling conventions and emerging censorship. And because he returned to and used these same stories when writing subsequent fiction, I also indicate the ways these adaptations produce important changes in his style that critics associate with his later works.

More info to come…

Arguing, Plotting and Making Hypertext

Mark Bernstein asks some basic questions of craft as he tries to write a hypertext page turner. Now, I don’t know Bernstein so it’s probably presumptuous for me to chime in on this and also foolish given how little I know of the hypertexts that have been written in the past twenty years or so. I’m also not a fiction writer. [note]As context, I’ve read only a few things that are available online. These include: Luminous Airplanes, “Changed,” Letters from Ireland, and My Body. Truth be told, these things are so different from each other, I’m not even sure which of them others might call hypertexts.[/note]

But I do know a fair bit about traditional poetics and am interested in the problem. So I’m going to take a risk and share a few thoughts and ideas I’ve come up with as I’ve made my first stab at writing an argumentative hypertext, a different but I think oddly analogous task. [note]In my hypertext, I’ve been working without the benefit of anything other than ordinary web links. So all of what I say here arises from coping with the situation where a reader can easily go anywhere in the hypertext regardless of what they’ve read or not. There are no gateways to cross.[/note]

In a rough way, I think a page-turning plot (or argument) is one that creates a desire to know. But it is also a plot that delays or frustrates that desire in a measured, carefully paced, and pleasurable way. Hypertexts create a problem for telling these kinds of stories because they pass control of sequence and, to an extent, narrative focus off to the reader. How do you elicit desire to understand or create suspense without controlling what readers know and when?

I have three ideas.

“Why?” or “How?” may be more powerful than “What next?”

Mysteries, one of the most heavily plotted, page-turning genres around, introduce the corpse early and spend the rest of their time working to figure out what happened before the book began (i.e. when the victim was still alive). By the same token, three narratives that I have begun to think of as “proto-hypertexts”–Citizen Kane, Rashomon, and Absalom, Absalom!— all begin with the ending of the story. In each case, the narrative is driven by a desire to know why or how something happened rather than what will happen next. And the only way to find out is to get mixed up in and explore the stories of various standers-by. (Something similar happens in the otherwise very different Pale Fire, although it is less ferociously plotted.)

I think this same trick–starting with the end and working backwards–is suited to hypertext plotting.

We may desire most those things we can’t have

All three of my proto-hypertexts abstain from presenting the protagonist’s story except insofar as it is revealed through the smaller-scale “mini-plots” of the characters caught in its wake. All of them enforce this choice by making their protagonists dead before the movie or novel begins. In a sense this places the page-turning story in a black box, making it the only story that the reader can never choose to read, no matter how much they want to. They can only access it through numerous, equally minor stories that cling to its edges, each of which reveals it only partially and (perhaps) with bias.

Bouncing a protagonist’s otherwise inaccessible story off other characters seems like a good way to make readers want to click on links recounting minor characters’ lives.

Saying “no” to readers.

Much of the very limited commentary I’ve read about hypertext celebrates the fact that authorial control recedes and readers “make” or “create” their own reading. This is true in many, many ways. In the various collage, archival or a performance hypertexts that I’ve seen, writers seem to have abdicated authority and simply (!) to have created possibilities to be explored or enacted. Readers are left to experience insight or not, to draw conclusions or not. But there is rarely any “end” to be understood. [note]Except in the frequently occurring case where the text argues implicitly or explicitly the post-modern conceit that author-ity no longer exists. In these cases, there is a point, but not one that needs to be argued.[/note]

Plots and arguments cannot be so open-ended and cannot be left up to the reader; only the choice of which mini-plots they will read in order to understand the story as a whole can be. And because reader choice eliminates the distinction between foreground and background, all of the mini-plots they will choose from have to be written. This includes those mini-plots they will choose to read as well as all of the mini-plots that they will choose not to read! And all of these mini-plots have to, in their own ways, point toward the end we are “turning pages” to discover.

Creating these coordinated options is a lot of writing and a lot of work. To be successful, it seems to me there have to be limits. In fact, I’m tempted to say that the most important question related to plot or argument in a hypertext is going to be “what options are the readers not going to have?” followed closely by “This choice lets the reader get away. How do I close it without seeming to close anything?”

These questions strike me as contrary to the ethos of hypertext as I’ve understood it from the limited commentary I’ve read. I mean really: is there anything more authorial than “Thou Shalt Not!”? And yet, saying “no” seems essential to conveying story.