Coding with Footnotes and Links

On the Tinderbox forum, Jean Goodwin inspired Paul Walters to demonstrate a technique by which text can be broken down using the footnote tool and codes assigned by creating a link to notes representing individual codes within the coding system. Jean then demonstrated how rules can be used to aggregate the codes and assign prototypes. I've refined their demonstrations, overcoming several limitations with respect to coding and output.

Feel free to download the Tinderbox file illustrating these techniques.

This article describes how to use the Tinderbox file. It covers:

1. An overview of the analytical workspace.
2. A walk-through as to how to code using the mechanism.
3. Adding new codes.
4. Changing the coding.
5. Coding from multiple dimensions.
6. Coding disjoint syntagms.
7. Assumptions.

The mechanics are described in this followup article.

The Workspace

This is my preferred workspace.

Preferred workspace for textual analysis coding.

The outline contains my Prototypes, Agents and Templates sections, which I have come to adopt as a standard for all my Tinderbox projects. The Gettysburg Address note introduces the text itself, and could very easily contain the entire text. (It doesn't in my example file, but to be fully consistent with the logic I'm describing here, it could be.)

The Gettysburg Address text is presented hierarchically, starting with the overall text itself (Gettysburg Address), then showing paragraphing (Paragraph 1, Paragraph 2, Paragraph 3), then each sentence, followed by each clause, with phrases below that.

The Codes Outline is really a subset of the initial outline. I've opened this additional outline so that the Codes will always be available, which is extremely important in making this technique work productively.

The Map view allows for additional visualisation opportunities. In this case, I've purposely aligned the Process (i.e. verbal phrase) in each clause. The fact that the map provides for additional juxtapositional possibilities represents a significant benefit relative to the map-based coding system illustrated in my previous article.

How to code with footnotes and links

This text is only partially coded. I'm going to navigate to a section of text that is not yet coded, and then begin the coding process. I'll walk you through the process step by step. You'll find the system pretty easy to use.

Partially analysed text, prior to coding.

Paragraph 2 has previously been broken into sentences (represented by the code ClauseComplex). The sentence starting "We have come…" has also been broken down into clauses. The first clause's phrases have been analysed. So, I'll continue by analysing the phrases in the projected clause "to dedicate…".

Select the note "to dedicate…" and click <space>. The note appears. (Ignore the thicket of attributes for now. Each one will be explained shortly.)

The note representing a clause, prior to any additional coding.

Mark out the next phrase.

Verbal phrase highlighted within the clause.

Then execute the Add Footnote As Child command by pressing Command+Shift+F. A second note appears on the screen.

Note representing the verbal phrase "to dedicate," popped up over top of its parent clause.

Now press the link icon and select the target code. The link window appears, and I choose the •Ideational link-type.

The • in •Ideational is a handy way of identifying the special link types in this application. The identifier •Ideational signifies that links of this type represent codes from the Ideational metafunction. Systemic Functional Linguistics posits that there are three metafunctions in language: Experiential, Interpersonal and Textual. Of these, the Experiential metafunction has two sub-components, Ideational and Logical. Hence my terminology.

NOTE: I've coded it as a Mental process (Process:Mental), because that's in my currently-available code-set, even though I suspect it should probably be coded as Process:Verbal. I'll return and clean this up soon.

Selecting an •Ideational link type.

Now close the note representing the new phrase. The original note now has a text link it. If you click on the text link (Command+Option+click) it will open the child note representing the phrase we've just coded.

The clause with the linked verbal phrase.

Notice the change in the map view. The verbal phrase "to dedicate" now appears within the clause. More than that, the Process:Mental prototype has been automatically applied to the phrase. (Magic? No: But, like any sufficiently advanced technology, it is indistinguishable from magic until you're trained in the art: Read on.)

Map showing the results of the coding.

Now I'm going to quickly repeat this process to code the nominal and circumstantial phrases. Look at the outline view to see the effect.

Outline view showing the newly-coded phrases.

The outline view is the easiest means of traversing the rank hierarchy. It provides a random-access entry point to the text being coded, whereas the map view provides a visually stimulating means for considering the outcome of the coding. By careful arrangement of the inside container views on the map, the analyst can see two levels of rank at a time, giving reasonable context for the analyzing the subsequent coded text.

So that's the basic coding process. To see what the final coded output looks like:

1. Select the Gettysburg Address note.
2. Create a New Nakakoji View.
3. Choose the option Selected notes.
4. Choose the Text export template /TEMPLATES2/•LGOutput

Now you can see the marked up text using an HTML-inspired coding representation.

Nakakoji output of the Gettysburg Address. Text is unevenly analysed, resulting in only a portion of the speech being visible.

Adding new codes

It's easy to expand the codes while the coding is in progress. Previously, I really wanted a Process:Mental code. So, let's add it now.

Simply locate the Process hierarchy in the Codes window. Select Process:Mental and duplicate it (Command+d). Press the space bar, and change:

1. Name from Process:Mental to Process:Verbal.
2. CodeName from Process_Mental to Process_Verbal.

There we have it. A new code. Now it's just a matter of changing the original coding.

Changing the coding

Changing the coding is slightly more complicated than you'd imagine. What you have to do is this:

1. Locate the note and open it.
2. Delete the existing link. (Within the note, open the links window, highlight the link, press delete.)
3. Create a new link to the code.

And then, just before you're ready to generate your Nakakoji view, you should switch on the agent Cleanup_RunOnceThenSwitchOff. The agent scavenges of the remnants of old codes and gets rid of them. (Remember to switch it off. Unpredictably nasty things will appear in your Nakakoji if you leave it enabled. You're warned.)

