A throwback experiment with Linux and Unix: Introduction and set-up

I worked for a week in Linux like it was Unix from fifty years ago. This is my experience.

Today’s Linux distributions are quite modern. Desktop distributions feature a graphical user interface that allows users to interact with the system and launch applications with a few mouse clicks. Many Linux users may not even use the command line at all, except maybe to do a very few specific tasks.

While I do most of my work in a graphical Linux desktop environment, I still use the command line to do a lot of things. I find the command line is still a powerful way to get work done. And as a “throwback” experiment, I wanted to demonstrate that you can still do real work on Linux, using just a terminal and the command line, just like the original Unix.

As a proof of concept, I worked for a week in Linux like it was Unix from fifty years ago. Watch for a short series of articles coming soon where I detail my experience in this experiment of using Linux like it was Unix from 50 years ago. It’s interesting to explore what Unix was like all those years ago. This is my experience.

Read more: Technology history: Where Unix came from

Setting the stage

In the late 1960s, when Unix emerged at Bell Labs, the computing “interface” was usually via a TeleType terminal. The TeleType looked like an electric typewriter that printed on a long roll of paper. Bell Labs used a TeleType Model 37 terminal, although other, similar paper terminals were also available.

By the 1970s, video display terminals displaced the paper terminals. While simple, these video display units were not too far from the modern Linux terminal window experience, like using GNOME Terminal, Xfce Terminal, or KDE Konsole. I used this for my “retrocomputing” experiment; while I booted my computer into my graphical desktop, I did all of my work in a terminal window.

I restricted myself to only the commands that were available in an early version of Unix. I have a PDF copy of the Unix Programmer’s Manual, 4th Edition (November 1973) and used that as my reference guide for what commands I could use during my experiment. Despite being over fifty years old, Unix 4th Edition already supported familiar commands like cat, cp, grep, man, and sort. For reference, I’ve included a list of all user commands in Unix 4th edition:

---

Unix 4th edition commands reference guide

---

However, Unix didn’t yet have some other commands that you might rely on; for example, the vi editor wouldn’t appear until 1978 in the Second Berkeley Software Distribution (the Unix variant developed at the University of California at Berkeley). Today, you might know vi as Vim, or Vi iMproved. The only editor on the original Unix was ed, a line-based editor.

Read more: Getting started with the Unix ‘ed’ editor

During this experiment, I assigned myself three tasks:

1. Write a FORTRAN 66 program
2. Prepare a document using nroff
3. Write several C programs

Building the environment

With those goals and limitations, I committed myself to using Linux like it was Unix from fifty years ago. I would only use the commands available in Unix 4th Edition to do my work. But first, I needed to set up my environment to more closely mimic the working environment from 1973 or 1974.

First, let’s change the shell prompt. By default, Fedora Linux sets up a Bash prompt that includes your username, host name, and current directory. For a system named fedora, where I’m in my home directory (~), my default prompt might look like this:

jhall@fedora:~$

But for that classic feel of Unix 4th Edition, we only need $ as a shell prompt. To change the standard shell prompt in Bash, set the PS1 variable:

jhall@fedora:~$ PS1='$ '

After that, the shell prompt will simply be the dollar sign with a space after it.

As part of the experiment, I needed to compile FORTRAN 66 programs. My Fedora Linux system doesn’t install FORTRAN by default, so I had to install the GNU FORTRAN compiler with dnf:

$ sudo dnf install gfortran

The GNU FORTRAN compiler is gfortran, but the FORTRAN compiler in Unix 4th Edition is fc. This is an internal command in Bash; the fc command edits the command history. To effectively “rename” the fc command to run the FORTRAN compiler, I had to make a command alias in Bash:

$ alias fc=$(which gfortran)

To work in nroff, I needed GNU groff, which provides the functionality of Unix nroff and troff. I already installed this package on my system, because I use groff quite often. If you don’t have groff on your system, you can install it via your package manager:

$ sudo dnf install groff

Finally, I needed to use ed to edit files. This may not be installed by default in all Linux systems, but it should be available to you as a package:

$ sudo dnf install ed

What it’s like (programming back in time)

As I compared my tasks to what was available in Unix 4th Edition, I hit a few snags.

For example, I find opportunities to use awk for lots of things; but awk wasn’t available yet in Unix. Aho, Weinberger, and Kernighan created the first awk in 1977, and Unix 4th Edition was released in 1973. If I needed to do something as simple as modify a test file by inserting a few lines, I couldn’t use awk to do it. Neither could I use commands like seq to create a test file with a list of numbers; seq first appeared in Unix 8th Edition in 1985.

If I needed one of these basic commands, that we take for granted today, but didn’t exist yet in classic Unix, I either had to write the tool myself or find another way to do it.

Read more: Explore the five steps of the FreeDOS boot sequence

Unix from fifty years ago

Follow along in this short series as I share my experience in using just the classic Unix commands, to do my work entirely at the terminal. This was a fun experiment to demonstrate what Unix was like fifty years ago. It reminded me of the power of using the command line, and the flexibility to do things my way. And yes, I was able to complete the three tasks I’d set for myself.

In doing so, I re-learned how to edit files in ed and how to format documents using nroff with the -ms macros. After a few hours of working entirely in the terminal, I found myself getting into a “zone.” Using a line-based editor like ed requires thinking differently about editing files, but the commands became familiar to me very quickly. After a few hours of using ed to edit files, I settled into a rhythm; after a day, I became productive. In fact, I wrote the first draft of this article in ed, although I finished it in a more modern text editor using markdown.

But times have changed, and the way we work is much different in 2024. These days, I rely on more visual tools like word processors to create documents, and programming editors and IDEs to write code. So while I enjoyed this look back at Unix from fifty years ago, I was also glad to return to my graphical desktop to do my work.

More from We Love Open Source

• Read part one of this tutorial series: Writing a FORTRAN 66 program
• Read part two of this tutorial series: Prepare a document using nroff
• Read part three of this tutorial series: Writing several C programs
• Read more from We Love Open Source: Technology history: Where Unix came from