In the old days, computers had blinking lights. Indeed, old movies used to show computers working with blinking lights and tape reels moving back and forth.
My school computer was a PDP-8/L with a whopping memory of 4K 12 bit words back in 1971. (Here’s a picture of similar machines. Mine was like one of the tall racks, and my teletype looked the same as the one in the picture. We didn’t have any disk or tape drives, but we did have a high speed (300 cps) paper tape reader. We used a line-numbered language called Focal. The machine was roughly $8,500 at the time. With a 1.5 µsecond cycle time, it was a 0.66 Megahertz machine. It’s amazing how many things are etched in my memory)
There was a signup sheet for 20 minute “online” time slots . (Offline meant using one of the 2 other standalone teletypes to punch a program onto a paper tape.) A big sign said “Think Offline!”. Another note: (if I remember correctly)
Achtung: Das machine ist nicht fer gerfingerpoken und mittengraben. Ist easy snappen der springenwerk blowenfusen, und corkenpoppin mit spitzensparken. Ist nicht fer gewerken by das dumpkofen. Das rubbernecken sightseeren keepen das hands in das pockets. Relaxen und watchen das blinkenlights
The blinking lights actually conveyed useful information: you’d get to recognize patterns that meant particular things. The main I/O device was a teletype machine that would print at 10 chars per second on rolls of yellow paper. When the computer was almost finished outputting to the teletype and would then be ready for user input, I got to know the light pattern at which I could start typing ahead, a couple seconds before the teletype had finished.
The blinking lights on my first computer had 2 rows of lights: the 12 bit address for the Instruction pointer, and the 12 bits for the accumulator. (The PDP-8 had only one general register, called the accumulator.) There was a row of toggle switches on which I could toggle the dozen or so 12 bit words for the bootstrap loader into memory fairly quickly. Digital Equipment Corp PDP machines were all in octal (base 8: 3 bits per digit), not hexadecimal (base 16: 4 bits per digit). In fact, the PDP (Programmable Digital Processor) product line used alternating colors for the switches: orange/yellow for the PDP-8/L line, dark/light green for the PDP-12 line, light pink/dark pink for the PDP-11, etc. The memory was all core memory: which means little magnetic donuts and that power down/up didn’t lose data.
A highlight of my junior high years was a visit to the old mill at DEC headquarters in Maynard, Mass. Employees had 24 hr access to all the machines, with no sign-up sheets! Wow! I wanted to work there!
(Quote: The venture capitalist's insistance on avoiding the term computer was based on the stereotype that computers were big and expensive, needing a computer center and a large staff; by using the term Programmable Data Processor, or PDP, DEC avoided this stereotype.)
Eleven years later, in 1982 I bought my first IBM PC. At 4.77 Mhz it had a whopping 256k of ram, 2 floppy drives, no hard disk and no monitor (I used the homebuilt 25” HeathKit color TV for a monitor) for a whopping $3100. That was a very good investment: I learned tons about that architecture, much of which is still applicable today.
I took the cover off and had it sideways against the back of my desk, so the expansion bus was exposed, and I put in a wire-wrap board so I could add my own circuits.
I put a very simple circuit: two 8 bit Digital to Analog converters (D-A) and attached the input of the 1st to the high 8 bits of the PC address bus and the 2nd to the next 8 bits.
I then attached the 2 analog outputs of these D-As to the X-Y input of my homebuilt HeathKit oscilloscope.
The result was a dynamic plot of what areas of memory were executing code. It was a trace of what memory locations were being accessed at any given time. This means the instruction pointer and any memory accesses for data would show on the plot. Anything in the top part of the picture meant that the OS was executing code. Low meant the BIOS: above that was the running application. Then came the app’s data segment and the heap. When the app was in an idle loop, a pretty stable pattern was shown. When processing, the patterns would vary quite a bit.
Nowadays, if the computer seems idle, the only hint that the computer is in fact doing something is to run task manager (which shows a dynamic systray icon of processor usage) or perhaps watching the hard disk light blinking (or hearing it).
I have thoughts of doing a 2 dimensional D-A display for a modern PC, but it wouldn’t be too useful: with multiple processes running and thread switched, it would be hard for the hardware address bus to distinguish useful patterns. With the higher processor speeds, a much faster oscilloscope would be needed. Besides, I’ve only had laptop machines at home for years.
However, it’s not so hard to do something similar in software. For a particular process, you can hook an application’s calls to the operating system for memory allocation and draw a plot in a window of used memory as the application is running. I did this with Visual Foxpro to see the patterns of virtual and heap memory usage. I could use various colors to show various kinds of memory: virtual, heap, data engine, etc. I even could click on a block of memory and find out what that block was used for. This is a map of memory usage, rather than a trace of physical memory accesses, but it still is like blinking lights.
Analysis of these patterns led me to make some memory usage improvements in Foxpro.
(Perfmon is somewhat useful: it can show total virtual bytes used, page faults, etc. but they are plotted against time. It doesn’t show a map of the currently used memory.)