Coding from multiple dimensions

As I've mentioned previously, Systemic Functional Linguistics calls for coding text from multiple perspectives. Many coding systems do. The mechanisms within this approach allow for multiple codes to be attached to any fragment of text.

Although the sample file allows for multiple codes, the Ideational perspective is privileged over Logical, Intepersonal, Textual or Cohesion codes in two ways:

1. By being the only code hierarchy that are Tinderbox prototypes.
2. By forming the principle by which the text is decomposed into finer levels of rank.

When you link a syntagm with an ideational code using the •Ideational link, the code is added to the coded note's Prototype attribute.

So, to code from multiple parts of the hierarchy:

1. Use at least one Ideational code, marked with an •Ideational link-type.
2. Any other codes must be assigned using the •CodeLink link-type.

(Unpredictable things happen if you have multiple links typed as •Ideational.)

Coding disjoint syntagms

In the sample file, in all the areas I've finished coding, I've finished at the phrase rank. Each phrase attracts opening and closing HTML-style tags in the Nakakoji view. Because the text is decomposed according to the ideational perspective, neither the phrase level nor the clause level represents the starting and ending of some tags. Paragraph 1 illustrates this.

The phrase, "Fourscore and seven years ago," can be linked to the Textual code of Theme. But the textual Rheme consists of the remainder of the phrases. We want output Nakakoji output like this:

<Clause_Independent> <Circumstance_Temporal><Theme> Fourscore and seven years ago</Circumstance_Temporal></Theme><Rheme><Nominal_Actor> our fathers</Nominal_Actor><Process_Relational_Existence> brought forth</Process_Relational_Existence><Circumstance_Locative> on this continent</Circumstance_Locative><Nominal_Goal> a new nation</Nominal_Goal></Rheme> </Clause_Independent>

Not with repeating <Rheme> and </Rheme> tags like this:

<Clause_Independent> <Circumstance_Temporal><Theme> Fourscore and seven years ago</Circumstance_Temporal></Theme><Rheme><Nominal_Actor> our fathers</Rheme></Nominal_Actor><Process_Relational_Existence> <Rheme> brought forth</Rheme></Process_Relational_Existence><Circumstance_Locative> <Rheme> on this continent</Rheme></Circumstance_Locative><Nominal_Goal> <Rheme> a new nation</Rheme></Nominal_Goal></Clause_Independent>

So, to code disjoint syntagms:

1. Select the opening note, and link it to the desired code using the •StartCodes link-type.
2. Select the closing note, and link it to the desired code using the •EndCodes link-type.
3. Select each intervening note, and link it to the desired code using the •ContainedCodes link-type.

That will generate the desired output.

Assumptions

Be aware of these assumptions:

1. While you can code at multiple levels of detail through a document, at any one branch you need to code at a uniform level. So, if you code an individual word within a phrase, then all the words in that phrase need to be represented at the word level. (Sibling phrases need not be analysed at the word level.)
2. Because prototypes are assigned through the primary code hierarchy, the primary hierarchy of codes must be mutually exclusive.
3. StartCodes, ContainedCodes, EndCodes do not communicate prototype inheritance. Only the primary coding system communicates prototype inheritance.

Oops

There is one mistake I keep making: frequently forgetting to create the footnote prior to linking it. This results in me marking out the text in the clause, then immediately linking that text to a code. It's visually similar to the result I want, but the mechanics relies on coding each phrase separately. When I do make that mistake, I have to delete the link, and then remember to run the Cleanup_RunOnceThenSwitchOff agent prior to generating the Nakakoji.

Next Article: Coding with Footnotes and Links—The Mechanics

Comments

[rogelio]

I think that Coding with Footnotes and Links is perfect because that's perfect actually I like to make links like this one:Buy Viagra, what do you think about it, I also make other links just for hobby.

[Snake]

One of the reasons why I like visiting your blog so much is because it has become a daily reference I can use Buy Generic Viagra in order to learn new nice stuff. It's like a curiosities box that surprises you over and over again.

[Looky]

Never doubt on the question of any sight that is being given by transformation.
early mornings are to relax. Markets.com