You often learn the golden rule or some variation of it as early as kindergarten. There are several ways to phrase it, but you most often hear: “Do unto others as you would have them do unto you.” While that’s catchy, it is really an aphorism that encourages us to consider the viewpoints of others. As people who design things, this can be tricky. Sometimes, what you want isn’t necessarily what most people want, and — conversely — you might not appreciate what most people want or need.
EDIT/1000
For example, printing a few lines around the current line requires the command: “/-2,L,5” which isn’t that hard, I suppose. To delete all lines that contain a percent sign, “1$ D/%/A/” assuming you don’t want to be asked about each deletion.
Sure, sure. As a Hackaday reader, you don’t find this hard to puzzle out or remember. But back in the 1980s, a bunch of physicists and chemical engineers had little patience for stuff like that. However, the editor had a trick up its sleeve.
Old Terminal Basics
Old HP terminals didn’t work like you think of a terminal today. The computer would send a whole screen to the terminal along with some instructions. This was common on several brands of computers, even though it is rare today. For example, the computer might send a form with some data. The user can then use the terminal to modify the data or add new data. Then, with a single keystroke, the entire screen goes back to the computer for processing.
In the case of EDIT/1000, you could invoke screen mode, which would load a page of text into your terminal. Then you could use the arrow keys, insert, delete and the experience wasn’t too far from using a text editor today. Until you wanted to change pages, that is.
You’d use /S to start the screen mode from the current location in a file. But to move forward you needed to use Control+F. Well, that’s if you wanted to send your changes to the computer. You could also move forward and discard your changes by pressing Control+F twice. There were a handful of other commands you could use in screen mode. To do things like search and replace, you still needed the oddball commands along with the Control+X incantation to execute a command while in screen mode.
Complaint Department
We heard no end of complaints about EDIT/1000 and spent a lot of time helping people fix their mistakes made while editing. Training didn’t really seem to help. There didn’t seem to be any other reasonable options as far as buying a different editor.
The problem is, we were split into two camps. People who knew how to use EDIT/1000 well and people who needed to use it, but didn’t really know anything about it.
One More Puzzle Piece
HP terminals of the day all had an interesting feature. The keyboards had nine keys along the top row — what you’d think of as function keys today. The monitors always had eight little spots at the bottom that had labels for what the keys did. The ninth key let you page through a couple of sets of function keys. You can see that in the HP terminal teardown video below.
So F1 might have “Help” on the screen above it, unless you set the next page where it might say “Clear” or something. The effect was best on the terminals where the keyboard and screen were one piece so the labels lined up.
Then One Day…
I was thinking, probably uncharitably, about how stupid people were that couldn’t learn how to use the editor. I happened to be setting up custom function keys at the time. I wrote a quick program to put a few editor-specific keys on the terminal like “next page” and “previous page” and mapped them to the correct commands.
That worked fine, and then I wrote a short program to launch the editor on a file and put it into screen mode. I grabbed someone passing by and had them try it. By the end of the day, everyone was using “my” editor.
No Genius
I can’t overstate how simple this was. I later reduced it to just a batch file that copied a text file to the terminal to set the function keys, and then launched the editor. And everyone loved it. The people who knew how to use the editor didn’t need all this, of course. And they knew how easy it was. But they loved that it saved people asking dumb questions or messing up their files. The other users just loved it because it made the editor easy.
This predates easy access to the Internet, and a common thing in those days was to trade tapes with other sites. You’d get a magnetic tape in the mail, mount it, look at what was on it, copying anything you found interesting. Then you’d add anything you had to the end, and send it to the next place. In a year or so, the tape would make its way back around to you and the process would repeat. I put my editor on the outbound tape.
Within a year or so, people were literally finding me — hard to do in those days — and sending me real letters thanking me for my editor solution.
The Moral
The script to do this was extremely trivial. It probably took 10 minutes to write and once you knew how to do it, maybe less. But the point was, the people who knew how to write the script didn’t need it. The people who needed it were those who had no more idea how to program function keys than I know how to perform open heart surgery.
It doesn’t matter if it is hardware or software. Getting into the heads of users can really pay off.
My brother is an Excel guru. He learned VBA and macros, he worked for small State budget office. He made many macros for his cow-orkers and bosses so they could print out Budget Reports. But often they came to him with a “one off” request. He’d tell them “I can teach you how to do this yourself in 15 minutes.”
But, most of them would refuse for various reasons (i.e. excuses).
He retired a couple of years ago. Then they contracted him to make videos explaining all things he was willing to show in the previous 20 years or so.
When I started undergrad, our school was using video terminals at 2400 baud attached to a VAX, and we were instructed how to use the line editor to enter programs. I saw someone using a screen editor, and immediately asked him what that was and how I could use it. That’s when I became an Emacs user.
Luxury!
We used to dream of edline.
We entered programs by using copy con: myprogram.exe
Then used Alt-keypad to enter the headers, opcodes and data.
Code like a Klingon (from Yorkshire)!
That was the improved version.
Before, we wrote basic programs to poke the real program into memory.
And we liked it.
At least we didn’t have to learn an OS (emacs), just to edit a file.
‘Do onto others as they are planning to do to you, but do it first.’ is a grownup golden rule
Beware edge cases around oral. Not an obligation.
“It doesn’t matter if it is hardware or software. Getting into the heads of users can really pay off.”
This is pretty much a universal truth for any human endeavor. Think about how what you make or do can make another person’s life better, and everyone will be happier, more productive, and better off.
Pay it forward.
Or for the more cynical: “It’s always good business to know your customers.” (Ferengi RoA#194)
There’s some dispute about the text and the actual number of that Ferengi Rule of Acquisition. But your overall point is well made.
“It doesn’t matter if it is hardware or software. Getting into the heads of users can really pay off.”
Just be sure it pays off to YOU, in the long or short term, not to a middle man, and be sure your customers,employers or friends knows that they are happier, more productive, and better off, thanks to YOU. Yeah I know, I know, but I didn’t invent the game, the rules were here already when I came in :)
If your user interface is not intuitive enough that someone can easily figure out what they need to do on their own you need to work on it to make it better, create better documentation or both. You also shouldn’t release a new interface that is missing functionality that the previous interface had (I’m looking at YOU Microsoft). It’s also a good idea to think through your interface fully BEFORE you start coding as going back and retrofitting functionality in might be a lot more work if you didn’t plan for the functionality in the first place.
ah, yes. memories of using cande on a burroughs b800 with td830 terminals. the editor would load a page into the terminal, you’d edit it locally, then transmit it back.
the td830 could also do forms. the computer could send a form containing text and a bunch of left-justified or right-justified fields. the user filled in the fields and sent the form back.
I babysat an HP1000 as well. Silicon on sapphire. Ours had the cool disk with the one button backup, that was kind of cool. We had a disk fail and HP was on site the next day. A van and 4 tech. The new “mech” came in a giant anvil case and they had a crane like thing they used to pull the old one out of the rack enclosure with and lower the new one into it with. And the 2628 terminals. Man that was a long time ago. HP kept up the weird crap even after the mini’s though. Their flavor of UNIX was meant to be used with one of their terminals. It was enough to make people not want to touch them. We had Sun’s that were a fraction of the speed but at least you could type on them. I spent some time collecting gripes and came out with and rc file that addressed most of the issues. Sun also got a lot of users mad with the move to Solaris. I recall they did a lot of the same. Just typing and using VI became a pain until you figured out what needed to be tamed.
I fondly remember the HP 1000-E, F, and M series (RTX-IVB). Fortran days. The big improvement in subsequent years was VAX-11/780s and PDP 11s, yet still assembly language, Fortran and C (but in those days also got to play with Snobol, lisp, Pascal, Modula-2 and Ada).
Oops RTE-11B