We don’t give much thought these days to what “Unix” means. In 2023, most Unix systems are actually running some version of Linux, which includes modern tools and commands that were unthinkable when Unix hit the scene in the early 1970s. But some 50 years later, “Unix” still lives on.
Setting the stage
I wanted to look back on Unix history and experience first-hand what it was like to use the original Unix. Unix 2nd Edition debuted in June 1972, and I chose that version as my target. That’s transporting back in time by about 50 years.
A big part of running Linux as the original Unix was the interface. I run my desktop Linux with GNOME, where I use GUI-based applications like LibreOffice, Firefox, Inkscape, and Rhythmbox. But 50 years ago, Unix didn’t have a graphical interface. Everything was plain text.
In the late 1960s, the standard computing “interface” was the teletype terminal, like an electronic typewriter that printed input and output on a long roll of paper. By the 1970s, electronic display terminals displaced the teletype. While simple, these “video display units” approached what we recognize today as a terminal emulator window.
The Unix team at Bell Labs used terminals in the early 1970s, and that’s how I decided to use Linux for my throwback experiment. While I still booted my Linux system into GNOME, I did all of my work in a full-screen GNOME Terminal.
For several weeks, I used Linux system like an early Unix terminal from 1973. I restricted myself to only the commands that were available at the time, according to a copy of the Unix Programmer’s Manual, Second Edition (June 12, 1972). For example, I interacted with Linux only via the command line and edited files using ed, just like original Unix.
I assigned myself a few tasks for this experiment:
- Write a non-trivial C program with the ed editor
- Write a FORTRAN66 program
- Prepare a document using nroff
What it’s like
With those limitations, I threw myself into Unix from 50 years ago. At first, the difference was jarring. While I like the command line, I wasn’t able to use many of the modern commands I’d grown accustomed to. Even the multipurpose awk command was missing; awk was created in 1977 and first appeared in Unix 7th Edition in 1979.
Despite the gap of so many years, the command line felt familiar. The original Unix tools introduced in Unix 1st Edition (1971) included commands we use every day on Linux systems, such as cat to display files, cp to copy files, df and du to report disk usage, ls to list files, rm and rmdir to remove files and directories, and a long list of other now-familiar commands. Unix 2nd Edition also introduced the man command to read system documentation, processed via nroff.
Yes, I was able to complete the three tasks I’d set for myself. I wrote several C programs, including a special file-loading function for another project I’m working on, entirely in ed:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 |
$ ed readfile.c 623 P *1,10n 1 #include <stdio.h> 2 #include <stdlib.h> 3 4 char * 5 readfile(FILE * input) 6 { 7 /* reads an entire data file into memory, and returns 8 a pointer to memory containing the null term string. 9 the caller must free() the memory later. */ 10 *25,$n 25 } 26 27 /* read the file into memory */ 28 29 rewind(input); 30 fread(data, filesize, 1, input); 31 32 /* null terminate */ 33 34 data[filesize] = 0; 35 36 return data; 37 } *q $ gcc -c -Wall readfile.c $ ls readfile* readfile.c readfile.h readfile.o |
The GNU gfortran compiler is backwards-compatible with previous iterations of the FORTRAN language, and is able to compile a FORTRAN66 program without problems. I used gfortran to write a FORTRAN66 program that performed numerical analysis simulation of trajectory data, similar to other data analysis programs I wrote as an undergraduate physics student in the early 1990s.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 |
$ ed traj.f 1353 P *1,10p PROGRAM TRAJPRG C PRINT A TRAJECTORY RESULTS TABLE C PROMPTS THE USER FOR THE INIT VEL AND INIT ANGLE C THEN FOLLOWS A TRAJECTORY UNTIL Y .LE. ZERO PARAMETER(PI=3.14159265367) PARAMETER(GRAV=9.8) DOUBLEPRECISION X,Y,ANGLE0 DOUBLEPRECISION VEL0,VELX,VELY DOUBLEPRECISION TIME, TIMESTEP PRINT *, 'TRAJECTORY SIMULATOR' *1c PROGRAM TRAJ . *w 1350 *q $ alias f77=gfortran $ f77 -Wall -o traj traj.f $ ls traj* traj traj.f |
I relearned nroff and created my own set of macros to help write a few documents. I used GNU groff to emulate the old nroff, and wrote my own macros. The first draft of this article was written like this:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 |
$ ed unix 305 P *1,10n 1 .de P 2 .sp 3 .ti 5 4 .. 5 .sp 4 6 .ce 1 7 Run Linux like original Unix 8 .sp 9 .ti 5 10 We don't give much thought these days to what "Unix" means. *8,9c .P . *1i .de H1 .sp 4 .ce 1 .. . *8,11n 8 .. 9 .sp 4 10 .ce 1 11 Run Linux like original Unix *9,10c .H1 . *w 312 *q $ nroff unix | head Run Linux like original Unix We don’t give much thought these days to what "Unix" means. In 2023, most Unix systems are actually running some kind of Lin‐ ux, which provides modern tools and commands that were unthink‐ able when Unix hit the scene in the early 1970s. |
After a few hours of working entirely at the terminal, I settled into a rhythm. After another day, I became quite productive. Once I slipped into the mindset of working entirely in character mode, leveraging the command line to process plain text files, things felt fairly smooth. I became more comfortable using ed to work on files, and soon the editor’s commands became almost second nature to me.
Working completely inside a terminal, I found myself getting into a “zone.” At the end of each day during the experiment, it felt a little weird to check my email in a graphical client, or to visit websites in a web browser. The terminal is a different experience, yet very effective.
End of line
This was a fun experiment to demonstrate what Unix was like 50 years ago. It reminded me about the power of using the command line, and the flexibility to do things my way. I first used Unix systems in 1992 as an undergraduate student, and this experience reminded me why I fell in love with the command line. If you don’t mind typing your commands, and learning a little command syntax, you can do almost anything.
But times have changed, and our work has changed with it. These days, I can’t manage my daily work entirely from the terminal; I rely on visual tools such as word processors, graphics programs, and web browsers. So while I enjoyed this look back at early Unix, I was also glad to return to my GNOME desktop when it was over. But it’s nice to know that I could still use Linux like Unix from 50 years ago.
0 Comments