Re: [Gnu-arch-users] Re: revision control for documents (was plug-in foo)

[Tom Lord]

How they did it in the stone age....  (a rant)


Screw this GUI editor foo.   Not really screw it but -- don't try to
hide, from _any_ user, the underlying markup language.  Users are
expected to learn that they are editting these markup source programs
(which they might have to edit directly) and programmers are expected
to make that a pleasant task.

Troff and tiny languages built on top of troff will do as a first
approximation.

Then add some coding conventions.   The ones beaten into my head as a
youngster were things like:

        Start every sentence on a new line.

Why did this make sense?

Well, for one thing, with "every sentence on a new line" -- plain old
diff(1) and patch(1) do a _much_ better job.

The cost, of course, was that every user had to be aware of, and
somewhat had to learn, the underlying markup language.  For example,
when patch produced invalid troff, they had to be able to fix that.
They had to not go into mode that involved running around the room in
circles, waving their arms to signal panic, when confronted with a
line that said ".rj".

We had a name for that kind of design in the UI group I worked with.
Actually it was a name that I coined.  We called it "not lying to
users".

"Not lying to users" meant not trying to create "false abstractions".

An example of a "false abstraction" would be an editor in which 80% of
the time you hide from the user that there's a markup language at all
-- just show them text that looks certain ways -- but then the reality
that there's an underlying markup language "seeps up" into the
interface in annoying and confusing ways.

The alternative to lying to users is "presenting the truth to the
user" -- e.g., letting them know that there's a markup language;
helping them to learn the markup language; helping them to perceive
the GUI editor as exactly what it _really_ is: a tool for manipulating
source texts in the markup language.

If you're presenting the truth to the user, then patch(1) and diff(3)
output are quite reasonable things to present.

Lying to the user, on the other hand, is often correlated with sexism.
All secrataries are dumb.  And mostly they're women.  Unlike us.

The early mac did a good job of simultaneously "not lying" and "hiding
the markup language".   Alas, it did this by making a document format
that was very limited in its expressive capabilities.

MSFT has done a good job of lying -- and shaping reality to conform to
their lie.   For quite a few years now, the emphasis in free software
projects aimed at providing "office productivity software" has been to
prove, "hey, man, we can lie just as well as MSFT."

-t