In a discussion of Open Office, Tim Bray wrote
There's no reason [OpenOffice] shouldn't have a `Blog this' button that XHTML-i-fies whatever you're typing, lets you preview, and then lets you ship it out ...
This is a good point. Moreover, you hit on the key point, without which the application fails socially:`lets you preview'.
But the issue becomes,
`preview for what'?
For a blog, besides the visual, you need to preview both the auditory
and the frugal. Otherwise, you exclude yourself from the company of
the
`situationally blind',
such as car drivers, who should not be looking at your blog while
driving, and you exclude yourself from people who suffer from a low
bandwidth connection or are using an old or small device.
In particular, over the next few years, the number of
`situationally blind',
will blossom. People driving will want to listen to their
email or listen to your blog.
Unfortunately, many contemporary people write for just one output format. This makes sense, since in the past, people wrote onto paper, either with a pen or typewriter, and that paper was the one significant form that output could take. In the past, the only salient blind were the permanently blind, and they are a small portion of the population.
Now, people who write have a choice among different output formats.
This combines with the large number of otherwise sighted, but
`situationally',
blind people.
Put in a way that might appeal to those who like abbreviations,
WTSWIWTRS
interface,
`What The Sender Wrote Is What The Recipient Sees'.
YRCHTVOL
format,
`Your Recipient Chooses How To View Or Listen'.
Yet today, many people think of
WYSIWYG
as singular, rather than quadruple. They think of a
`What You See Is What You Get'
program as providing a single
`frozen'
typeset output format, rather than a plain text frozen, a frugal
on-line, a typeset frozen, and a typeset on-line format. (Auditory is
usually the same as one of the
`on-line'
formats).
A generation ago, man pages and Texinfo were developed as formats for
multiple outputs -- the
`frozen'
plain text and typeset outputs for paper and the
`linked'
outputs for online work.
Sad to say, even computer geeks who write man pages and Texinfo tend to write for just one format. I have seen this often.
Moreover, even people who design Web sites often create for only one particular visitor even though the output format is one in which the visitor chooses the format, and that is well known!
Fortunately, the solution is there: as you say, it is to preview the output.
But rather than leave vague the different preview formats as in a phrase such as
lets you preview
it is important to say,
lets you preview for the frugal,
the situationally sighted working online,
the situationally sighted working offline with paper,
and the situationally blind.
That way, more writers will come to think of the various ways their content will be read or heard.
As an aside, let me note that an auditory desktop is one of the
four kinds of
`integrated environment'
currently in use. An auditory desktop need not be simply an addition
to another kind of user interface, like a screen reader.
The four integrated environments are the
command line interface, such as
`sh' or
`bash', the
virtual Lisp machine, Emacs, the
graphic user interface,
such as Gnome, KDE, or Enlightenment, and the
auditory interface, Emacspeak.
Although Emacspeak is built on Emacs, it is truly different from the
previous three types of interface.
More than twenty years ago, the first widespread
`single input to multiple outputs'
formats were the various
`run off' or
roff
formats used for Unix manual pages and the
Texinfo format used in the
GNU Project in operating systems such as
GNU/Linux.
In 2002, Prof. Tommaso Toffoli of
Boston University
advanced our understanding by distinguishing between a
`deep-representation', and
`surface-expressions'.
Thus, a document formatted in Texinfo or
XML
is a deep representation. The document's various output formats,
whether for listening, reading on a computer or on paper, are its
surface-expressions.
(Toffoli developed this distinction in a
paper aimed at a
different question, which is
what new cultural resources
can help ordinary individuals maintain an adequate `personal
information space' of their own?)
As yet, not one has written an editor (or `word processor') that provides two or more different surface expressions at the same time as a deep representation. (In Emacs, WhizzyTex mode provides for one deep representation and for one parallel surface expression.)
From the point of view of a user, the tool is straight forward. For example, you should be able to see three different surface expressions, such as Info, HTML, and DVI at the same time you edit the Texinfo deep representation. (You should be able to edit any one of the surface expressions and have those changes be reflected in the other surface expressions and the deep representation, too; but that would take more work.)
For example, you could set things up so that by default a frame is laid out with four windows above each other, like this:
[ If you cannot see the image above,
here is an alternative:
+------------------------------------+
Info surface expression
+------------------------------------+
HTML surface expression
+------------------------------------+
DVI surface expression
+------------------------------------+
Texinfo deep representation
+------------------------------------+
]
Hitherto, when speaking about multiple outputs, I have focused on the two terms `deep representation' and `surface expression'.
But three terms fit the situation more closely:
Suppose we wish to display an enumerated list. In Texinfo, the list looks like this:
@enumerate
@item First item. With many more words so as to show what happens
when an item has more than one line.
@item Second item.
@item Third item.
@end enumerate
The Texinfo source is the `deep representation'.
In a Web browser, the list looks like this:In Info, it looks like this:
1. First item. With many more words so as to show what happens
when an item has more than one line.
2. Second item.
3. Third item.
The Info output is a `surface expression' when you are reading or listening efficiently but a source when you are looking at the file. When talking about it as a source, it is an `intermediate expression'.
Similarly for HTML. The HTML looks like this:
<ol> <li> First item. With many more words so as to show what happens when an item has more than one line. <li> Second item. <li> Third item. </ol>
In a Web browser, the list looks like this:
In one circumstance, the HTML is a surface expression. In another, it is a source. The term `intermediate expression' helps clarify this.
Thus, when I view an HTML file in Emacs, the sequence goes like this:
test.texi -> test.html -> Emacs W3 buffer
deep representation -> intermediate expression -> surface expression
| |
V V
the `makeinfo' transform the W3 mode transform uses
uses temporary data a Lisp object representation
as an `intermediate expression'
Depending on how you look at it, test.html may serve as a `deep
representation' or as a `surface expression'.
As a general rule, you need seldom look at an `intermediate expression', only the various surface expressions created by a deep representation. Nonetheless, the term is useful.
Or return to: Rattlesnake Home Page