On Tue, Sep 4, 2018 at 5:35 AM Andy Kosela <akosela@andykosela.com> wrote:
On Tuesday, September 4, 2018, ron minnich <rminnich@gmail.com> wrote:
On Mon, Sep 3, 2018 at 11:11 PM Andy Kosela <akosela@andykosela.com> wrote:
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 "bitmapped graphical displays."

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.