Smart terminals: Personal computing’s true origin? (2023) | Hacker News Reader

Smart terminals: Personal computing’s true origin? (2023)

thehistoryofhowweplay.wordpress.com

66 pointsrbanffy14 comments

As someone with some knowledge of the BLIT and other intelligent terminals, I've often thought about them as an alternative path of evolution in computing. One we've kinda worked our way back to in a way - with much fatter clients.

> I've often thought about them as an alternative path of evolution in computing.

I never saw one in the flesh, but DEC's Gigi is a very interesting one - AFAIK, it's both a VT-100-like terminal (with Tek and ReGIS graphics) and a computer with BASIC. The computing world would be very different today if all personal computers had modems and could be terminals as well as computers.

> we've kinda worked our way back to

That's true. The first time I saw an HTML form I immediately thought of the 3270 block oriented terminals shooting screens back and forth rather than one character at a time.

> The computing world would be very different today if all personal computers had modems and could be terminals as well as computers.

Doesn't every smart phone have a modem and act both as a computer (running local software) and as a terminal (in the modern form of the web browser)?

Yes, but all that happened after the web, and it didn't happen (at least not immediately) to desktops and laptops. Now every computer is connected to a large global network, but when the Apple IIs roamed the Earth, every computer (except the extremely well funded ones) was an island.

We had large numbers of AT&T 3b2 + BLIT (well...5620s and 630s) setups in college. They were really fun to work on. Bit-mapped, portrait view display when most folks had 80x24 text, a real GUI (called 'layers') with a mouse, windows and apps and such. Even games. Especially nice was the fact that you could put a BLIT on the end of a 19.2k or higher serial line and get real work done.

There was a similar-but-different terminal from BBN called the BitGraph that was almost as nifty. Way more obscure these days.

To me, though, the pinnacle of 'traditional' serial terminals will always be the Tektronix 4100 and 4200 series. Graphics, color, very rich command set, a trackpad style 'mouse', even a graphics tablet. Good times.

> a real GUI (called 'layers') with a mouse, windows and apps and such

There is a Blit emulator in the Apple App Store, but I never found enough of the server side of Layers to be able to use it for anything (other than booting and looking awesome).

I am fascinated by these less traveled roads of computing.

> the pinnacle of 'traditional' serial terminals will always be the Tektronix 4100 and 4200 series

Those were very impressive machines. But sooooo expensive...

https://loomcom.com/3b2/

Emulate it to your hearts content.

but I never found enough of the server side of Layers

It should be in many of the various SVR3 releases and most of the SVR4s. I know those can be run in virtual machines of various kinds these days, and the distros are not exactly hard to find. There's even a guy working on a 3B2 emulator which obviously should have it. Might have to find that emulator and crank up the old Dell SVR4 and see if they'll talk.

I am fascinated by these less traveled roads of computing.

You might check out the MGR windowing system. It's an 'inspired by' doppelganger of layers. Ran on SunOS and some other old Unixen, as well as the Atari ST and others I forget. Source code is out there.

Those were very impressive machines. But sooooo expensive...

Still are on both counts.

Yeah, a working DMD emulator has been worked out, and also a distribution with layers.

Sort of? I don't disagree but this shift of locus for compute from the datacenter to the edge and back again is kind of like a pulsing heartbeat if you stick around long enough.

Mainframe -> form based terminals

Minicomputers (multiple servers) -> Terminals with flexibility in their formatting

Personal computers (combined terminal + compute)

Server farms (lots of servers) -> Thin X servers / Citrix style clients

Server farms (lots of servers) -> Web Browser (software implementation of a terminal with very flexible formatting)

Surprisingly, I wrote about it in BYTE Magazine back in the day (like in 1984) about how "intelligence" (which was code for programmability) in remote nodes lead to a separation of computation and presentation. There is a tremendous bandwidth advantage if you do it this way (sending text is less bandwidth than sending bitmaps or compressed video streams).

Exactly! I've been around long enough to experience that series of events from top to bottom.

That's the weird thing about this business. There's always a new generation saying 'this is dumb, we should do it differently' and things bounce back and forth.

As you say, smart terminals are one reason why an old mainframe could support so many users with so few resources - all that display and input processing offloaded in a very distributed fashion.

Web and Electron apps make me weep for what was.

There's also a history of something called shared-logic word processors, which was a few dumb terminals hard wired to a minicomputer with a printer and disk. The original IBM PC borrowed its monitor from IBM's shared-logic word processor.

Apple 1 is a good representative of transitional period of mid 1970s, as it is a computer and a dumb terminal on the same board.

Because terminals above a certain level of sophistication were small computers running dedicated terminal firmware didn't help them - it was unavoidable they'd end up not being cheaper than desktop computers running terminal software.

Reply on news.ycombinator.com