On Tue, Sep 4, 2018 at 5:35 AM Andy Kosela <akosela(a)andykosela.com> wrote:
On Tuesday, September 4, 2018, ron minnich
On Mon, Sep 3, 2018 at 11:11 PM Andy Kosela <akosela(a)andykosela.com>
That was one of the main reasons I disliked
Plan9. It embraced the
"windows interface" trend of the mid 80s.
well, you can believe that, and I can't stop you, but it's wrong.
Can you elaborate more on your point of view?
I don't mean to speak for Ron, but I think I know where he's coming from.
There has been a slow shift in the way we use computer interfaces and the
start of the "windows computing" revolution
certainly happened around mid
80s with companies like Apple, Microsoft or Commodore developing their own
version of GUI (which goes back to Xerox PARC of course). Unix received X
Window System from MIT in 1984.
Don't mistake "windows" (as in "stacking window manager") for
At the time people thought that GUI is the best and most useful interface
for the new era and text terminal computing is about
to die pretty soon.
Well it took at least 10 more years to happen and the introduction of World
Wide Web and Windows 95 certainly help solidify it.
When Plan 9 was created in the mid-late 80s exactly those ideas
circulated. Nothing comes from nothing, everything has its historical
context. In the late 80s in order to "innovate" it was natural to think
that abandoning text terminals is a "progress".
This is conflating two things: textual interfaces and the graphical
presentation of those interfaces. Plan 9 is about both.
Unix was born in an era where the TTY (that is, tele-typewriter, as in
"prints to paper") was still very much a force in mediating the interaction
between user and computer. That evolved rather quickly to the "green
screen" terminals of the 70s and early 80s, but the paradigm was basically
the same: the serial terminal was a window showing the tail of an infinite
scroll of data. The "terminal", as in the TTY, was and is a central
abstraction in Unix.
By the late 80s, when plan9 got started, the paradigm had shifted: machines
now had relatively high resolution bitmapped graphical interfaces, and by
and large you weren't sitting in front of a serial terminal anymore. Being
tied to a single "terminal" was a hindrance and led to a lot of complexity
(job control, terminal interactions with process groups, POSIX sessions,
signals and ioctls for window-size changes for programs that wanted to
continue believing that they're using a serial terminal, even though they
haven't been for years...).
Plan9 wanted to take advantage of the new graphics functionality but didn't
want to be chained to the complexity associated with obsolete hardware
(e.g., the TTY abstraction, which _still persists_ and has its fingers in
weird parts of the kernel).
They still wanted a text-oriented interface though, and that's what plan9
provides. You sweep out a rio window and it's running a shell. Text in acme
is usually editable and there aren't a lot of strange glyphs to click on;
commands are strings. And you're no longer chained to a "terminal": I can
have many shells running in many windows and they're all more or less the
same. And it allowed them to move beyond the limitations of
cursor-addressed user interfaces. They could, for example, write (or more
precisely adapt) text editors like `sam`, which is fundamentally a textual
program but uses the GUI to very nice effect. It may seem dated by today's
standards, but it still works very nicely (indeed, I had to run a coworker
through a sam session last Thursday; he was a continent away from me
connecting to a plan9 system but we were able to do what needed to be done
relatively quickly because it's all text and so simple...).
I remember when I was in high school driving over to New Jersey and going
to Bell Labs and meeting Dennis Ritchie for the first time (a college
student I knew was doing an internship there and let me come visit). Dennis
showed me plan9 on his gnot (this was back in the 8.5 days), and
specifically talked about this: the focus was text, which was editable,
could be manipulated, combined, split apart, was self-explanatory etc,
instead of little icons like MS Windows and the Mac which were
simultaneously static and cryptic. It *is* a textual interface, though it's
*presented* and *multiplexed* via a bitmapped graphics display.
I distinctly remember feeling blown away by the powerful marriage of text
with bitmapped displays; it was a GUI for a Unix-like experience done
right. They didn't sacrifice anything, but they gained so much more.
Unix was born in the different era. Same with the original IBM PC. That
is why they revolve around pure text interface.
Unix and the PC date from radically different eras.
The original IBM PC had a graphics adapter, and that was the expected mode
of interaction, not the serial port. Granted that adapter was pretty weak,
but it was there. Using a PC, you were using a graphical representation of
your text interface. Unlike a serial terminal, where you simply emit the
text to the terminal and the terminal deals with displaying it, writing an
interface for CGA or MGA -- even in text mode -- involves scrolling the
buffer, handling line feeds, tab and backspace expansion, and all the rest
of it in software (granted, lots of serial drivers for Unix handle tab and
BS expansion, too). But you, the programmer, have to manually keep track of
your position in that little 4k buffer. You have to deal with moving the
cursor around, etc.
- Dan C.