Advent of Computing: Recent Episodes
Sean Haas
Welcome to Advent of Computing, the show that talks about the shocking, intriguing, and all too often relevant history of computing. A lot of little things we take for granted today have rich stories behind their creation, in each episode we will learn how older tech has lead to our modern world.
It's no secret that I've been fascinated by odd UNIX clones for a while. When I got invited back to speak at VCF West this year I decided to share that fascination with a captive audience. In this talk we look at Idris and CROMIX, and ask the simple question: why would you want UNIX free UNIX?
VCFed will be posting the video version of this presentation in the coming weeks. I'll add a link here once that's up.
SEE my slides, here: https://docs.google.com/presentation/d/1v21An2jTGbKn4HV7Orr7xQcjnj3Cju_iMgNX50UcjeI/edit?usp=sharing
Install Co-Idris: https://github.com/hansake/Whitesmiths-Idris-OS
Install ST-Idris: https://github.com/9nut/IDRIS-OS-for-Atari-ST
And DEFINITELY install CROMIX: https://www.sydneysmith.com/wordpress/run-cromix/
In 1950 Northrup unveiled their MAgnetic Drum DIgital Differential Analyser. The machine is a wild piece of technology; a rendering of an analog computer in digital encoding. But how did we get here? How did a project to guide a missile lead to a mass produced computer? And what does it have to do with suspiciously dry martinis?
Selected Sources:
https://sci-hub.st/10.1109/MAHC.2003.1179869 - 2003 paper on MADDIDA
Like Advent of Computing? Then check out the after show! Adjunct of Computing is now LIVE: YouTube Spotify Apple Podcasts
EMUL-8 is a fascinating programming language. It's described in just one paper from 1977. It's a mix of features from APL, LISP, ALGOL, and SNOBOL. And, I think, it's a wonderful window into how counterculture and home computing collided.
I mean that both in the specific and the abstract. This episode we are looking at APL, which stands for A Programming Language. APL was developed in the mid 50s, but didn't see a working implementation until 1965. It's a language that truly looks like no others, but has some odd parallels to everything from BASIC to LISP to linear algebra.
Learn APL at: tryapl.org https://www.jsoftware.com/papers/APL.htm - A Programming Language
Dale Biagio(author of Hello, World!) got in touch with me recently. He said he had a book full of short histories of programming languages. Better still, it has sources! How could I resist! In this episode I sit down with Dale to talk about the intersection of technical and human histories.
You can find more about Hello, World! at Dale's website:
https://helloworldthebook.com/
I've been browsing old compur surveys and trying to build up a comprehensive data set. What I've found is a little surprising: between late 1945 and 1949 only 10 new computers entered service. Once we get to the 50s that number explodes. What's going on here? What caused the gap between the first digital machines and the explosion of computers in the 50s? In this episode I try to answer that question by finding out just what was going on during this digital gap.
Like Advent of Computing? Then check out the after show! Adjunct of Computing is now LIVE: YouTube Spotify Apple Podcasts
What connects IBM, the NSA, the Third Reich, and high fidelity recordings of symphonies? The answer is: magnetic drum memory. Join me as I lose all track of scope and plot to discovery just how and why magnetic drum memory was invented.
Like Advent of Computing? Then check out the after show! Adjunct of Computing is now LIVE: YouTube Spotify Apple Podcasts
In 1947 Raytheon signed a contract to make their first computer. It would be their last... at least for many many years. The fruits of this contract was RAYDAC. Early digital computers were odd, to say the least. And RAYDAC distinguishes itself. From zig-zag delay lines to hunting tapes to freon cooling, it truly is a unique machine.
Selected Sources:
https://ed-thelen.org/McGee_Book-4.2.2.pdf - McGee on his experience programming RAYDAC
https://sci-hub.st/10.1109/JRPROC.1948.232626 - A Digital Computer for Scientific Applications
https://www.jstor.org/stable/2002859 - The Logical Design of RAYDAC
Like Advent of Computing? Then check out the after show! Adjunct of Computing is now LIVE: YouTube Spotify Apple Podcasts
The image of a mainframe is almost always accompanied by it's companion: the magnetic tape drive. For decades magnetic tape served as the medium of choice for computing. It was faster than punch cards, and more available than hard drives. But where did it come from? Is it a borrowed technology like the vacuum tube?
Like Advent of Computing? Then check out the after show! Adjunct of Computing is now LIVE: YouTube Spotify Apple Podcasts
In which we discuss GPSS: the General Purpose Simulation Language. As for as languages go, this is a unique one. It's designed for certain types of simulations. It's code is just a handy way to feed a flowchart into a computer. It's design is closer to an analog computer than it is to a programming language. Yet GPSS is Turing Complete. Step inside and prepare to be... confused!
The big source of the show:
https://dl.acm.org/doi/epdf/10.1145/960118.808382 - The Development of GPSS
Like Advent of Computing? Then check out the after show! Adjunct of Computing is now LIVE: YouTube Spotify Apple Podcasts
The Olivetti Programma 101 isn't quite like any other machine. On first glance it looks like a big desktop calculator. Inside, it's a purebred computer... but strange one. It uses twisted spring steel for memory, has no addresses, and it's machine code looks more like a spell than a program. It's existence is due, in no small part, to a man being very mean to GE engineers.
Like Advent of Computing? Then check out the after show! Adjunct of Computing is now LIVE: YouTube Spotify Apple Podcasts
Dan Temkin has been a long time friend of the show. I finally got the chance to sit down and talk with him about one of his latest projects. Forty-Four Esolangs is a "The first artist's monograph of programming languages". During this interview we keep circling around one very crucial question: what really is a programming language?
Get the book and learn more about esolangs here:
https://danieltemkin.com/Esolangs
Who wants to hear me make incorrect assumptions about old software? RSX is a system that, from the outside, can sound like it has a similar story to that of UNIX. First developed for the PDP-15 in 1969, RSX becomes much more well known when it migrates to the PDP-11. It becomes a multitasking and multiuser system. A key difference is niche. While UNIX is a very general purpose system RSX is built for real time. That leads to something very unique.
UNIX is beloved by many. It's the classic minicomputer operating system. It's big, it's powerful, it's multitasking, and it has some very specific memory requirements. So what happens when you try and get UNIX to run on a microcomputer? Hilarity ensues.
Today we are looking at 3 small versions of UNIX: OMNIX, LSX, and CROMIX. And, I'll tell you, one of these is closer to vaporware than the others.
Today we are talking about one of the most unique languages I've ever come across. SNOBOL emerges from the early days of programming. It's first compiler is implemented on the back of an envelope. It only has one data type, and only one format for every line of code. It's the bane of Chester, and center of an office drama! What's not to love?
Selected sources:
https://dl.acm.org/doi/epdf/10.1145/960118.808393 - Griswold's history of SNOBOL
https://dl.acm.org/doi/epdf/10.1145/321203.321207 - THE SNOBOL1 Paper
We are getting back to the actual digital family tree. In 1937 George Stibitz built a tiny binary adding circuit on his kitchen table using scraps he "liberated" from his job at Bell Labs. In 1940 he demonstrated a machine he called a computer. That research forms one of the foundations of modern computing. It also forms a weird temporal phenomenon that I have yet to name. Maybe the Curse of '37?
Selected Sources:
Zeroth Generation by George Stibitz (NOW WITH A 2nd EDITION!)
http://www.bitsavers.org/magazines/Datamation/196704.pdf - Stibitz in Datamation
Hybrid computers are composed of a digital computer linked to an analog computer. That leads to an interesting challenge: how do you write software for one of these things? The analog side actively resists programming, while the digital side can't comprehend of continuous values. In the 1960s specialized languages appeared that tried to bridge this divide. And, I assure you, they are not at all like what you would expect.
In 1945 the first electronic digital computers sparked to life. Number crunching was instantly changed forever! The perfect technology had arrived, and there was never even a competition, right? Well, not so much. The simple fact is that computers sucked for decades. Digital machines have all kinds of inherent pitfalls. There was another entire lineage of computers that existed in the shadow of digital machines: the analogs. Eventually the two technologies would merge in an attempt to create the truly perfect machine: one with the flexibility and accuracy of a digital computer, and the speed and interactivity of an analog computer. The result were hybrids!
Last episode I said that Fourth Generation Languages were a topic for another time. Well... this counts as another time. Today we are trying to figure out what exactly makes a language 4th Generation. Along the way we will see why the term bugs me so much, why 4GLs seem so strange, and how a programmer can increase their productivity by 2,000% (some restrictions apply).
I'm back to normal episodes, and I'm running out the gate with a weird one. Thoroughbred/OS was a multi-user and multi-tasking operating system for the IBM PC. It's mian interface was... BASIC of all things! What exactly is this oddity?
https://winworldpc.com/product/thoroughbred-os/662 - Try Out Thoroughbred/OS yourself
I recently had the chance to talk to Ben Zotto about his upcoming book: Go Computer Now! - The Story of Sphere Computers. It's all about an obscure machine powered by the Motorola 6800 that released in 1975. I figured it was the perfect faire for my audience. And... I really want to read this book!
You can back the project over at kickstarter: http://kickstarter.com/projects/bzotto/go-computer-now-the-story-of-sphere?ref=ey52pt
And find out more at Ben's sites: https://gocomputernow.com/, https://sphere.computer/
In 1981 Joe Dellinger attempted to create the perfect computer program: a virus that spread silently. In 1982 a revision of that virus broke containment. It would have remained completely hidden if it wasn't for an obscure Apple II game. Today we look at the story and motivation behind that virus, and how it slipped into the sands of time. Or... did it!? The truth is if you have an Apple II it may be infected with Dellinger's virus!
My main source: https://virus.wdfiles.com/local--files/applvir/Applvir.txt
Imagine a secret number that could be used to bring your computer to a screeching halt. In 1977 Gerry Wheeler discovered an interesting feature of Motorola's new 6800 microprocessor. There was a secret instruction that, if read, would cause the processor to stop working. He called this magic number Halt and Catch Fire, or HCF, and wrote a neat article about the operation. This was the first time the public would learn about the secret powers of HCF, but this isn't actually the beginning of the story. When it comes to HCF things are more complicated than that... but only a little bit!
Have you ever had a computer do something you can't explain? Have you ever thought a machine had a mind of its own? In 1971 Met Life was faced with this exact conundrum. Their tape drives, for some reason, were throwing tape all over the floor every night. Systems were checked and no flaws were found, but every morning an operator would walk in on an absolute mess. What could make a healthy machine spit up it's precious tape?
My trilogy on the PDP-11 concludes with a look at the far flung places this computer can take us. In this episode we look at some issues with claims of the PDP-11's linage, smuggling, Hungarian-made microcode, and much more. Along the way we answer the question: if the PDP-11 was such a good design then where was it during the home computing boom of the 80s?
This episode we continue my series on the PDP-11 by examining how DEC adapted to the advent of the microprocessor. Along the way we will see how the PDP-11 inspired new generations of computers, and the surprising connection to early digital hobbyists.
Last weekend I had the chance to talk about the LGP-30 and my emulation project at VCF West in Mountain View, CA. The showrunners will be posting a full video later, but that takes a while to go live. In the meantime, here's the audio I siphoned off the sound board and my slide deck.
View my slides here: https://drive.google.com/file/d/1E9-B3EzxudFWX0yJMevbbIkD2qRbBKWi/view?usp=sharing
View the emulator at: https://lgp30.org
The DEC PDP-11 is one of the most influential minicomputers of all time. Some would even call it the most influential computer of all time. But where exactly did it come from? How was it designed? This episode is the start of a 3 part series that will look at how the PDP-11 was created, adapted to changes, and the strange places it ended up.
In 1949 CSIRAC sprung to life in a lab in Sydney, Australia. It was a very early stored program computer. All machines of the era were unique. But CSIRAC, well, it was very unique indeed.
Selected Sources:
https://cis.unimelb.edu.au/about/csirac/music/reconstruction - The Music of CSIRAC
https://sci-hub.se/10.1109/MAHC.1984.10014 - Pearcy and Beard on CSIRAC
The first batch of digital computers emerge directly following WWII. The hallmark of this generation is uniqueness: no two computers are the same. However, there is a machine that bucks that trend. The IAS Machine, built in Princeton in the late 1940s, served as the inspiration for at least a dozen later computers. But how similar were these Princeton-class computers? What exactly was so special about the IAS Machine? And how does good 'ol Johnny von Neumann get tied up in all of this?
The Eastern Boarder map fundraiser
Selected Sources:
Bigelow Oral History - https://www.si.edu/media/NMAH/NMAH-AC0196_bige710120.pdf
Prelin IAS Machine Report - https://www.ias.edu/sites/default/files/library/Prelim_Disc_Logical_Design.pdf
Lunar Lander is one of the best loves video games of all time. The game was created in 1969 as an homage to the recent Apollo 11. From there it would only spread. Just about anything that can print text has it's own version of Lunar Lander.
The early history of this game is mixed up with something weird: two nearly identical programming languages. Today we will be using the history of Lunar Lander as a good excuse to look at an obscure tongue called FOCAL. This language is so close to BASIC that direct line-by-line translation is possible. But are the two connected?
In 1982 Intel released the iAPX 286. It's was the first heir to the smash-hit 8086. But the 286 was developed before the IBM PC put an Intel chip on every desk. It's design isn't influence by the PC. Rather, it reaches further into the past. Today we are looking at the strange melding of old technology, new ideas, and compatibility that lead to the 286.
In 1973 the world caught it's first glimpse of INTERCAL. It's a wild and wacky language, somewhere between comedy and cutting satire. But the compiler was never circulated. There would be later implementations, but that original compiler remained lost to time. That is, until now. This episode covers how the original source code was found, and my attempt to get it up and running.
Get the source code for INTERCAL72 here: https://github.com/rottytooth/INTERCAL72/
Read the original INTERCAL manual: https://3e8.org/pub/intercal.pdf
The S1 operating system can do it all! It can run on any computer, read any disk, and execute any software. It can be UNIX compatible, DOS compatible, and so, so much more! But... can S1 ship? Today we are talking about an operating system that sounds too good to be true. Is it another example of vaporware? Or is S1 really the world's most sophisticated operating system?
How do you make a computer act less like a computer? It sounds like some kind of riddle, but in the early 1960s it was an actual problem. As IBM customers transitioned from tabulators to computers they ran into all sorts of practical issues. Programmers became a hot commodity. But how do you find a programmer in 1959? And how can you even afford such a luxury? Wouldn't it be better if you could just use your new computer as a tabulator? Well, with RPG, all that and more was possible.
In the early 1960s a neat little machine came out of MIT. Well, kind of MIT. The machine was called LINC. It was small, flexible, and designed to live in laboratories. Some have called it the first personal computer. But, is that true? Does it have some secret that will unseat my beloved LGP-30? And how does DEC fit into the picture?
The LGP-30 is one of my favorite computers. It's small, scrappy, strange, and wonderous. Among its many wonders are two obscure languages: ACT-I and ACT-III. In this episode we are exploring the ACTS, how the LGP-30 was programmed in practice, and why I've been losing sleep for the last few weeks.
When I was down at VCF SoCal I ran into a strange machine: the Keypact Micro-VIP. It's a terminal without a keyboard, covered in dials, with a speaker and a switch labeled "voice". This chance encounter with the unknown sent me down a wild path. It involved the creeping spread of computing, chicken feed, door to door life insurance salesmen, and at least one early hacker.
A special treat from VCF SoCal. While visiting I had the chance to host a panel on restoration and preservation. I was joined by:
David from Usagi Electric (https://www.youtube.com/@UsagiElectric)
Rob from Souther Amis (https://www.southernamis.com/)
Jim, Former Executive Director Computer Museum of America (https://computerhalloffame.org/home/about/)
Have you ever looked at an old computer and seen a weird typewriter thing tacked on? In most cases that's a device called a Flexowriter. It's half electric typewriter, half teleprinter, half tape reader, and all business! This episode we are chronicling the rise, fall, and weird business dealings of the Flexowriter.
In the modern day Windows is a power house, but that wasn't always the case. In this episode we are looking at the fraught development of Windows 1.0. During development it was called vaporware, it was panned in the press, roasted at at least one trade show, and even called... "eclectic". Through it all a vision in lime green would take form.
This episode we are taking a trip back to UNIX world. We're looking at IDRIS, the first clone of UNIX. It was supposed to be highly compatible, but use no code from Bell Labs. IDRIS ran on everything from the Intel 8080 up to the IBM System/370. There was even a version that could run MS-DOS programs. Sound too good to be true? Well, that may be the case.
Selected Sources:
https://archive.org/details/aquartercenturyofunixpeterh.salus_201910/page/n196/mode/1up - A Quarter Century of UNIX
https://github.com/hansake/Whitesmiths-Idris-OS - Co-Idris disk images and executables
In 1970 a little language called BLISS emerged from Carnegie Mellon University. It was a systems language, meant for operating systems and compilers. It was designed, in part, as a response to Dijkstra's famous Go To Considered Harmful paper. It had no data types. It used the most bizzare form of the pointer I've ever seen. And it was a direct competitor to C. Sound interesting, yet?
Selected Sources:
https://bitsavers.computerhistory.org/pdf/dec/decus/pdp10/DECUS-10-118-PartII_BlissReadings_Dec71.pdf - Readings on BLISS
https://www.cs.tufts.edu/~nr/cs257/archive/ronald-brender/bliss.pdf - A History of BLISS
In 1961 Texas Instruments unveiled the Molecular Electronic Computer, aka: Mol-E-Com. It was a machine that fit in the palm of your hand, but had all the power of a much larger computer. This was in an age of hefty machines, which made the achievement all the more marvelous. How was this even possible? It was all thanks to the wonders of molecular electronics, and a boat load of funding from the US Air Force.
Selected Sources:
https://web.archive.org/web/20160304071831/http://corphist.computerhistory.org/corphist/documents/doc-496d289787271.pdf - Invention of the Integrated Circuit, Kilby
https://archive.org/details/DTIC_AD0411614/page/n15/mode/2up - Investigation of Silicon Functional Blocks, TI
https://apps.dtic.mil/sti/tr/pdf/AD0273850.pdf - Silicon Semiconductor Networks, TI
The Z4, completed by Konrad Zuse in 1945, is a computer with a wild story. It was made from scrounged parts, survived years of bombing raids, moved all around Berlin, and eventually took refuge in basements and stables. In this episode we will follow the Z4's early days, and look at how it fits into the larger picture of Zuse's work. Along the way there is looting, rumors, and even... IBM!
Selected Sources:
The Computer, My Life - Konrad Zuse's autobiography
https://web.archive.org/web/20090220012346/http://delivery.acm.org/10.1145/370000/361515/p678-bauer.pdf?key1=361515&key2=3342588511&coll=&dl=acm&CFID=15151515&CFTOKEN=6184618 - Plankalkul, F.L. Bauer and H. Wossner
https://ieeexplore.ieee.org/document/9787324 - Architecture of the Z4, Rojas
In 1933 Konrad Zuse, a German civil engineer, caught the computing bug. It would consume the rest of his life. According Zuse he invented the world's first digital computer during WWII, working in near total isolation within the Third Reich. How true is this claim? Today we are looking at Zuse's early machines, the Z1, Z2, and Z3.
Selected Sources:
The Computer -- My Life, by Konrad Zuse
https://arxiv.org/pdf/1406.1886 - Z1 Architecture paper by Rojas
https://sci-hub.se/10.1109/85.707574 - Z3... Turing Complete? also by Rojas
Have you ever felt like a computer just refuses to work? Like a machine has a mind of it's own? In 1970 a hard drive at the National Farmers Union Corp. office decided to do just that. That year it started crashing for apparently no reason. It would take 2 years and 56 crashes to sort out the problem. The ultimate solution would leave more questions than answers. Was the hard drive haunted? Or was something else at play?
Selected Sources:
https://archive.org/details/computercrime0000mckn/page/98/mode/2up - Computer Crime
https://archive.org/details/sim_computerworld_1972-08-02_6_31/mode/1up?view=theater - Computer World article
This time we are diving back into the Jargon File to take a look at some hacker folklore. Back in the day hackers at MIT spent their time spying on one another's terminals. That is, until some intrepid programmer found a way to fight back.
Selected Sources:
http://www.catb.org/esr/jargon/html/os-and-jedgar.html - OS and JEDGAR
https://github.com/PDP-10/its - ITS restoration project
In 1962 Food Center Wholesale Grocers Inc installed a new IBM 305 RAMAC. That's when things started to go wrong. The faulty machine seemed to have a mind of it's own, and would spread chaos to grocery stores all around Boston.
Selected Sources:
https://archive.org/details/computerinsecuri0000norm - Computer Insecurity
https://bitsavers.computerhistory.org/magazines/Computers_And_Automation/196805.pdf - Computers and Automation article
https://archive.org/embed/sim_computerworld_january-01-08-1969_3_1 - Computerworld
Programming, as a practice and study, has been steadily evolving for the past 70 or so years. Over the languages have become more sophisticated and user friendly. New tools have been developed that make programming easier and better. But what was that first step? When exactly did programmers start trying to improve their lot in life? It probably all started with assembly language. Well, probably…
Selected Sources:
https://albert.ias.edu/server/api/core/bitstreams/d47626a1-c739-4445-b0d7-cc3ef692d381/content - Coding for ARC
https://sci-hub.se/10.1088/0950-7671/26/12/301 - The EDSAC http://bitsavers.informatik.uni-stuttgart.de/pdf//ibm/periodicals/Applied_Sci_Tech_Newsletter/Appl_Sci_Tech_Newsletter_10_Oct55.pdf - IBM Applied Sci Tech Newsletter
The early history of computer games is messy, weird, and surprising. This episode we are looking at HUTSPIEL, perhaps one of the oldest games ever played on a computer. It's a wargame developed to simulate nuclear conflict... and it's 100% analog. Join us as we find out just what tax dollars were being used for in 1955.
Selected Sources:
https://archive.org/details/hutspiel-a-theater-war-game - The HUTSPIEL paper
I'm finally back to my usual programming! This time we are taking one of my patent pending rambles through a topics. Today's victim: the humble type-in program. Along the way we will see how traditions formed around early type-in software, and how the practice shifted over time. Was this just a handy way to distribute code? Was this just an educational trick? The answers are more complex than you may first imagine.
Selected Sources:
https://s3data.computerhistory.org/pdp-1/DEC.pdp_1.1964.102650371.pdf - LISP for the PDP-1
https://archive.org/details/DigiBarnPeoplesComputerCompanyVol1No1Oct1972 - PCC Issue #1
https://archive.org/details/Whattodoafteryouhitreturn - What To Do After You Hit Return
LIVE from VCF West 2024, my talk on edge notched cards!
Since this is a live recording from an auditorium the audio is a little boomy, so be warned. Actually, I'm pretty sure this is the same space that CHM uses for some of their oral histories.
What I have today is just the audio component. VCF will be posting a full video eventually, which I'll be sure to pass around.
I've gotten busy preparing for VCF West, so this time you get a short one!
In this byte-sized episode we are looking at a short and strange story: that time a plane struck a software company, and the company turned around and used the crash in their own ads.
Have you ever formed a bad first impression? Way back when I formed a hasty impression of this language called TRAC. It's been called a proto-esoteric language, and for good reason. It's outlandish, complex, and confounding. But, after the urging of some listeners, I've decided to give TRAC a second look. What I've found is, perhaps, more confusing than I ever imagined. This episode we are looking at the wild history of TRAC, how it actually pioneered some good ideas, and why it feels so alien.
Selected Sources:
https://dl.acm.org/doi/pdf/10.1145/800197.806048 - 1965 TRAC paper
https://github.com/gmilmei/trac64 - TRAC64 processor in "modern" C
https://dl.acm.org/doi/pdf/10.1145/365230.365270 - 1966 TRAC paper, with more code!
In 1984 SCO released PC XENIX, a port of UNIX that ran on an IBM PC. To understand why that's such a technical feat, and how we even got here, we have to go back to the late 1970s. In this episode we are taking a look at how Microsoft got into the UNIX game, and how they repeatedly struggled to make micro-UNIX work for them. Along the way we run into vaporware, conspiracy, and the expected missing sources!
This episode I'm opening up my research vault to present some interesting pre-digital technology. Back before computers us humans used to write everything down on paper. Over time that lead to some organizational issues. By 1890 punch cards show up to solve one aspect of this problem, but that technology had it's limitations. We will be looking at other paper-based approaches to data management, as I slowly try and explain a realization I've come to about the early history of hypertext.
I'm currently out traveling. Due to my poor planning I managed to score back to back trips, for both business and leisure. While I'm not able to get an episode out on time, I do have a replacement!
In 2023 I was invited to speak at the Intelligent Speech conference. So, today, I present the audio of that talk. The topic is, of course, the wild path of the Intel 8086's creation and rise to power!
If you prefer to watch, here's the video of the same talk:
https://www.youtube.com/watch?v=6ud8LK3-eAM
In 1959 the world bore witness to a new type of computer: the PDP-1. It was the first interactive computer to really make a dent in the market. Some say it was the first minicomputer: a totally new class of machine. But where did this computer come from, and what made it so different from the rest of the digital pack?
Selected sources:
https://americanhistory.si.edu/comphist/olsen.html - Smithsonian interview with Ken Olsen
https://archive.computerhistory.org/resources/access/text/2019/03/102785079-05-01-acc.pdf - Computing in the Middle Ages
https://archive.org/details/bitsavers_decBooksBeng_37322315 - Computer Egnineerling, Bell et al.
I've been feeling like rambling, so it's time for a classic ramble. This time we are looking at the origins of books about computers. More specifically, computer books targeted at a general audience. Along the way we stumble into the first public disclosure of digital computers, the first intentionally unimportant machine, and wild speculation about the future of mechanical brains.
No sources listed this time, because I want the journey to be a surprise!
This is a hefty one. I usually try to keep things as accessible as possible, but this time we have to get a little more technical than usual. We are picking up in 1964, with the first proposals for a new version of ALGOL. From there we sail through the fraught waters of ALGOL X, Y, W, and finally 68. Along the way we see how a language evolves over time, and how people and politics mesh with technical issues.
Selected Sources:
https://dl.acm.org/doi/pdf/10.5555/1061112.1061118 - Successes and Failures of the ALGOL Effort
https://sci-hub.se/10.1109/MAHC.2010.8 - Cold War Origins of IFIP
https://archive.computerhistory.org/resources/text/algol/algol_bulletin/ - The ALGOL Bulletin
ALGOL is one of those topics that's haunted the show for a while. It comes up any time we talk about programming languages, and with good reason. Many of the features and ideas found in modern languages have their roots in ALGOL. Despite that influence, ALGOL itself remains somewhat obscure. It never reached the highs of a C or LISP.
In this series we are going to look at ALGOL from 1958 all up to 1968, keeping a careful eye on how the language evolved, how it's problems were addressed, and how new problems were introduced.
Selected Sources:
https://www.softwarepreservation.org/projects/ALGOL/paper/Backus-Syntax_and_Semantics_of_Proposed_IAL.pdf - Backus, 1958 IAL report
https://algol60.org/reports/algol60_rr.pdf - ALGOL 1960 Report
https://dl.acm.org/doi/pdf/10.5555/1060960.1060966 - Cleaning Up Algol
Originally presented at VCF SoCal in February of 2024.
The cryotron, a superconductive switch, almost revolutionized computing. It's one of those fascinating near misses. In this episode we are talking about the history of the cryotron, how the NSA and supercomputing factors into the mix, and the current state of research into the topic. Did the NSA actually construct a supercomputer that ran in a vat of liquid helium? The answer is... maybe?
Video of this talk:
https://youtu.be/FqzSGTZ3TMU
This is going to be a wild rambling ride. In 1939 a computer called Nimatron was made. It was one of the earliest digital electronic computers in the world. It did one thing: play a game called Nim. Over a decade later, in 1951, another Nim machine hit the scene. This computer called Nimrod, was designed to demonstrate how computers worked... by playing a game of Nim. These machines, humble as they may sound, end up deeply complicating the history of computing. Join me as I, once again, muddy the long arc of progress. Selected Sources: https://archive.org/details/faster-than-thought-b.-v.-bowden - Faster Than Thought https://www.goodeveca.net/nimrod/NIMROD_Guide.html - Faster Than Thought
This episode wraps up the System/360 trilogy by taking things back to where they started for me. We will be looking at System/360 clones, how they could exist, why they existed, and why IBM didn't crush them. We close with a discussion of how these earlier clones impact our understanding of the IBM PC story. The truth is, by 1981 IBM was no stranger to clones. This is the culmination of a wild story, so prepare! Selected Sources: https://archive.org/details/iclbusinesstechn0000camp/mode/1up - ICL: A Business and Technical History https://archive.org/details/impactreportamdaunse/page/1/mode/1up - Impact Report by INPUT https://www.stayforever.de/ibm-pc-a-conversation-with-dr-david-bradley/
My coverage of the IBM System/360 continues! In this episode we look at US v IBM, and the fallout that surrounded the release of the System/360. By 1969 IBM already had a history of antitrust litigation. What was IBM doing to upset the Department of Justice, and how does it tie in to the larger story of clone computers? Selected Sources: http://www.cptech.org/at/ibm/ibm1956cd.html - 1956 Consent Decree https://supreme.justia.com/cases/federal/us/298/131/ - 1936 Consent Decree https://archive.org/details/foldedspindledmu00fish/page/n5/mode/2up - Folded, Spindled, and Mutilated
In this episode I sit down and talk with Micki and Steve about VCF SoCal, a new Vintage Computer Festival! The event is taking place in Orange, California on Febuary 16th and 17th. VCFs are a wonderful time, and a great opportunity to meet up with other retro enthusiasts.
The weekend will be filled with exhibits and speakers, including myself! I will be in attendence, and talking about some super cool technology. Stick around until the end of the interview for the full details.
More information on VCF SoCal can be found at: https://www.vcfsocal.com/
The release of the IBM System/360 represents a major milestone in the history of computing. In 1964 IBM announced the 360 as the first family of compatible computers. Users could choose a system that was just the right size for their needs, mix and match peripherals, and have no fear of future upgrades. If you started on a low-end 360 you could move up to a top of the line model and keep all your software! Something like this had never been done before. Such a watershed moment resulted in interesting cascading effects. In this episode we will look at the 360 itself. In the coming weeks we will be examining how it shaped and dominated the market, how it led to a federal antitrust suit, and how a mysterious series of clone computers survived in uncertain times. Selected Sources: https://spectrum.ieee.org/building-the-system360-mainframe-nearly-destroyed-ibm https://archive.computerhistory.org/resources/access/text/2012/11/102658255-05-01-acc.pdf - Fred Brooks Oral History https://archive.computerhistory.org/resources/access/text/2017/11/102655529-05-01-acc.pdf - 14K Days
Released in 1982, the Jupiter Ace is a fascinating little computer. It's hardware isn't much to write home about. It's just an 8-bit microcomputer very much in line with other systems of the era. Where it shines is it's software. In a period when most home computer ran some version of BASIC the Ace was using Forth. On the surface that might sound like a trivial difference, but that one deviation from the norm made all the difference in the world. Selected Sources: https://www.theregister.com/2012/09/21/jupiter_cantab_jupiter_ace_is_30_years_old - The Register article on the Ace https://jupiter-ace.co.uk/documents_index.html - Every other Ace resource you could ever want
Tools are the most important programs in the world. Without quality tools it's impossible to write quality software. One of those most important of those tools, and the most hotly coveted, is the text editor. These programs offer us a window into the digital world. It's no wonder that programmers the world over basically live inside text editors. In this episode will discuss when exactly that digital window was opened. When did text editors first appear? What forms did they take? Selected Sources: https://www.computerhistory.org/pdp-1/_media/pdf/DEC.pdp_1.1960.102650331.pdf - Colossal Typewriter Manual https://www.si.edu/media/NMAH/NMAH-AC1498_Transcript_StephenPiner.pdf - Piner Oral History https://opost.com/tenex/anhc-31-4-anec.pdf - The Beginnings of TECO
Most accounts of the early history of programming languages all share something in common. They all have a sentence or two explaining how there was great resistance to these new languages, but eventually all programmers were won over. Progress was made, despite the forces of counterrevolutionaries. What you won't find in most histories are the actual arguments these counterrevolutionaries made. This episode we are looking at those arguments. I've tracked down a handful of papers that argue against digital progress. Are these truly cursed articles, or is there something to be learned from arguments against programming? Selected Sources: https://dl.acm.org/doi/pdf/10.1145/1455270.1455272 - Why Not Try A Plugboard? https://dl.acm.org/doi/pdf/10.1145/367390.367404 - Comments from a FORTRAN User https://dl.acm.org/doi/pdf/10.1145/320932.320939 - Methods of Simulating a Differential Analyzer on a Digital Computer
Have you ever opined for a simpler time? Have you ever wanted a computer that you can understand all the way down to the silicon? Then RCA's COSMAC might be the architecture for you! COSMAC was a simplified computer architecture designed in the early 70s. It's tiny, cheap, and built to be easy to understand. But is the chip actually useful? Selected Sources: https://archive.org/details/manualzilla-id-5721710/page/26/mode/1up?view=theater - All the ELF articles in one place! https://sci-hub.se/10.1109/MC.1974.6323475 - A Simplified Microcomputer Architecture
This episode we are looking at a ghost of bygone days: batch processing! Before fancy terminals peppered computer rooms, before there was a microcomputer on every desk, there was the batch. In this non-interactive form of computing a user could wait hours, days, or even weeks to get a chance at computer time. Machines were kept well away from programmers, guarded by digital clerics. Why did such an arrangement exist? And did it ultimately help the programmer? Selected Sources: https://multicians.org/thvv/compatible-time-sharing-system.pdf - Compatible Timesharing System, 15th Anniversary https://sci-hub.se/10.1109/MAHC.1983.10026 - Rykman on GM-NAA I/O https://ethw.org/First-Hand:Operating_System_Roots - Operating System Roots
It's finally Spook Month here on Advent of Computing! To kick things off I'm tackling a bit of a mystery. Between 1972 and 1982 there is only one well documented virus. This period is book ended with plenty of sources and, yes, even viruses. But this decade long span of time has almost nothing! Was this era truly safe from the grips of malicious code? Or is there a secret history lurking just beneath the surface? Selected Sources: https://dl.acm.org/doi/pdf/10.1145/358453.358455 - Worms at Xerox PARC! https://archive.org/details/crimebycomputer0000park - Crime by Computer https://archive.org/details/dr_dobbs_journal_vol_05_201803/page/n89/mode/2up - Programming Pastimes and Pleasures
Byte has to be one of the most recognizable parts of the digital lexicon. It's an incantation that can be recognized by even the uninitiated. But where does the byte come from? Has it always existed, or did it more recently come into being? And, more specifically, why is a byte 8 bits? Is it some holdover from long ago, or is there some iron clad rule of 8's? Selected Sources: https://archive.org/details/byte-magazine-1977-02/page/n145/mode/1up?view=theater - Buchholz on the "byte" in BYTE! https://sci-hub.se/10.1049/pi-3.1949.0018 - A STORAGE SYSTEM FOR USE WITH BINARY-DIGITAL COMPUTING MACHINES https://ia600208.us.archive.org/32/items/firstdraftofrepo00vonn/firstdraftofrepo00vonn.pdf - The First Draft of a Report on EDVAC
It's finally time! In this episode we are looking at the Monte Carlo method, perhaps the first practical computer program that could outpace human capability. The best part: the method relies on a random walk to reach a statistically valid answer! Selected Sources: https://www.osti.gov/servlets/purl/10596 - Igniting the Light Elements https://library.lanl.gov/cgi-bin/getfile?00326866.pdf - The Beginning of the Monte Carlo Method, Nick Metropolis
I will admit, the title here is a bit of click bait. In the early 1950s a researcher named Nils Aall Barricelli started in on a bold project. His goal was to simulate evolution on a computer and, in doing so, create a perfect lab to study evolutionary processes. What he found was astonishing. Given a simple rule set these interesting patterns emerged. He called them symbioorganisms. Despite being simple numeric constructs, they exhibited many properties of living things. Did Barricelli create a digital form of life?
Selected Sources:
https://sci-hub.se/10.1007/BF01556771 - Numerical Testing of Evolution Theories. Please, just read this paper and be amazed!
This episode is simply a reading of the Story of Mel. I opened last episode with an excerpt, but didn't feel right leaving it at that. So, I present, the Story of Mel as written by Ed Nather and preserved in the Jargon file.
In 1956 Librascope released the LGP-30, a truly wild machine. It was, for the time, the most simple and cheap machine that could actually be useful. It was the size of a desk when contemporary machines took up small rooms. It plugged into a normal wall outlet while other machines requires special power feeds. It was, perhaps, the first hint of a personal computer. And at its heart was a magnetic drum that only a true programmer could love. Selected Sources: http://www.catb.org/jargon/html/story-of-mel.html - The Story of Mel https://sci-hub.se/10.1109/TEC.1957.5221555 - Frankel's MINAC Paper http://www.hp9825.com/html/stan_frankel.html - A Biography of Frankel
I'm wrapping up my dive into Prolog with... Prolog itself! This episode I'm actually covering the development of Prolog, using all the natural language processing lore we covered last time. Along the way we will see how Prolog developed from a set of tools, and how those tools were generalized into a useful language.
Selected Sources:
http://alain.colmerauer.free.fr/alcol/ArchivesPublications/PrologHistory/19november92.pdf - The Birth of Prolog
https://archive.org/details/introductiontoma0000hutc/mode/1up?q=%22q-systems%22&view=theater - An Introduction to Machine Translation
I've been told I need to do an episode about Prolog. Well, here's the start of that process. To talk about Prolog we first need to come to grips with natural language processing, it's tools, and it's languages. This episode we are doing just that, going from ELIZA to Planner ro SHRDLU in an attempt to figure out how AI was first taught human tongues, where smoke and mirrors end, and where facinting programming begins. Selected Sources: https://dl.acm.org/doi/pdf/10.1145/365153.365168 - ELIZA https://stacks.stanford.edu/file/druid:cm792pj8606/cm792pj8606.pdf - Planner https://web.archive.org/web/20200725084321/http://hci.stanford.edu/~winograd/shrdlu/AITR-235.pdf - SHRDLU
Space is cool, in all meanings of the word. Not only is it wondrous, vast, and fascinating, it can also be a cold place. It's also a very useful place to put things. This episode we are looking at the first practical use of space: communication satellites. Selected Source: https://archive.org/details/BigBounc1960 - The Big Bounce https://archive.org/details/dtic-ada-141865-ieee-centenial-journal-1984-ocr/page/n67/mode/2up - A Signal Corp Space Opera https://history.nasa.gov/SP-4308/ch6.htm - The Odyssey of Project Echo
I don't usually cover video games. When I do, you know it's for a weird reason. This episode we are looking at the Atari VCS 2600, it's strange hardware, and how it fits into the larger story of the rise of microprocessors. These new tiny chips were already changing the world, but they brought along their own problems.
Selected source:
https://spectrum.ieee.org/atari-2600 - Inventing the Atari 2600
https://archive.computerhistory.org/resources/access/text/2012/09/102658257-05-01-acc.pdf - Al Alcorn Oral History
https://www.digitpress.com/library/interviews/interview_bob_whitehead.html - Bob Whitehead Interview
What really is the deal with microcontrollers? Are they just little computers... or are they something totally different? This episode we are looking at the development of the microcontroller through the history of the TMS1000.
This episode we pick back up where we left off. We are looking at the roots of the Mundaneum, the applications of the Universal Decimal Code, and how it call connects to hypertext.
Selected Sources:
https://web.archive.org/web/20051227184732/http://people.lis.uiuc.edu/~wrayward/otlet/xanadu.htm - Visions of Xanadu
https://www.ideals.illinois.edu/items/4184 -- Selected Essays of Paul Otlet
The Internet is the closest we've come to a universal store of all human knowledge. However, it's not the first pass at this lofty goal. In this episode(and the next) we are looking at the Mundaneum, a project started in the 1890s to address the information problem. How is it connected to the larger story of hypertext? And how can this older project inform our views on the information problem? Selected sources: https://www.ideals.illinois.edu/items/4184 -- Selected Essays of Paul Otlet
Back in episode 90 I made a passing reference to the Cyclops, the first consumer digital camera. It's this masterstroke of hackery that uses a RAM chip as a makeshift image sensor. In this episode I'm coming back around to the Cyclops and taking a look at the origins of digital imaging in general.
Selected Sources:
https://www.youtube.com/watch?v=1gmSeVfmZHw - Terry Walker CHM lecture
https://sci-hub.ru/10.1109/6.591664 - The origins of the PN junction
https://sci-hub.ru/10.1364/AO.11.000522 - The silicon vidicon photometer
The Apple III was a pretty slick machine... in theory. From a lack of launch software, to strait up hardware failures, Apple's 3rd computer didn't really win in the market place. Why was that? Was the machine setup for failure from the start? Was it's case really designed before it's motherboard? When it comes to the III there's a surprising amount of folklore to untangle. Selected Sources: https://archive.org/details/sim_byte_1985-01_10_1/page/166/mode/1up?view=theater - Interview with Wozniak that covers the III https://www.digibarn.com/collections/systems/appleIII/sandersinterview.html - Sander discussing the project https://archive.org/details/apple-design/page/n14/mode/1up?view=theater - AppleDesign http://www.applelogic.org/AIIIDesignBugs.html - AppleLogic
We're finally taking a look at Sketchpad. This program was completed in 1963 as Ivan Sutherland's Ph.D. research. On the surface it looks like a very fancy drawing program. Under the hood it's hiding some impressive new programming techniques. Selected Sources: http://worrydream.com/refs/Sutherland-Sketchpad.pdf - Sutherland's Sketchpad thesis https://www.youtube.com/watch?v=495nCzxM9PI - Sketchpad in action https://www.computerhistory.org/collections/catalog/102738195 - Oral History transcripts
This episode I attempt to find the first interactive computer text interface. All I can say is, well, it's a journey. Selected Sources: https://sci-hub.se/10.2307/3917015 - Early article on Stibitz's CNC Model I https://archive.org/details/fortranprimer0000orga/page/103/mode/1up?view=theater - Primer on the FORTRAN Monitor System https://kyber.io/rawvids/LISP_I_Programmers_Manual_LISP_I_Programmers_Manual.pdf - LISP I manual
This episode picks up where we left off last time. We are looking at Ada and its applications. How does Ada handle tasking? What's the deal with objects? And, most importantly, what are some neat uses of the language? Selected Sources: https://dl.acm.org/doi/pdf/10.1145/956653.956654 - Rationale for the Design of Ada https://trs.jpl.nasa.gov/bitstream/handle/2014/45345/08-2590_A1b.pdf - Cassini's AACS computer and software http://www.bitsavers.org/components/intel/iAPX_432/171821-001_Introduction_to_the_iAPX_432_Architecture_Aug81.pdf - Behold the iAPX 432
Ada is a fascinating language with a fascinating history. It was initially developed as part of a Department of Defence project. The plan was to create a standardized language for everyone inside the DoD. The results, well, they may just surprise you.
Selected Sources:
http://archive.adaic.com/pol-hist/history/holwg-93/holwg-93.htm - Ada at the HOLWG
https://dl.acm.org/doi/pdf/10.1145/956653.956654 - Rationale for the Design of Ada
http://iment.com/maida/computer/requirements/strawman.htm - Strawman
Advent of Computing has finally reached 100 episodes! Today we are taking a break from the usual content to discuss the show, it's arc, and some of the mysteries I have yet to solve.
UNIX is a big deal. It's one of the most influential programs in history. Most operating systems that we use today can trace their lineage back to UNIX. The only notable exception at this point is Windows. But all these new-fangled operating systems aren't blood relatives of UNIX, they are all derivatives. Second cousins, if you will. So how did we get from UNIX into a diverse field of UNIX-like things? It all starts with a little project at UC Berkeley. Selected Sources: https://archive.computerhistory.org/resources/access/text/2022/06/102743073-05-01-acc.pdf - Oral History of Bill Joy https://archive.org/details/aquartercenturyofunixpeterh.salus_201910/page/n157/mode/2up?view=theater - A Quarter Century of UNIX
This time we are looking at a somewhat obscure machine: the Canon Cat. Designed by Jef Raskin, the Cat is sometimes called the spiritual successor to the Macintosh. That's a nice little epitaph, but doesn't fully explain the tangled mess of things between Raskin, Jobs, Apple, and the Mac. Today we will try to untangle some of that mess as we examine a fascinating little computer that could have changed the world.
Selected Sources:
http://www.canoncat.net/ -- Everything about the Cat
https://archive.org/details/Apple_Mac_Selected_Papers_1980/ -- Raskin's Macintosh memos
https://www.digibarn.com/friends/jef-raskin/writings/millions.html -- Computers by the Millions
We've approach the beast itself: SQL. Or, as it used to be known, SEQUEL. In this episode we will discuss how early navigational databases failed, and how we were able to move past them into a relational future. It's a fascinating tale about how careful research and planning can lead to much better tools.
Selected sources:
https://www.seas.upenn.edu/~zives/03f/cis550/codd.pdf -- Dr. Codd on relational databases
https://web.archive.org/web/20070926212100/http://www.almaden.ibm.com/cs/people/chamberlin/sequel-1974.pdf -- The first SEQUEL paper
https://people.eecs.berkeley.edu/~brewer/cs262/SystemR.pdf -- A History and Evaluation of System R
I've fallen into a bit of a data rabbit hole, and you get to join me. In this episode I'm starting my journey to understand where databases came from, and how they started to evolve. This will serve as a foundation for next episode, when we will dive into one of the most popular databases from the 1970s: SQL. Along the way we wrestle with GE, the realities of the Apollo Program, and try to figure out what a database really is.
Selected Sources:
https://sci-hub.se/10.1109/MAHC.2009.110 - A history of IDS
https://archive.org/details/TNM_Integrated_Data_Store_introduction_-_General__20171014_0141 - Learn IDS for yourself!
https://archive.org/details/bitsavers_ibm360imsRGuide1969_8480205/page/n6/mode/2up - Educational guide to IBM's IMS
So far I've strayed away from hypermedia in my larger hypertext coverage. This episode helps to fix that. Today we are looking at Aspen Movie Map, a project from 1978 that created a virtual Aspen, Colorado. Why would you want to digitize an entire city? Why did DARPA fund a trip to Aspen? And how does this link up with hypermedia? All this and more will be answered.
Robots have always fascinated and horrified humanity in equal measure. The prospect of a synthetic lifeform is at times exciting, but can quickly turn south. Luckily we've never gotten that far... or have we? This episode we will look at a selection of early robots, from the Mechanical Turk to Elektro. All have one thing in common: they run off smoke and mirrors. Selected Sources: Robots of Westinghouse by Scott Shaut - Best source on Elektro and his friends https://www.youtube.com/watch?v=T35A3g_GvSg - See Elektro in action https://www.google.com/books/edition/Inanimate_Reason_Or_a_Circumstantial_Acc/mvVdAAAAcAAJ?hl=en&gbpv=1 - On the Mechanical Turk
Anybody up for a fright? This episode we are looking at 3 of the earliest horror video games I can find. Over this journey we will look at different programmatic ways to instill fear, how platforms can affect the route to terror, and even dig up the mystery of the first horror game. Selected Sources: http://www.twenex.org/ - Sign up for an account and play Haunt https://www.zx-gaming.co.uk/games/monstermaze/default.htm - Escape from Rex and his maze! The Untold History of Japanese Game Developers, by John Sczepaniak
Anybody up for a fright? This episode we are looking at 3 of the earliest horror video games I can find. Over this journey we will look at different programmatic ways to instill fear, how platforms can affect the route to terror, and even dig up the mystery of the first horror game. Selected Sources: http://www.twenex.org/ - Sign up for an account and play Haunt https://www.zx-gaming.co.uk/games/monstermaze/default.htm - Escape from Rex and his maze! The Untold History of Japanese Game Developers, by John Sczepaniak
It's Spook Month 2022! To kick things off we are diving into the frustrating depth of copy protection, piracy, and the origins of commercial software. In 1969 the Great Unbundling made the software market viable for the first time. Ever since then pirates and software vendors have been locked in a battle over bits. This episode traces the early days of copy protection, and how spite played an important role. Selected Sources: https://fadden.com/apple2/cassette-protect.html - In depth analysis of Apple II copy protection https://www.princeton.edu/~rblee/ELE572Papers/Fall04Readings/CryptoProc_Best.pdf - The crypto-microprocessor https://sci-hub.se/10.1109/85.988583 - A personal recollection of the Unbundling
Whirlwind represents a fascinating story of transition. The project started in the middle of the 1940s as an analog machine. As times changed it became a digital device. By 1951 it was perhaps the fastest computer in the world, filled to the brim with new approaches to design and new technology. It may have even been host to the first video game. Selected Sources: https://apps.dtic.mil/sti/pdfs/AD0896850.pdf - Report on MIT's storage tubes https://sci-hub.se/10.1109/MAHC.1983.10081 - An interview with Jay Forrester https://ohiostate.pressbooks.pub/app/uploads/sites/45/2017/09/retro-hurst.pdf - Screenshots and info about the Bouncing Ball https://www.retrogamedeconstructionzone.com/2021/07/the-whirlwind-bouncing-ball-simulator.html - Play the Bouncing Ball Program for yourself!
Whirlwind represents a fascinating story of transition. The project started in the middle of the 1940s as an analog machine. As times changed it became a digital device. By 1951 it was perhaps the fastest computer in the world, filled to the brim with new approaches to design and new technology. It may have even been host to the first video game. Selected Sources: https://apps.dtic.mil/sti/pdfs/AD0896850.pdf - Report on MIT's storage tubes https://sci-hub.se/10.1109/MAHC.1983.10081 - An interview with Jay Forrester https://ohiostate.pressbooks.pub/app/uploads/sites/45/2017/09/retro-hurst.pdf - Screenshots and info about the Bouncing Ball https://www.retrogamedeconstructionzone.com/2021/07/the-whirlwind-bouncing-ball-simulator.html - Play the Bouncing Ball Program for yourself!
In the last half of the 70s there was one gold standard in home computing: S100. This was a standardized bus that was the heart of many computers. It allowed for the interchange of parts from different manufacturers. Best of all, the S100 bus was simple. This made for a wonderful platform for hobbyists, and helped jump start the home computer revolution. And then... it disappeared. Where did the S100 bus go, and would we have been better off if it stuck around? This episode we tackle these questions and more. Selected Sources: https://archive.org/details/IoNewsVolume1Number1/page/n5/mode/2up?view=theater - The Cromemco Story https://www.digibarn.com/stories/MITS/mholley-images/Ed_Roberts_Oct_1984_ME.pdf - An interview with Ed Roberts https://mirrors.apple2.org.za/Apple%20II%20Documentation%20Project/Books/W.%20Gayler%20-%20The%20Apple%20II%20Circuit%20Description.pdf - Circuit Description of the Apple II
In the last half of the 70s there was one gold standard in home computing: S100. This was a standardized bus that was the heart of many computers. It allowed for the interchange of parts from different manufacturers. Best of all, the S100 bus was simple. This made for a wonderful platform for hobbyists, and helped jump start the home computer revolution. And then... it disappeared. Where did the S100 bus go, and would we have been better off if it stuck around? This episode we tackle these questions and more. Selected Sources: https://archive.org/details/IoNewsVolume1Number1/page/n5/mode/2up?view=theater - The Cromemco Story https://www.digibarn.com/stories/MITS/mholley-images/Ed_Roberts_Oct_1984_ME.pdf - An interview with Ed Roberts https://mirrors.apple2.org.za/Apple%20II%20Documentation%20Project/Books/W.%20Gayler%20-%20The%20Apple%20II%20Circuit%20Description.pdf - Circuit Description of the Apple II
What language has two stacks? What language is used on satellites and in home computers? What language deals in words? Why, Forth, of course! Forth is a highly unique language developed in the 60s by Chuck Moore. And when I say unique, I mean unique. Forth uses reverse polish notation for all operations, along with a dedicated data stack for passing parameters. But it's not just unique for the fun of it, Forth's design is highly deliberate. It offers a level of simplicity and power that's rarely seen in programming languages. Selected Sources: http://www.forth.org/POL.pdf - Moore's Programming a Problem Oriented Language https://www.1strecon.org/downloads/Forth_Resources/CM_ForthLanguageInteractiveComputing_1970.pdf - Early paper discussing Forth https://archive.org/details/1985-10-dr-dobbs-journal/page/41/mode/1up - Dobb's Journal article on the NX4000
Digital animation has really become an artform in and of itself. In the current epoch these animations play out on fancy bitmapped displays, but it's origins are far more visceral. Or maybe we should say far more hacky. This episode we are diving in to BEFLIX: an early animation toolchain from Bell Labs that produced computer films on physical rolls of film.
Selected Sources:
https://dl.acm.org/doi/10.1145/363958.363993 - Paper on Zajac animation
https://jimboulton.medium.com/studies-in-perception-a-restoration-story-241cd8c75ab1 - Recreation of Studies in Perception I
https://dl.acm.org/doi/10.1145/1464122.1464130 - BEFLIX Paper
https://techchannel.att.com/playvideo/2012/09/10/AT&T-Archives-Computer-Technique-Production-Animated-Movies - BEFLIX animation about BEFLIX
Can a computer be creative? Can we program a machine to make art? It turns out the answer is yes, and it doesn't even take artificial intelligence. This episode we are diving in to the ILLIAC Suite, a piece for string quartet that was composed by a computer. Along the way we will examine the Markov Chain Monte Carlo method, and how methods used to create the hydrogen bomb were adapted to create music. Selected Sources: https://archive.org/details/experimentalmusi0000hill/page/n5/mode/1up - Experimental Music https://web.archive.org/web/20171107072033/http://www.computing-conference.ugent.be/file/12 - Algoryhythmic Listening(page 40) https://www.youtube.com/playlist?list=PLEb-H1Xb9XcIyrrN5qauFr2KAolSbPi0c - The ILLIAC Suite, in 4 parts
What is a computer? A miserable pile of electrons!
But... not necessarily. I have yet to find a fully satisfying definition for "computer" that encompasses the full grandeur of calculating machines. This episode we are further complicating that quest by adding fluid based computers to the mix. We will be looking at 3 machines that crunched numbers using nothing but fluids and tubes. There's actually a rich tradition of fluidics to talk about.
Selected sources:
https://archive.org/details/electronicbrains0000hall/page/186/mode/2up - Electronic Brains chapter on MONIAC
https://archive.org/details/ACFELANALYTICALSTUDIESOFFREEZINGANDTHAWINGSOILS1953/LUKYANOV%20-%20Hydraulic%20Apparatus%20for%20Engineering%20Computations%20%281955%29/ - Translated paper on the water integrator
https://www.gwern.net/docs/cs/computable/1964-gluskin.pdf - FLODAC!
More Visi-fun ahead! Today we are looking at Visi On, a visionary user interface developed for home computers. Along the way we will discuss smalltalk, portability, and how the slick graphics over at Xerox were adapted to run on smaller machines. Selected Sources: http://toastytech.com/guis/vision.html - Toasty Tech's Visi On page, with screenshots and downloads for emulation https://archive.org/details/byte-magazine-1983-06/page/n255/mode/2up - A Guided Tour of Visi On https://archive.org/details/RosettaSmalltalkACM1979/mode/1up - Rosetta Smalltalk
Today we are looking at VisiCalc, the original killer app. Hitting the market in 1979, VisiCalc was the first computer spreadsheet program. Through it's 6 year lifespan it was ported to everything from the Apple II to the IBM PC to the Apple III. It dominated the market and then... it disappeared. Selected Sources: https://conservancy.umn.edu/handle/11299/113026 - Oral History with Bricklin and Frankston http://www.bricklin.com/history/intro.htm - Bricklin's personal website https://sci-hub.se/10.1109/MAHC.2007.4338439 - The creation and demise of VisiCalc
The Standards Eastern Automatic Computer was built by the National Bureau of Standards in 1948. It started crunching numbers in 1950 and stayed in constant operation until... 1964! This early machine, festooned with vacuum tubes, lived well past the first transistorized computers. So what exactly is SEAC doing so far into the semiconductor future?
Selected Sources:
https://archive.org/details/circularofbureau551unse/page/n7/mode/2up - Circular 551
https://sci-hub.se/10.1109/85.238389 - EDVAC Draft Report
https://sci-hub.se/10.1145/1457720.1457763 - Imaging with SEAC
In this episode I talk with Aaron Reed, author of 50 Years of Text Games. We discuss the history of computer games, interactive fiction, business "gaming", and why we all love Adventure.
You can find Aaron's work here:
http://aaronareed.net/
Multitasking: we all do it. For a feature of modern computing multitasking has surprisingly old roots. It started out as timesharing on vacuum tube based machines, reached ubiquity on large computers, then hit a wall: the microcomputer. Multitasking didn't smoothly transition over as soon as home computers hit the scene. It took some time, and it took some adaptation. Today we are looking at what made timesharing work, early changes to microprocessors that paved the way for multitasking, and one of the first operating systems to support timesharing in the home. Selected Sources: https://www.roug.org/soren/6809/os9sysprog.html - OS-9 System Programmer's Manual https://archive.org/details/byte-magazine-1979-01/page/n15/mode/2up - Article on the development of the 6809 https://sci-hub.se/10.1109/TEC.1962.5219356 - The One-Level Storage System
There's power in music, but not all tones are created equal. During the reign of Bell Telephone there was one tone in particular that opened up a world of possibilities: 2600 Hz. The devotees of this note were called phreakers, and in some cases they knew the telephone system better than Bell employees themselves. This episode were diving in to the early history of phreaking, how a bag of tricks was developed, and why exploring the phone grid was so much fun. Selected sources: http://explodingthephone.com/ - Phil Lapsley's book and website of the same name https://archive.org/details/belltelephonemag09amerrich/page/205/mode/2up - All about the Holmes Burglar Alarm system http://explodingthephone.com/docs/dbx0947.pdf - FBI's records on Barclay and the Blue Box
When people talk about early computers Babbage's Analytical Engine is bound to come up. Designed back in the 1830's it's definitely older than any other example of the art. But it also has a lot of strikes against it. The machine was purely mechanical. It only really did math. It stored numbers in decimal instead of binary. Worst of all, it only ever existed as designs on paper. So should we call this beast a computer? Or is it something else entirely? Selected Sources: https://www.fourmilab.ch/babbage/sketch.html - Sketch of the Analytical Engine, and Lovelace's Notes https://web.archive.org/web/20210226094829/http://athena.union.edu/~hemmendd/Courses/cs80/an-engine.pdf - Bromleys low level description of the engine https://sci-hub.se/10.1007/978-3-642-61812-3_2 - On the Mathematical Powers of the Calculating Engine, by Charles Babbage https://archive.org/details/bub_gb_Oi3IhTZyVCAC/mode/1up - The Ninth Bridgewater Treatise, Babbage
We're getting back to my hypertext series with a big of an obscure tale. ZOG is a hypertext system what was first developed in 1972 at Carnegie-Melon University. It then stagnated until the latter half of the 1970s when it was picked back up. By 1983 it was cruising on a US Navy aircraft carrier. ZOG presents a hypertext system with some very modern notions. But here's the part that gets me excited: ZOG was developed after Doug Engelbart's Mother of All Demos. So, in theory, ZOG should take ques from this seminal event. Right? ... right? Selected sources: https://www.campwoodsw.com/mentorwizard/PROMISHistory.pdf - History of PROMIS https://apps.dtic.mil/sti/pdfs/ADA049512.pdf - 1977 ZOG Report https://apps.dtic.mil/docs/citations/ADA158084 - 1984 USS Carl Vinson Report
Programming doesn't have to be a very serious discipline. In fact, sometimes it's better if it's a little silly. Today we are talking about INTERCAL, the first esoteric programming language. Is it a joke? Is it a form of hacker folk art? Is it even a good language? To answer those questions we need to asses what makes a programming language "good" in the first place. Program INTERCAL online today! (https://www.tutorialspoint.com/compile_intercal_online.php) Selected Sources: https://archive.org/details/intercal-ref/mode/1up?view=theater - 1973 INTERCAL Manual https://esoteric.codes/blog/don-woods - Interview with Don Woods https://sci-hub.se/10.1145/800197.806048 - 1965 TRAC paper
It's no secret, I'm a big fan of memory. Not only is memory crucial for the functioning of a computer, it's also plain weird. This episode we are looking at magnetic core memory; a technology that defined computing for more than two decades. We'll be talking about how it works, the impacts of ferrite, and the surprising controversy surrounding it's creation. Selected Sources: https://archive.org/details/bitsavers_datamation_31792007/page/n161/mode/2up - Datamation coverage of the patent disputes http://johngustafson.net/pubs/pub57/ABCPaper.htm - Recreation of ABC https://amhistory.si.edu/archives/AC0196_wang701029.pdf - Wang Oral History http://www.columbia.edu/cu/computinghistory/core.html - Diagrams and photos of magnetic cores
This episode we blast off at warp speed! We're looking at Star Trek, a game written in BASIC in 1971. Examining this game gives us some insight into the early spread of BASIC. Along the way we will see the issue with paper, why strings matter, and how software was distributed before the Internet. Selected Sources: https://web.archive.org/web/20181106092235/https://gamesoffame.wordpress.com/star-trek/ - Games of Fame article with a few interviews https://www.atariarchives.org/bcc1/showpage.php?page=275 - Super Star Trek! https://archive.org/details/d64_Star_Trek_1983_Jeff_Lewis - c64 version of Trek, good middle ground between the original and more fully featured versions
Cybernetics is broadly defined as the study of control and communications, with a special emphasis on feedback-based systems. Put another way: cybernetics is the study of the flow of data. Predating computer science by decades, cybernetics offers up an interesting view of computing. But of course, there's a lot more to the picture than just computers. This episode we are looking at Project Cybersyn, an attempt to automate Chile's economy via cybernetics. To talk about this specific case we are going to dive deep into the history of cybernetics itself. Selected Sources: https://sci-hub.se/10.1086/286788 - Behavior, Purpose, and Teleology https://sci-hub.se/10.1057/jors.1984.2 - The Viable System Model, by Beer https://web.archive.org/web/20181222110043/http://ada.evergreen.edu/~arunc/texts/cybernetics/Platform/platform.pdf - Beer on Cybersyn https://web.archive.org/web/20200619033457/https://homes.luddy.indiana.edu/edenm/EdenMedinaJLASAugust2006.pdf - Designing Freedom, Regulating a Nation, by Eden Medina
This is the conclusion to my exploration of why LISP is the "mother tongue of artificial intelligence". We pick up from the end of last episode and continue to cover the early days of AI. We follow the meandering path from the FORTRAN List Processing Language and IPL, up to pen-and-paper versions of LISP and into the first true implementation of the language. Along the way we will see just why LISP is called elegant, and how it was tailored for thinking machines. Selected Sources: https://sci-hub.se/10.1145/321021.321022 - FLPL http://www-formal.stanford.edu/jmc/mcc59.pdf - Machines with Common Sense https://dspace.mit.edu/bitstream/handle/1721.1/6096/AIM-008.pdf - AI Memo 8
I'll let you in on a secret: I've never understood why LISP is so closely associated with artificial intelligence. I've decided to fix this. In this episode, and the next, I'm tracing the early roots of AI and why list processing is important in the field. This episode we dive into the Information Processing Language, a strange programming language that predates LISP . Along the way we discuss the origin of linked lists, chess playing machines, and a program that could solve logic proofs. Selected Sources: http://bitsavers.org/pdf/rand/ipl/P-620_The_Chess_Machine_Dec54.pdf - The Chess Machine https://www.rand.org/content/dam/rand/pubs/papers/2008/P1929.pdf - IPL V introduction http://shelf1.library.cmu.edu/IMLS/MindModels/logictheorymachine.pdf - Logic Theorist
Viatron's System 21 was the computer of the 1970s! ...At least that's what their marketing claimed. Started in 1967 Viatron was set to be one of the most exciting companies of the coming decade. They were offering a desktop sized computing machine, the System 21, that promised to break IBM's domination of the office. The System 21's heart, the so-called "micro-processor", was slated to be built from cutting edge LSI chips. It could automate data processing, replace bulky IBM hardware, and do away with the punch card. And this marvel could be yours for just $39 a month. Sounds like a good deal, right? Maybe too good. According to some Viatron was strait up stock fraud. Selected sources: http://bitsavers.trailing-edge.com/pdf/viatron/ViatronSystem21Brochure.pdf - 1969 Viatron Brochure http://vintagecomputer.ca/viatron-system-21-model-2111-restoration/ - The beast itself https://archive.org/details/CIA-RDP80-01794R000100200043-2/mode/2up - CIA review of System 21
No matter how you cut it the MOS Technology 6502 is an important chip. The chip was cheap, simple, and plentiful. This made it perfect for the home computing boom of the late 1970s. But how was this classic created? Today we are looking at Motorola's earliest attempts to seize the microprocessor market, how economic factors impact history, and how trends and forces can conspire to create better technology. Selected sources: https://archive.computerhistory.org/resources/access/text/2015/06/102702020-05-01-acc.pdf - 6800 Oral History Panel https://archive.computerhistory.org/resources/access/text/2014/08/102739939-05-01-acc.pdf - Check Peddle Oral History
NLS, or the oN-Line System, is often looked at as a mile marker in the development of modern computing. It was the first system to use a mouse, one of the first functional examples of hypertext, pioneered remote collaboration, and so much more. But how much do you know about NLS itself? In this series of episode I'm picking apart the system behind the legend. In Part 2 we are looking at the development of NLS itself. Along the way we talk timesharing, strange custom hardware, and complex programming practices. Does NLS live up to the hype? You'll have to listen to find out. Selected Sources: https://dougengelbart.org/content/view/374/ - Go watch the Mother of All Demos https://www.dougengelbart.org/content/view/140/ - 1968 NLS progress report http://web.archive.org/web/20160210002938/https://web.stanford.edu/dept/SUL/library/extra4/sloan/mousesite/EngelbartPapers/B2_F5_ARNAS1.html - 1966 progress report
NLS, or the oN-Line System, is often looked at as a mile marker in the development of modern computing. It was the first system to use a mouse, one of the first functional examples of hypertext, pioneered remote collaboration, and so much more. But how much do you know about NLS itself? In this series of episode I'm picking apart the system behind the legend. Part 1 deals primarily with the early roots of NLS, Augmenting Human Intellect, and Doug Engelbart's vision of hypertext. Surprisingly, a lot of this episode has to do with punch cards and a more obscure related technology: the edge notched card. Selected Sources: https://dougengelbart.org/content/view/138 - Augmenting Human Intellect https://americanhistory.si.edu/comphist/englebar.htm - Engelbart Oral History, with the Smithsonian
Make sure you have some extra batteries for your lamp, this episode we are delving into the depths of Zork. Written in 1977 Zork would quickly become the epitome of text based adventures, pushing aside all competitors. A lot of this comes down to it's simple gameplay, and the simple fact that Zork is fun to play. But lurking deeper into the game is a hidden treasure. Ya see, the other huge part of Zork's success was it's portability. That was made possible thanks to some sick programming tricks, and a virtual computer called the Z-machine. Selected Sources: https://sci-hub.se/10.1109/MC.1979.1658697 - Early article from IEEE https://web.archive.org/web/20060427000213/http://www.csd.uwo.ca/Infocom/Articles/NZT/zorkhist.html - Tim Anderson's Zork history https://archive.org/details/a2woz_Zork_I_1981_Infocom_r75 - Go play Zork
This episode I face my greatest fears: computer bugs. We are going to dive into the origin of the term, and examine the origins of debugging. The simple fact is that as soon as computers hit the scene we start finding bugs. Debugging follows very soon after. That part's not too surprising, it's the specifics that get interesting. Modern debugging methods we still use today were first developed on ENIAC, a machine that's anything but modern.
It's Spook Month on Advent of Computing! Every October we cover the more spooky, scary, and frustrating side of computers. To kick off this year we are looking at viruses again, this time with a special eye to the first infections for IBM PCs and compatible systems. Besides the technical changes, this drops us into an interesting transitionary period. Up to this point viruses had been something of an in-joke amongst hackers and computer nerds, but with the creation of viruses like Brain and VirDem we see them start to enter public awareness. Selected Sources: https://dl.acm.org/doi/pdf/10.1145/358198.358210 - Reflections on Trusting Trust http://web.archive.org/web/20060427081139/http://www.brain.net.pk/aboutus.htm - Brain Computing on Brain Virus https://archive.org/details/computervirusesh0000burg - Computer Viruses: A High-Tech Disease
In today's episode we take a long hard look at the telegraph, and try to see how character encoding developed. We are dealing with 100% pre-computing technology, but there are some shocking similarities to later digital systems. Selected Sources: https://archive.org/details/electrictelegrap00highrich/page/2/mode/2up - Early history of the electric telegraph http://www.samhallas.co.uk/repository/telegraph/b6_baudot_multiplex.pdf - 1934 pamphlet on the Baudot telegraph https://ia800708.us.archive.org/view_archive.php?archive=/22/items/crossref-pre-1909-scholarly-works/10.1049%252Fjiee-1.1901.0058.zip&file=10.1049%252Fjiee-1.1905.0034.pdf - Murray's comprehensive article on telegraphy
Today we are talking about computers in space! 1964 saw the launch of Gemini I, the first spacecraft to carry an onboard computer. The aptly named Gemini Guidance Computer was responsible for guidance, navigation, and safe reentry. Built by IBM it weighed in at a tiny 59 pounds. For 1960's technology there just isn't any comparison to make, it was an amazingly small machine. What secrets does it hold? Did IBM crack some secret code to build such a tiny computer?
https://www.ibiblio.org/apollo/Gemini.html - Overview of the Gemini Guidance Computer
https://history.nasa.gov/computers/ch1-1.html - Official NASA History
https://www.ibiblio.org/apollo/Documents/GeminiProgrammingManual.pdf - How the thing was programmed
This concludes my series on the distinctive shape of early home computers. In this episode we finally cover the Sol-20 itself, the first system on the market to be shaped like a wedge. More generally, we try to figure out if the Sol-20 was the progenitor of hundreds of machines that followed, or if the wedge was inevitable. For such a simple question, this has become a surprisingly complicated topic. Selected sources: http://archive.computerhistory.org/resources/access/text/2012/10/102702231-05-01-acc.pdf - Lee Felsenstein, oral history at CHM http://www.leefelsenstein.com/wp-content/uploads/2013/01/I_Designed_the_Sol.pdf - Article about the Sol-20's design process http://www.leefelsenstein.com/wp-content/uploads/2013/02/Felsenstein-Tabloid-BW.pdf - Tom Swift Lives! Like the show? Then why not head over and support me on Patreon. Perks include early access to future episodes, and bonus content: https://www.patreon.com/adventofcomputing
Early home microcomputers have a very distinctive shape to them. From the Apple II and the ZX Spectrum, to the Commodore 64 and the Amiga, wedged were the order of the day. I've always wondered why that shape became so popular, and where it came from. Today we start a deep dive into that question, slowly tracing the origins of the first wedge shaped computer. Selected Sources: http://www.leefelsenstein.com/wp-content/uploads/2013/01/TST_scan_150.pdf The Tom Swift Terminal, or a Convivial Cybernetic Device https://archive.org/details/levy-s-hackers-heroes-computer-revolution "Hackers", by Levy http://www.s100computers.com/Hardware%20Manuals/Processor%20Technology/VDM-1%20Manual.pdf VDM-1 manual
Hypertext has really become a core offering of daily life, and defined the face of the Internet for decades. But the links and formatting we know so well only make up part of the story. Today we are looking at FRESS(the File Retrieval and Editing SyStem), a hypertext system developed at Brown University at the tail end of the 60s. What makes FRESS so crucial in the history of hypertext is that it was extensively studied. Multiple experiments were carried out to test if FRESS, and hypertext in general, had a place in classrooms. Some useful sources from this episode: https://sci-hub.do/10.1162%2F109966299751940814 1999 paper on FRESS and hypertext in general by Andres van Dam https://archive.org/details/VanDamFinalReport1976 Final experimental report https://archive.org/details/AndyVanDamHypertextFilm Short film on the FRESS experiment
It's here! My celebratory question and answer episode! Contains ramblings on my checkered past, why computer history is important, and why FOIA is so cool.
COBOL! Just its name can strike terror in the hearts of programmers. This language is old, it follows its own strange syntax, and somehow still runs the world of finance and government. But is COBOL really as bad as it's made out to be? Today we are talking a look at the languages origins and how it's become isolated from early every other programming language in common use. Perhaps most importantly for me, we will see is Grace Hopper should really be blamed for unleashing this beast onto mainframes.
Selected Sources:
https://archive.org/details/historyofprogram0000hist - History of Programming Languages, contains Sammet's account of CODASYL
https://archive.org/details/bitsavers_codasylCOB_6843924/ - COBOL 60 Manual
https://sci-hub.do/10.1016/0066-4138%2860%2990042-2 - FLOW-MATIC/MATH-MATIC usage paper
ALOHANET was a wireless networking project started at the University of Hawaii in 1968. Initially, it had relatively little to do with ARPANET. But that relative isolation didn't last for long. As the two networks matured and connected together we start to see the first vision of a modern Internet. That alone is interesting, but what brings this story to the next level is the protocol developed for ALOHANET. Ya see, in this wireless network data delivery wasn't guaranteed. Everyone user shared a single radio channel, and terminals could talk over each other. So how did ALOHANET even function?
Selected sources used in this episode:
https://archive.org/details/DTIC_AD0707853 - The initial 1970 ALOHANET report
https://archive.org/details/jresv86n6p591_A1b/page/n3/mode/2up - Summary paper by Kuo, contains a map of ALOHANET
https://sci-hub.do/10.1145/1499949.1499983 - Khan's 1973 PRNET paperhttps://www.eng.hawaii.edu/wp-content/uploads/2020/06/abramson1985-Development-of-the-ALOHANET.pdf - 1985 wrap-up of ALOHANET, by Abramson
Like the show? Then why not head over and support me on Patreon. Perks include early access to future episodes, and bonus content: https://www.patreon.com/adventofcomputing
This episode we take a look at the earliest days of computing, and one of the earliest forms of computer memory. Mercury delay lines, originally developed in the early 40s for use in radar, are perhaps one of the strangest technologies I've even encountered. Made primarily from liquid mercury and quartz crystals these devices store digital data as a recirculating acoustic wave. They can only be sequentially accessed. Operations are temperature dependent. And, well, the can also be dangerous to human health. So how did mercury find it's way into some of the first computers?
Like the show? Then why not head over and support me on Patreon. Perks include early access to future episodes, and bonus content: https://www.patreon.com/adventofcomputing
Where did educational games come from? According to some, the practice of using games in classrooms started in the early 60s with the appearance of the Sumerian Game. However, the story is more complicated than that. This episode we dive into the Sumerian Game, some of the earliest educational games, and the bizarre legacy of a lost piece of software.
Like the show? Then why not head over and support me on Patreon. Perks include early access to future episodes, and bonus content: https://www.patreon.com/adventofcomputing
The TI TMS9900 is a fascinating microprocessor. It was the first 16-bit microprocessor on the market, it has a unique architecture that makes it well suited to multitasking, and it was on IBM's shortlist to power the PC. Today we are looking at this strange chip, and the TI minicomputers that predated it's design. Along the way we will construct a theoretical TI-powered PC, and see how home computing could have changed if IBM took a slightly different path.
Like the show? Then why not head over and support me on Patreon. Perks include early access to future episodes, and bonus content: https://www.patreon.com/adventofcomputing
Project Xanadu, started in 1960, is perhaps the oldest hypertext system. It's creator, Ted Nelson, coined the term hypertext just to describe Xanadu. But it's not just a tool for linking data. Nelson's vision of hypertext is a lot more complicated than what we see in the modern world wide web. In his view, hypertext is a means to reshape the human experience. Today we are starting a dive into the strange connection between hypertext, networking, and digital utopianism.
Like the show? Then why not head over and support me on Patreon. Perks include early access to future episodes, and bonus content: https://www.patreon.com/adventofcomputing
Even after nearly 50 years C remains a force in the programming world. Anytime you brows the web, or even log into a computer, C is somewhere in the background. This episode I wrap up my series on C by looking at it's early development and spread. We will get into the 1st and 2nd C compilers ever written, and take a look at how a banned book lead to generations of avid C programmers.
Like the show? Then why not head over and support me on Patreon. Perks include early access to future episodes, and bonus content: https://www.patreon.com/adventofcomputing
C is easily one of the most influential programming languages in the world, and it's also one of the most popular languages in the world. Even after close to 50 years it remains in widespread and sustained use. In this series we are going to look at how C was developed, how it spread, and why it remains so relevant. To do that we need to start with background, and look at what exactly influenced C. This episode we are diving into some more ALGOL, CPL, BCPL, and eventually B.
Like the show? Then why not head over and support me on Patreon. Perks include early access to future episodes, and bonus content: https://www.patreon.com/adventofcomputing
One of the great things about the modern Internet is the wide range of services and content available on it. You have news, email, games, even podcasts. And in each category you have a wide range of choices. This wide diversity makes the Internet so compelling and fun to explore. But what happens when you take away that freedom of choice? What would a network look like if there was only one news site, or one place to get eamil? Look no further than THE SOURCE. Formed in 1979 and marketed as the information utility for the information age, THE SOURCE looked remarkably like the Internet in a more closed-off format. The key word here is: looked.
Like the show? Then why not head over and support me on Patreon. Perks include early access to future episodes, and bonus content: https://www.patreon.com/adventofcomputing
Released in August 1981, the IBM PC is perhaps one of the most important computers in history. It originated the basic architecture computers still use today, it flung the doors open to a thriving clone market, and created an ad-hoc set of standards. The heart of the operation, Intel's 8088, solidified the x86 architecture as the computing platform of the future. IBM accomplished this runaway success by breaking all their own rules, heavily leveraging 3rd party hardware and software, and by cutting as many corners as possible. The PC was designed in less than a year, so how did it become the most enduring design in the industry? Some ad clips this episode were from this fabulous PC ad compilation: https://www.youtube.com/watch?v=kQT_YCBb9ao Like the show? Then why not head over and support me on Patreon. Perks include early access to future episodes, and bonus content: https://www.patreon.com/adventofcomputing
The Intel 8086 may be the most important processor ever made. It's descendants are central to modern computing, while retaining an absurd level of backwards compatibility. For such an important chip it had an unexpected beginning. The 8086 was meant as a stopgap measure while Intel worked on bigger and better projects. This episode we are looking at how Intel was trying to modernize, how the 8086 fit into that larger plan, and it's pre-IBM life.
Like the show? Then why not head over and support me on Patreon. Perks include early access to future episodes, and bonus content: https://www.patreon.com/adventofcomputing
Saga II was a program developed in 1960 that automatically wrote screenplays for TV westerns. Outwardly it looks like artificial intelligence, but that's not entirely accurate. Saga has much more in common with CNC software than AI. This episode we take a look at how the same technology that automated manufacturing found it's way into digital westerns, and how numerically controlled mills are remarkably similar to stage plays.
Clips drawn from The Thinking Machine: https://techtv.mit.edu/videos/10268-the-thinking-machine-1961---mit-centennial-film
Like the show? Then why not head over and support me on Patreon. Perks include early access to future episodes, and bonus content: https://www.patreon.com/adventofcomputing
Sometimes an idea is so good it keeps showing up. Electronic ping-pong games are one of those ideas. The game was independently invented at least twice, in 1958 and then in 1966. But, here's the thing, PONG didn't come around until the 70s. What were theses earlier tennis games? Did Atari steel the idea for their first hit? Today we go on an analog journey to find some answers.
Like the show? Then why not head over and support me on Patreon. Perks include early access to future episodes, and bonus content: https://www.patreon.com/adventofcomputing
Lars Brinkhoff has been spearheading the effort to keep the incompatible Timesharing System alive. Today we sit down to talk about the overall ITS restoration project, software preservation, and how emulation can help save the past.
You can find the full restoration project at github: https://github.com/PDP-10/its
And follow Lars on twitter: @larsbrinkhoff
Modern operating systems adhere to a pretty rigid formula. They all have users with password-protected accounts and secure files. They all have restrictions to keep programs from breaking stuff. That design has been common for a long time, but that doesn't make it the best solution. In the late 60s ITS, the Incompatible Timesharing System, was developed as a more exciting alternative. ITS was built for hackers to play, there were no passwords, any anyone who could find ITS was welcome to log in.
Like the show? Then why not head over and support me on Patreon. Perks include early access to future episodes, and bonus content: https://www.patreon.com/adventofcomputing
Hacker hasn't always been used to describe dangerous computer experts will ill intent. More accurately it should be sued to describe those enamored with computers, programming, and trying to push machines to do interesting things. The values, ethics, morals, and practices around those people make up what's known as hacker culture. Today we are digging into the Jargon File, a compendium of all things hackish and hackable, to take a look at hacker culture through its folklore. Huge thanks to some of my fellow podcasters for doing readings for me this episode. In order of appearance they are: Randall Kindig of the FloppyDays Vintage Computing Podcast(floppydays.com) Charles Edge from The History of Computing(thehistoryofcomputing.libsyn.com) Sebastian Major of Our Fake History(ourfakehistory.com) Like the show? Then why not head over and support me on Patreon. Perks include early access to future episodes, and bonus content: https://www.patreon.com/adventofcomputing
BASIC is a strange language. During the early days of home computing it was everywhere you looked, pretty much every microcomputer in the 70s and early 80s ran BASIC. For a time it filled a niche almost perfectly, it was a useable language that anyone could learn. That didn't happen by accident. Today we are looking at the development of BASIC, how two mathematicians started a quest to expose more students to computers, and how their creation got away from them.
In 1946 John Eckert and John Mauchly left the Moore School, patented ENIAC, and founded a company. One of those discussions would have consequences that wouldn't be resolved until 1973. Today we close out our series on ENIAC with a look at the legal battle it spawned, and how it put ownership over the rights to basic digital technology on trial. Along the way we talk legal gobbledygook, conspiracy, and take a look at some of the earliest electronic computers.
Like the show? Then why not head over and support me on Patreon. Perks include early access to future episodes, and bonus content: https://www.patreon.com/adventofcomputing
Completed in 1945, ENIAC was one of the first electronic digital computers. The machine was archaic, but highly influential. But it wasn't a totally new take on computing. Today we are taking a look at the slow birth of ENIAC, how analog computers started to fall apart, and how earlier ideas transitioned into the digital future.
Like the show? Then why not head over and support me on Patreon. Perks include early access to future episodes, and bonus content: https://www.patreon.com/adventofcomputing
This episode is not about the IBM PC. In 1981 the Personal Computer would change the world. Really, it's hard to talk about home computing without diving into it. But I've always had an issue with the traditional story. The PC didn't come out of left field, IBM had actually been trying to make a home computer for years. In 1981 those efforts would pay off, but the PC wasn't revolutionary hardware for Big Blue, it was evolutionary. So today we are looking at that run up with SCAMP, the 5100, and the Datamaster.
Like the show? Then why not head over and support me on Patreon. Perks include early access to future episodes, and bonus content: https://www.patreon.com/adventofcomputing
It's time to round out spook month with a return to one of last year's topics: the computer virus. Malicious code traveling over networks is actually a relatively new phenomenon, early viruses were much different. In this episode we examine ANIMAL and Elk Cloner, two early viruses that were meant as practical jokes and spread by hapless computer users. Along the way we will see cases of parallel evolution, name calling, and find out if there is any one origin to the word "virus".
Like the show? Then why not head over and support me on Patreon. Perks include early access to future episodes, and bonus content: https://www.patreon.com/adventofcomputing
Spam emails are a fact of modern life. Who hasn't been sent annoying and sometimes cryptic messages from unidentified addresses? To understand where spam comes from we need to look at the origins of email itself. Email has had a long and strange history, so too have some of it's most dubious uses.
Like the show? Then why not head over and support me on Patreon. Perks include early access to future episodes, and stickers: https://www.patreon.com/adventofcomputing
We've all played the Oregon Trail, but what do you know about it's origins? First developed as a mainframe program all the way back in 1971, the Oregon Trail was intended as an educational game first and foremost. In fact, it traces its linage to some of the first efforts to get computers into the classroom. Today we are following the trail back to it's source and seeing how the proper environment was built to create this classic game.
You can play the 1975 version here: https://archive.org/details/OregonTrailMainframe
Like the show? Then why not head over and support me on Patreon. Perks include early access to future episodes, and stickers: https://www.patreon.com/adventofcomputing
The creation of FORTRAN and early compilers set the stage to change computing forever. However, they were just the start of a much longer process. Just like a spoken language, programming languages have morphed and changed over time. Today we are looking at an interesting case of this slow evolution. JOVIAL was developed during the Cold War for use in the US Military, and it's been in constant small-scale use ever since. It's story gives us a wonderful insight into how programming language change over time, and why some stick around while others die out.
Like the show? Then why not head over and support me on Patreon. Perks include early access to future episodes, and stickers: https://www.patreon.com/adventofcomputing
Is there a more iconic duo than the IBM PC and MS-DOS? Microsoft's Disk Operating System would be the final success that turned the company into what we know today. But here's a dirty little secret: DOS didn't start out at Microsoft. So how did Gates and Allen get hold of a winning program? Today we look at how Tim Paterson, an engineer at a long forgotten company, created the first x86 computer and the original version of DOS.
Important dates:
1979 - Tim Paterson builds first 8086 Computer
1980 - Microsoft licenses DOS from Seattle Computer Products
1981 - DOS ships with the IBM PC
Like the show? Then why not head over and support me on Patreon. Perks include early access to future episodes, and stickers: https://www.patreon.com/adventofcomputing
The IBM PC and MS-DOS, the iconic duo of the early 80s. The two are so interconnected that it's hard to mention one without the other. But in 1980 DOS wasn't IBM's first choice for their soon-to-be flagship hardware. IBM had wanted to license Gary Kildall's CP/M, but in a strange series of events the deal fell through. Legend states that Kildall lost the contract b was too busy flying his private plane to talk business with IBM, but is that true? Today we look at the development of CP/M, why it was a big deal, and why the PC ultimately shipped with Microsoft software.
Like the show? Then why not head over and support me on Patreon. Perks include early access to future episodes, and stickers: https://www.patreon.com/adventofcomputing
A lot of the technology we associate with the modern day started on anachronistic machines. I'm not talking about mainframes, I'm talking older. Today we are looking at George Julius's Automatic Totalisator, an analog computer used to manage betting at horse tracks around the world. These were massively complex machines, some networked over 200 input terminals, and they did it all mechanically.
Like the show? Then why not head over and support me on Patreon. Perks include early access to future episodes, and stickers: https://www.patreon.com/adventofcomputing
Important Dates:
1913: Premier Tote installed in Auckland
In 1974 Intel released the 8080 processor, a chip long in the making. It was the first microprocessor that had the right combination of power and price to make personal computers viable. But that same year a small group of employees defected and formed their own company called Zilog. Among this group were Masatoshi Shima and Federico Faggin, two of the principal architects behind the 8080 as well as Intel's other processors. Zilog would go on to release a better chip, the Z80, that blew Intel out of the water. Today we continue our Intel series with a look into this twisting story.
Like the show? Then why not head over and support me on Patreon. Perks include early access to future episodes, and stickers: https://www.patreon.com/adventofcomputing
Important Dates:
1974: Intel 8080 hits shelves
1976: Zilog Z80 goes on sale
I recently got the chance to sit down and talk with Microsoft alumni Brad Chase. He was the product manager for Microsoft Works on the Macintosh, DOS 5, DOS 6, and the marketing lead for Windows 95 as well as much more. We talk about the Apple-Microsoft relationship, the groundbreaking launch of Windows 95, and what it takes to sell software.
Editing for this episode was handled by Franck, you can follow him on instagram: www.instagram.com/frc.audio/
Like the show? Then why not head over and support me on Patreon. Perks include early access to future episodes, and stickers: https://www.patreon.com/adventofcomputing
In 1972 Alan Kay published a paper called "A Personal Computer for Children of All Ages". In it's pages Kay offers the first description of a portable computer, what he calls the DynaBook. What makes this document so remarkable is that the computer it describes is shockingly modern. Despite being nearly 50 years old the DynaBook is depicted as essentially a tablet computer. What's more, Kay envisioned DynaBook as a user friendly computer that could be used by anyone, from children up to computer experts.
The most widely circulated sketch of the DynaBook shows it as a flat slate 12" x 9" slate with a screen and keyboard on its surface. I/O ports, some type of removable storage, and a holder for a stylus would be built into the sides of the computer's case. But Kay is quick to point out that the computer need not be bound to that specific design, rather the sketch was given as one possible form factor for the DynaBook. In Kay's view a personal computer had to be portable and easy to use, the keyboard-and-screen design was just one way to accomplish that goal.
"Once one has gotten used to the idea of no moving parts, he is ready for the idea of no keyboard at all! Suppose the display panel covers the full extent of the notebook surface. Any keyboard arrangement one might wish can then be displayed anywhere on the surface.
…
The bottom portion of the display panel can be textured in various ways to permit touch typing. This arrangement allows the font in which one is typing to be shown on the keys, special characters can be windowed, and user identifiers can be selected with one touch."
~Alan Kay, A Personal Computer for Children of All Ages
So scratching just below the surface Kay does indeed describe a tablet computer almost perfectly. The idea of a textured screen definitely didn't take off, but Kay correctly foresaw that a keyboard could be removed from the equation altogether. On screen keyboards on smart phones and tablets today look a lot like what Kay describes, a keyboard is simply displayed on a portion of the screen as needed. He even identifies the flexibility of this type of system. Since the keyboard is just another image displayed on screen you aren't beholden to any one layout or look.
The futuristic hardware design is just part of what makes Kay's writing shocking. He brings things to another level by claiming that the DynaBook could be produced using 1972 technology, and that a mass produced DynaBook could be sold for under $500 dollars. Today that has become possible, cheap consumer tablets are readily available. But that was definitely not the case in 1972. Microprocessors were still in their infancy, flat panel displays weren't very much further along in their development. Kay wouldn't build a tablet in the 70s, but the idea of the DynaBook would serve as a goalpost for his future work.
A few years later, in 1976, Kay took another stab at designing a practical DynaBook. This redesign would eventually lead to the development of the Xerox NoteTaker. Kay's first drawings of what the NoteTaker could be show a more practical attempt at designing a portable computer. This later design drops the slate form factor in favor of something more akin to an actual laptop. The large touchscreen was replaced with a more modest size display, but they keyboard remained relatively unchanged. Kay also sketched the NoteTaker with a folding lid that would cover and protect the device.
While the NoteTaker did materialize the finished prototypes were vastly different from Kay's initial design. These prototypes were some of the first luggable computers, weighing in the neighborhood of 50 pounds. A far cry from the DynaBook concept, and not exactly what Kay had in mind. Ultimately we wouldn't get cheap and portable computers for years to come, but Kay's work did plant the seed of the idea.
You can read Alan Kay's "A Portable Computer for Children of All Ages" here: https://www.mprove.de/visionreality/media/kay72.html.
To learn more about the history of portable computing listen to my episode on the topic:
Website // Apple Podcasts
Portable computing is now totally ubiquitous. There's a good chance you are listening to this episode on a tiny portable computer right now. But where did it all come from? As it turns out the first portable computer was designed all the way back in 1972. This machine, the DynaBook, only ever existed on paper. Despite that handicap, in the coming years it would inspire a huge shift in both personal and portable computing.
Like the show? Then why not head over and support me on Patreon. Perks include early access to future episodes, and stickers: https://www.patreon.com/adventofcomputing
Important dates in this episode:
1972: DynaBook designed by Alan Kay
1976: NoteTaker project starts
1982: GRiD Compass released
In this episode we finish up our look at the birth of the transistor. But to do that we have to go back to 1880, the crystal radio detector, and examine the development of semiconductor devices. Once created the transistor would change not just how computers worked, but change how they could be used. That change didn't happen over night, and it would take even longer for the transistor to move from theory to reality.
Like the show? Then why not head over and support me on Patreon. Perks include early access to future episodes, and stickers: https://www.patreon.com/adventofcomputing
Important dates in this episode:
1939: Russel Ohl Discovers P-N Junction
1947: Point Contact Transistor Invented at Bell Labs
1954: TRADIC, First Transistorized Computer, Built
The development of computer technology, especially early on, is deeply tied to governmental and military research. Early computers like Colossus and the Harvard Mark Iwere a big part of the Allied war effort. The internet itself is an outgrowth of a collection of US government projects. But not all of these undertakings see the light of day. A great example of this is the not-so-subtly named Project Lightning, the NSA's attempt to create a totally new type of computer in the 1950s. And while Lightning would never lead to any public facing advances, we can see an interesting story emerge from declassified documents.
One internal report from the late 1950s summarizes Project Lightning:
"Eventually we foresee that natural limitations on speed and size will be encountered, and then the inevitable advances of our opponents will corner us, so that the duel will become one of pure wits. But while we can we must maintain our superior weapons. Project LIGHTNING was set up to preserve our advantage in speed of computation."
~Lightning, HOWARD H. CAMPAIGNE
This was in the middle of the Cold War, and the fear at the time was that the USSR would overtake the US's dominance in the field of computing. But there was an issue facing any push to advance computing, the limitations that this document cite. In this era the vacuum tube was the core component used to build computers, and while that worked it wasn't an ideal solution. These tubes ran hot, were pretty large, and didn't operate all that fast. While it would have been possible to just beef up existing computer systems you'd quickly run into diminishing returns. In order to maintain technological superiority a radical change would be needed.
The plan laid out for Project Lightning is ambitious, to say the least. In that same document the end goal was described as:
"A jet plane can go one hundred times as fast as a man can run. A computer can go ten thousand times as fast as a man can compute. LIGHTNING will go ten million times as fast."
The NSA was trying to build a supercomputer. While not exactly common, supercomputers do exist in the modern day. But in the 1950s this was unprecedented. Keep in mind that this is before the first integrated circuits, and decades before the first microprocessor. The first transistorized computer, TRADIC, was a new and untested technology. This was a strange period where the future of computing wasn't entirely clear. Project Lightning was, broadly speaking, an attempt to find the computing element of the future.
Lightning would investigate a number of contenders, but one of their early and promising leads was a device known as a cryotron. These were superconductive switches invented by Dudley Allen Buck in 1953. The first prototype cryotrons were simply a core wire wrapped in a coil of a dissimilar metal. Both metals are superconductive at low temperatures, but when a magnetic field is generated by the coil the core wire becomes resistive. The catch is that for this to work the cryotron has to be kept near absolute zero in a bath of liquid helium.
But Lightning wasn't going to be using these early cryotrons. The NSA wanted to leverage an even more futuristic technology. In the latter half of the 50s Dudley Buck was able to develop a technique for creating superconductive integrated circuits, which he called "thin film cryotrons".
"Using thin films of silicon monoxide as insulation we plate layer over layer until we have a complex assembly on a microscope slide, equivalent to a vacuum tube chassis in information-handling ability but so thin that a finger tip cannot feel its presence. This method or assembly may not only get us our 1000 megacycles, but get it for us cheap, for in mass production such techniques of assembly are much cheaper than the classical wiring and soldering"
Years before semiconductor chips existed, Buck was able to etch microscopic cryotrons on to silicon chips. A thin-film cryotron chip could switch much faster than a vacuum tube, used a scant fraction of the power, and in theory could be mass produced. The wild thing is, this was within reach. At least one prototype computer was built using thin-film cryotrons. If Project Lightning had survived we may very well have seen a massively parallel supercomputer built from superconductive circuits by the end of the 1950s.
However, Project Lightning would never reach its end goal. At least not in this iteration. The project would go on for a number of years, burning funding and resources. With the limited sources available it's hard to point to an exact failure point. It's likely that the dreams of a cryotron computer at the NSA fell by the wayside with the success of the transistor, or that Project Lightning transformed into another endeavour that has yet to see the light of day.
If you want t read more about Project Lightning, there are a number of FOIA released documents floating around. This is the one that talks the most about the cryotron side of the project.
https://www.nsa.gov/Portals/70/documents/news-features/declassified-documents/tech-journals/lightning.pdf
To learn more about the cryotron in general I'd recommend checking out "The Cryotron Files" by Douglas Buck and Iain Dey. It's been an invaluable source for me personally, and it's a good read in general.
To learn more about the early development of the vacuum tube, cryotron, and early computers listen to my episode on the topic:
Website // Apple Podcasts
The transistor changed the world. It made small, complex, and cheap computing possible. But it wasn't the first attempt to crack the case. There is a long and strange lineage of similar devices leading up to the transistor. In this episode we take a look at two of those devices. First the vacuum tube, one of the first components that made computing possible. Then the cryotron, the first device purpose built for computers.
You can find the full audio of Atanasoff's talk here: https://www.youtube.com/watch?v=Yxrcp1QSPvw
Like the show? Then why not head over and support me on Patreon. Perks include early access to future episodes, and stickers: https://www.patreon.com/adventofcomputing
Important dates in this episode:
1880: Thomas Edison Rediscovers Thermionic Emission
1904: Ambrose Fleming Invents the Vacuum Tube
1906: Lee de Forest Patents the Audion Triode Tube
1937: George Stibitz Creates First Binary Adding Circuit from Spare Relays
1938: John Atanasoff Visits a 'Honkey-Tonk'
1941: ABC, First Vacuum Tube Calculator, is Completed
1953: Cryotron Invented by Dudley Allen Buck
In the current day Linux is the most widely used UNIX-like operating system. It's rise to prominence has been an amazing success story. From it's humble beginnings Linux has grown to power everything from super computers to car stereos. But it's not the first UNIX clone. A much earlier system existed, called Coherent. And as it turns out both Linux and Coherent share a lot of similarities. The biggest difference being that Coherent was closed source.
Like the show? Then why not head over and support me on Patreon. Perks include early access to future episodes, and stickers: https://www.patreon.com/adventofcomputing
Important dates in this episode:
1973: AT&T UNIX V4 Goes Public
1949: DOJ Sues AT&T Over Antitrust Violations
1975: AT&T UNIX V6 Released
1977: First Version of BSD Circulates
1977: XYBASIC Released by Mark Williams Company
1980: Coherent Released for PDP/11
1983: Coherent Comes to the IBM PC/XT
1995: Mark Williams Company Closes
In this byte sized episode I take a look at a pack in that came with the first Macintosh. Along side Apple stickers, manuals, and the computer itself there was a single cassette tape labeled "A Guided Tour of the Macintosh". The purpose? It's a strange addition to the Mac's packing, but a great example of Apple's attention to detail and ingenuity.
Like the show? Then why not head over and support me on Patreon. Perks include early access to future episodes, and stickers: https://www.patreon.com/adventofcomputing
Important dates in this episode:
1984: A Guided Tour of the Macintosh Released
Pulse Code Modulation, or PCM, is the core technology behind digital audio. Despite being so central to modern day life PCM is actually pretty old. It was originally developed by Alec Reeves, a telecom engineer, all the way back in 1937. From there the technology has slowly gained traction and eventually found its way into computerized audio systems. Decades after its creation Reeves would write out his thoughts on the technology in an article titled "The past, present and future of PCM"(https://tkhf.adaxas.net/cd1/Reeves2.pdf). Despite being written in 1965, more than 50 ago, his predictions for the future are uncannily accurate.
Reeves uses the year 2000 as a goalpost for most of his long-term predictions. Some of these are pretty mundane: telephone usage will greatly increase, new technology will spread in emerging markets outside the US and Europe. His safest prediction is that larger and more widespread use of telephone systems will make PCM the only suitable option for ferrying audio. But Reeves would go on to describe other causes for widespread adoption of PCM:
"In my view, this “other reason” by that date will be the necessity for widespread closed-loop television — a necessity, I repeat, not just the urge for a status symbol that is likely to start this kind of demand in the nearer future."
I've struggled a bit to understand exactly what he means by "closed-loop television" here. It's clear he isn't referring to CCTVs, the direct context makes me think he means broadcast television. However, later in the paper when addressing the use of PCM in information retrieval he writes:
"The only adequate answer will be for a few information processing centers to be set up in each large industrialized area, staffed by top-grade people, with the information being made available to the public immediately and automatically when a dialed request is made. An ordinary high-speed data link may be adequate for the next 20 years, but by A.D. 2000 the only way to pass the information fast enough to the caller’s brain will be to use moving pictures."
So it could be that he is trying to describe a teleconferencing-like system. Whatever the case, Reeves is still accurate in predicting the audio side of things. Broadcast television signals switched to digital in most parts of the world during the 2000's, and the audio component of those signals is now encoded as PCM. However, I think the teleconferencing angle has a little more meat to it. In a later passage Reeves writes:
"Commuters will refuse to accept the delays and inconveniences that even a moderate journey to and from their place of work would entail...We shall have to transport the brains, the skills of the staff, not their bodies, to their daily jobs, again involving not merely ordinary data links but a great many private television channels as well."
The language is a little anachronistic, but here Reeves is speculating that video conferencing will become essential as more employees wish to work remotely. Of course today we don't conference using a TV, we use computers. But just like digital television signals, video conferencing software like Skype employs PCM for audio encoding.
To learn more about the story of PCM, listen to my episode on the topic:
Website // Apple Podcasts
Every day we are inundated with digital audio: phone calls, music, even this podcast. Digitized sound has become so ubiquitous that it often fades into the background. What makes this all possible is a technology called Pulse Code Modulation, or PCM. This isn't new technology, its roots trace all the way back to 1937. So how exactly did digital audio come into being well before the first digital computers?
Like the show? Then why not head over and support me on Patreon. Perks include early access to future episodes, and stickers: https://www.patreon.com/adventofcomputing
Important dates in this episode:
1937: PCM Developed by Alec Reeves
1941: Germany Cracks A-3 Code
1943: Bell Labs Develops SIGSALY(aka The Green Hornet)
1957: First PCM Synthesizer, MUSIC I, Programmed by Max Mathews
It's easy to think of Apple and Microsoft as bitter rivals, but that's not always the case. The two companies have a very complicated relationship, and a very long history. This connection goes all the way back to the 1970s and a product called Applesoft BASIC. It would become stock software on nearly every Apple II computer ever sold, it kept Apple competitive in the early home computer market, and it may have saved Microsoft from bankruptcy.
Like the show? Then why not head over and support me on Patreon. Perks include early access to future episodes, and stickers: https://www.patreon.com/adventofcomputing
Important dates in this episode:
1997: Bill Gates saves Apple from Bankruptcy
1976: Apple I hits shelves, Integer BASIC soon follows
1977: Apple II Released
1978: AppleSoft BASIC Ships
The Vectrex was a unique and impressive console. It differentiated itself from other home offerings of the time by using vector graphics instead of a more traditional pixelated approach. The machine could handle crude 3D graphics years before the competition, and in the modern day it's become a cult classic. But what were people saying about the Vectrex on release day? Lets take a look at how Byte described the console in a 1982 article(https://archive.org/stream/byte-magazine-1982-12/1982_12_BYTE_07-12_Game_Plan_1982#page/n93/mode/2up).
Overall, the article casts the console in a positive light. The title itself declares the Vectres "brings true arcade adventures into the home". And that headline is mostly correct. Vector games did exist, titles like Asteroids were extremely popular and rendered totally in vectors. In terms of power the Vectrex was pretty on-par with it's arcade counterparts, in some cases the Vectrex outpaced these cabinets. Asteroids, for instance, ran off of a 6502 CPU which was slower and all around less powerful than the Vectrex's 6809. By going for the smaller niche of vector based games this new console was able to accurately recreate arcade games in the home market.
The article also brings up portability as a major feature of the Vectrex. Since it didn't plug into a television you could play it anywhere with a power outlet. An integrated screen was part of the Vectrex's design due to necessity: it needed to have full control over it's CRT tube so it couldn't work with a standard TV set. But as it turned out not needing a seperate TV was a selling point. And as would be expected the screen is one of the most mentioned features in Byte:
"And the display -- well it almost has to be seen to be believed; imagine playing games at home (or in the office) using vector graphics with three-dimensional rotation and zoom."
Even in 1982 the Vectrex was surprisingly different from every other game console out there. From day one the machine was set apart from competition. Not only did it look different, it was capable of things that other consoles simply couldn't do. Rendering wire-frames in 3D that were easily rotated and scaled was unheard of outside of arcades. But for $200 you could have that in your home with the Vectrex.
Also included is a brief listing of some launch titles for the console. What surprises me is just how varied the launch line up was. The Vectrex is often known for it's space-themed and 3D games, but the first set of games represent a pretty wide swath of genres. You have Mine Storm, the Asteroids-like game that comes in an internal ROM on every Vectrex. But you also have a port of Berserk, a car racing game, football, and a few different shooters. To round things out is what I'd say is one of the more impressive titles on the console: StarTrek, a fully 3D first person spaceship shooter. Its clear from this 1982 article that people have always been impressed by the Vectrex.
If you want to experience the Vectrex for yourself, then you're in luck! The Internet Archive has an expensive collection of games that can all be played from your web browser. Check them out here:
https://archive.org/details/vectrex
To learn more about the history of the Vectrex, listen to my episode on the topic:
Website // Apple Podcasts
The 1980s were a turbulent and fast-moving decade for the video game industry. There were huge success stories, rapid advancements in technology, and the North American Video Game Crash. Caught up in all of this was an ambitious machine called the Vectrex. In an era dominated by pixelated graphics the Vectrex brought higher resolution vector images and early 3D to market. But ultimately it would be swept away during the market's crash. Today we are taking a dive into the development of the Vectrex, what made it different, and how it survives into the modern day.
Like the show? Then why not head over and support me on Patreon. Perks include early access to future episodes, and stickers: https://www.patreon.com/adventofcomputing
First published in the Atlantic Monthly in 1945, As We May Think is often cited as a watershed moment in computer history. In this essay Vannevar Bush laid out his vision for machines of the future, improved interfaces, and better data handling methods. It's most remembered today for it's description of the Memex, a theoretical device that implemented something close to the internet, complete with hyperlinks, using 1940s technology. However, there is more to this paper than just Memex. Some of the predictions and recommendations made by Bush would be realized in the coming years, others wouldn't come to be for decades.
One of these predictions is not entirely dissimilar to the idea of a computer network, at least if you use a little imagination. A core feature to Memex and some of Bush's earlier works was microfilm, for a long period of time it was the best way to store large amounts of information. Bush devotes a good amount of As We May Think to describing an idea for essentially a melding of a television and fax machine. The device he describes would take images, transfer them over some type of communication lines, and then reproduce them on microfilm. In this way large amounts of data could be requested from a repository of information and then sent to the requester, similar to a UDP request but using microfilm and fax lines.
One major theme in As We May Think, and Vannevar's writing in general, is an apparent aversion to the pen and paper. To quote from Bush:
"To make the record, we now push a pencil or tap a typewriter. Then comes the process of digestion and correction, followed by an intricate process of typesetting, printing, and distribution. To consider the first stage of the procedure, will the author of the future cease writing by hand or typewriter and talk directly to the record?"
To be clear, he thought the later would be the case in the near future. While As We May Think was being written some of the first "talking machines" were starting to show promise. The Voder, a very primitive device that could turn keystrokes into human-like speech, was shows at the 1939 World's Fair. Bush was in attendance and became instantly fascinated by the device, but he went further with the idea. If a machine could produce speech why not make a machine that can also understand speech? For the time that was a revolutionary idea. Speech recognition has only recently started catching on after considerable effort has been made, but to put forward the idea prior to the widespread use of computers was another matter entirely. But Bush had an interesting stance on the matter.
I can't underline enough how Voder only sounded roughly human, it was much more robotic and had a limited range of sounds it could produce. Instead of predicting steady progress towards more human-sounding machines Bush looked in the opposite direction. He posited that in the near future human language would adapt to be better understood by machines, thus rendering human speech more machine-like. In his words:
"Our present languages are not especially adapted to this sort of mechanization, it is true. It is strange that the inventors of universal languages have not seized upon the idea of producing one which better fitted the technique for transmitting and recording speech."
This prediction had at least half come to pass. Today digitized speech and speech recognition have become common place. A large factor in that has not been the adoption of a universal machine-like language spoken by all humans. Instead it has been thanks to a slow, steady progress to machines that can speak and understand existing human language better.
You can read the full text of As We May Think on the Atlantic's website.
And if you want to hear more about Memex and it's connection to the internet, you can find my episode on the matter here:
Website // Apple Podcasts
The widespread use of the internet has shaped our world, it's hard do imagine the modern day without it. One of the biggest featured would have to be the hyperlink. But despite the modern net feeling so new, links actually date back as far as the 1930s and the creation of the Memex: a machine that was never built but would influence coming generations of dreamers.
Like the show? Then why not head over and support me on Patreon. Perks include early access to future episodes, and stickers: https://www.patreon.com/adventofcomputing
Important dates in this episode:
1927: Differential Analyzer Built at MIT
1938: Rapid Selector Built by Vannevar Bush
1945: As We May Think Published
The floppy disk has changed very little since it's original development way back at IBM in the late 1960s. That being said there have been incremental improvements, and I'd like to look at one of those early changes. As it turns out early floppy disks came with a pattern of holes punched along their outer edge. Many 8 inch disks, and some 5 ¼ inch disks, had this feature. These types of disks were called hard sectored, and even though this approach didn't last for long I think it's useful to examine as it can give us a better understanding of how floppy drives worked.
So what exactly is a sector to begin with? To explain that let's take a look at how data is structured on a floppy disk. Data on a floppy drive is laid out in a similar way to a table, but instead of rows and columns you have tracks and sectors. Each of these sections of the disk can store a small chunk of data, so a read head has to be able to move to any location on the floppy disk. The read/write head of a floppy drive is positioned on a sled ad gear mechanism that can move it in and out over the disk, this allows for track selection. Sector selection is where the holes of hard sector disks come into play.
When in use the disk of a floppy disk spins at a constant velocity. In order to select a specific sector the drive has to wait for that sector to pass under the head. In order to do this the drive has to know which sector it's on, and that's done by reading the s on the disk's perimeter. An optical sensor in the floppy drive trips every time a hole passes so, with a little bit of programming, it's able to keep track of what part of the disk is currently under the head. To finish things off another index hole is usually punched on the inner edge of the disk to mark the first sector, that way the drive knows where to start the sector count.
Programming the controller for a hard sector disk drive is relatively simple. You don't need all that much code or power to count holes passing by. However, this style of floppy disk would pretty quickly fall out of use. I can't find a definitive answer as to why, but it's easy to speculate at a reason. One of the large driving forces behind the development of the floppy disk was price. Disks were cheap, as were disk drives. Punching holes in hard sector disks would have added an extra step and just a little more overhead to manufacturing costs. Another contributing factor cold have simply been the development of more advanced disk controller circuitry. With a little tinkering, and some more complicated software, it was possible to do away with sector holes all together.
These newer disks, called soft sectored disks, replaced the physical sector holes with magnetic markers. Instead of using a seperate optical detector the same read/write head that read data would pull double-duty, also registering sector markers. By looking for passing magnetic markets, and a little more complicated code, these soft sector capable drives were made to function just as well as their hard sector counterparts. Once 5 ¼ inch disks became the norm hard sectroing fell out of favor. Punched 5 ¼ inch disks did exist, but they were not nearly as common as soft sector disks.
To learn more you can listen to my series on the floppy disk here:
Part 1: Website // iTunes
Part 2: Website // iTunes
The floppy disk is one of the most iconic pieces of technology. While not in use in the modern day there was a period of 40 years where the floppy disk was synonymous with data storage. Today we pick up where we finished in the last episode, with the rise and fall of the 5 1/4 inch disk. We will be looking at the creation and spread of the 3 1/2 inch floppy disk. How did Sony, a non-player in the computer market, create this run away success? And how did Apple contribute to it's rise?
Like the show? Then why not head over and support me on Patreon. Perks include early access to future episodes, and stickers: https://www.patreon.com/adventofcomputing
Important dates in this episode:
1980: Sony Invents Microfloppy Disk
1983: Apple Builds Prototype MAC with 3 1/2 Inch Floppy
The floppy disk was a ubiquitous technology for nearly 40 years. From mainframes to home computers, the plastic disk was everywhere. And in the decades it was around there were very few changes made to how it fundamentally worked. So how did it get so popular? What made the floppy disk so flexible? And how did it finally fall out of favor? In this episode we will look at the technology's early days.
Like the show? Then why not head over and support me on Patreon. Perks include early access to future episodes, and stickers: https://www.patreon.com/adventofcomputing
Important dates in this episode:
1971: 8 Inch Floppy Disk(Minnow) Created at IBM
1976: Shugart Invents 5 1/4 Inch Floppy Disk
In November of 1954 the first preliminary design of FORTRAN was completed. Over the next few years a compiler was built and distributed, various changes were made to the language, and FORTRAN would start down it's path to domination. High level programming languages, starting with FORTRAN, would change what could be done with computers. In the modern day low level languages(such as assembly or machine code) are only used in niche applications, by and large programmers use sophisticated high level languages. And even through the field has come a long way since the 1950s you can still find artifacts of FORTRAN in modern day code. So what can we see in modern programming that was present in the first FORTRAN specification(https://archive.computerhistory.org/resources/text/Fortran/102679231.05.01.acc.pdf)?
Many of the features of FORTRAN's syntax were adapted from mathematics. For instance, the language has named variables, and simply uses an equals sign for assignment. These are both core features to modern languages, very very few programming languages differ from this convention. The syntax for mathematical expressions is also taken directly from pen-and-paper math. A plus is used for summing two values, and minus for subtracting, and so on. There are good reasons that this basic structure is used in more modern languages, it's clear and easy to understand and use. In that way FORTRAN more set convention than invented the syntax. However, there is one part of FORTRAN's math syntax that strikes me as interesting. The "x" operator is used for multiplication, for exponents it's doubled to the "xx" operator. More than likely this was done due to the limited character set that could be represented on punched cards. What I find interesting is that some modern languages still adhere to this schema. For instance, in Python the multiplication operator is "" and the exponential operator is "*". More than a direct adaptation, it's more likely that FORTRAN entered the double-multiplication-is-exponent syntax into common convention.
Named variables are another big feature for FORTRAN, but in early versions of the compiler there were some major limitations. Variable names could be no longer than two characters. There was also some implicit typing tied in with variables names. Any variables that started with i, j, k, l, m, or n were treated as integers while all other variables were treated as floats. On the surface this distinction may seem arbitrary, but there is good reason for this choice. In mathematics it is common to use i, j, k, l, m, or n to represent iterators(such as with the summation operator) or as indexes in vectors of matrices. FORTRAN didn't invent this notation, but it would help codify it as convention for programmers. Today it's almost universally accepted that "i" is just what you call an iterator in loops, and if it's taken then you move to "j" and on down the line.
Another interesting artifact that has to do with integers is FORTRAN's "do" loops. Later versions of FORTRAN would have relatively modern looking loops, but the preliminary report and early versions offered a different take on the matter. A do loop would look something like this:
DO 1, 10, 11 i=1, 10, 1
It's a little dense. Basically, that line of FORTRAN will loop over line 1 to 10, and when done looping jump to like 11. The second part of the line sets up the iterator, we will look "i" from values 1 to 10 in steps of 1. Later versions would change to using "do...while" instead. Needless to say programming languages have much more clear loop syntax today. However, loops using the same "do" keyword still exist in many languages including C, C++, JavaScript, PHP, and even Kotlin.
The final relic I want to touch upon is the infamous "goto" statement. Syntactically, this one is much more simple than "do". It looks like this in the preliminary report:
GO TO 100
That statement would jump execution to line 100 of your program. This statement, or at least this type of operation, predates FORTRAN. On the machine code level "goto" is analogous to a jump instruction. In more recent times it has been said that these types of instructions shouldn't be used in high level programming languages, but that hasn't stopped "goto" from making an appearance. It's not as widespread as "do" but some recent languages like Google's Go still support the keyword.
To learn more about FORTRAN and the early development of programming languages, check out my episode on the matter:
Website // Apple Podcasts
Our modern world is full of software, it's what makes everything tick. The sheer amount of code that goes into something like keeping the internet running is staggering. Programming isn't the easiest profession, but there was a time when it was much much harder. It took a huge shift in thinking, and some impressive feats of software development, to make complicated programming possible. And that shift started in the 1950s.
Like the show? Then why not head over and support me on Patreon. Perks include early access to future episodes, and stickers: https://www.patreon.com/adventofcomputing
Important dates in this episode:
1951: Grace Hopper Creates A-0 Compiler
1954: John Backus Starts FORTRAN Project at IBM
1957: First FORTARN Compiler Ships
Rogue is, arguably, one of the most influential video game ever written. It was the first game to make significant use of procedurally generated content. And there is a good chance that most people have never played it. Despite it's important and far-reaching legacy Rogue was never a commercial success. However, games heavily influenced on the 1980 original are still published and played today. Some games like Diablo, Pokemon Mystery Dungeon, Faster Than Light, or Darkest Dungeon borrow heavily from Rogue's design. Still others like Minecraft or No Man's Sky have core gameplay elements such as procedural generation. Even with the plethora of options for modern roguelike games, I think it's worth tracking down the original and giving it a spin. There are a lot of ways to play Rogue today, so I'll go over some of the options at your disposal.
The easiest way to get into the Dungeon of Doom is probably via the Internet Archive. It really is amazing just everything that the Archive, well, archives. Anyway, thanks to their in-browser emulator you can play Rogue for a number of platforms very easily. The best ports to get started with are probably the MS-DOS version or the Macintosh release. DOS Rogue is the closest to the original since it's graphics are all rendered using text characters. The major change between the 1980 version and the DOS release is the addition of color and an increased character set, both thanks to the IBM PC. Controls are relatively simple, relying on arrow keys for movement and hotkeys for actions.
The Macintosh version is quite a bit different, it has the same gameplay as the original but the graphics and controls are another story. As with most Mac software the game is rendered in black and white graphics. Everything is represented by small sprites on screen, from items to monsters to the dungeon map. It retains the same gameplay as all versions do, but the control scheme is a lot different. The entire game is driven by the mouse, a series of menus, and sub-windows. It's reasonably easy to get used to, but navigating dungeons with a mouse just doesn't feel quite the same.
Another option outside of emulation is to find a copy of rogue for your platform of choice. Luckily, there are plenty to choose from over at the Roguelike Archive. This site hosts a collection of versions of Rogue and early roguelike games. This includes copies of the aforementioned DOS and Mac ports, as well as many other ports, beta releases, and source code. The real draw for me here are the early versions of Rogue, the earliest on this page being version 3.6 from 1981. There are compiled binaries for various platforms with matching source code for the curious. These archives are from the (seemingly defunct) Roguelike Restoration Project.
Beyond being an interesting relic to explore Rogue still holds up as a fun game today. It presents a stripped down experience, presenting just what's needed to have an engaging RPG with none of the frills. In an era flooded with fancy AAA titles I think Rogue and it's close relatives still have a place. But if the graphics and controls are still a little daunting, if you'd like to just have more options, then there are! I'd also recommend checking out Slash'Em or NetHack. Both of these games are descendants of Rogue but with many, many, many more features. Each have expanded and new mechanics, character classes, more stats, and optional graphics.
If you want to learn more about the history of Rogue, then you can listen to my episode on the matter here:
Website // Apple Podcasts
Many video games today make use of randomized content, some more than others. It may seem like an obvious feature, but it turns out that procedural generation didn't really catch on in video games until the 1980 release of Rogue. The game itself never saw much commercial success, but was wildly popular among UNIX users. In this episode we look at Rogue, how it was created, and the legacy that we still see today.
Like the show? Then why not head over and support me on Patreon. Perks include early access to future episodes, and stickers: https://www.patreon.com/adventofcomputing
Important dates in this episode:
1980: Rogue Written for PDP/11
1984: Rogue Ported to PC, Macintosh, Atari ST
The Intel 8008 was the second microprocessor produced my Intel, but it was the first to have much interesting software written for it. Intel's earlier chip, the 4004, was only ever really used for desktop calculators. So most of the software written for that platform is very special purpose. Things were different for the 8008. It was used in some of the earliest personal computers, so it had relatively complex and flexible software released for it.
8-bit home computers would come to be known, almost as a cliche, for running BASIC. Well, it turns out that the tradition started early. The 8008 was the first 8-bit microprocessor, and it also had its own dialect of BASIC. One of the first companies to offer an interpreter was SCELBI(SCientific ELectronics BIology), for their own kit computer and other 8008-baed systems. This early microcomputer version of BASIC was called SCELBAL(for SCientific ELementary BAsic Language). This meant that it was possible to program for the 8008 with something other than assembly language, making it a much more immediately useful platform.
The reason this is possible with the 8008 and not a chip like the earlier 4004 comes down to complexity. The 8008 wasn't the first microprocessor, but it was the first one capable enough to run something as complex as BASIC. For some comparison: the 4004 could address only 640 bytes of memory, whereas the 8008 could handle up to 16 kilobytes. The 4004 also rigidly enforced separate memory segments for code and data, while the 8008 adhered to the more flexible Von Neuman architecture.
Outside of all of those qualifications is the simple fact that the 4004 was a 4-bit microprocessor. The single internal register, it's accumulator, was only 4-bits wide. While certainly useful for something as simple as a desktop calculator it puts the chip at a major disadvantage when it comes to more intensive tasks. And there is one key application that the 4004 would have had a major problem with: string processing. A 4-bit number can only encode 16 possible values, not enough to encode the full Latin alphabet. That fact alone means that programming something as simple as a string compare would be pretty difficult, or at pretty slow. Add that to the limited memory space and you aren't going to be getting much done with this chip.
By contract the 8-bit 8008 had plenty of space to handle characters and strings. With seven internal registers, each 8 bits wide, there is a lot of scratch space to work with. And since an 8-bit number can encode 256 possible numbers that means that you can do string processing much more easily with the 8008. Of course, that wasn't the only factor. But the simple fact that the 8008 was able to be programmed to efficiently handle functions like a string compare meant it could run BASIC. And that opens up a much larger world of possibilities.
To learn more about the Intel 8008, listen to my episode on the topic:
Website // Apple Podcasts
It's time to continue our deep dive into the legacy of Intel's processors. This episode we will be looking at the 8008, the second microprocessor produced by Intel and the progenitor of the x86 family. Along the way we will see how an innovative terminal from 1969 inspired the chip, how Intel lost a contract, and discuss some of the first personal computes.
Like the show? Then why not head over and support me on Patreon. Perks include early access to future episodes, and stickers: https://www.patreon.com/adventofcomputing
Important dates in this episode:
1969: CTC Develops First 'Glass-Teletype' Terminal
1972: 8008 CPU Released by Intel
In this mini episode we will look at the Y2K bug, and some of the recipes it spawned. That's right, we are talking about Y2K cookbooks!
You can find all more Y2K compliant food here: https://web.archive.org/web/19991012032855/http://y2kkitchen.com/
Like the show? Then why not head over and support me on Patreon. Perks include early access to future episodes, and stickers: https://www.patreon.com/adventofcomputing
Important dates in this episode:
1999: Y2K Kitchen Hits Shelves
PLATO was a groundbreaking project that was started at the University of Illinois in 1960. Over its considerable lifespan it pioneer new technology for computer-aided teaching, time-sharing, and graphics just to name a few fields. On the official side of things it was an educational platform, but unofficially it was a fantastic platform for video games.
The ultimate iteration of the system, PLATO IV, would be unveiled in 1972. It's new terminals sported a marvelous new invention: the monochrome plasma display. These screens packed a resolution of 512 x 512 pixels, which was pretty respectable for the 70s. On the backend of things PLATO IV terminals all connected up to a powerful supercomputer, forming a centralized network of just over 4000 machines. The graphical and networking capabilities of PLATO made it a ready incubator for many a young hacker. Over the year a multitude of videogames, many of them with networked multiplayer modes, popped up on the system. These included some of the earliest RPGs, arena shooters, even flight simulators.
I hear you ask, can you experience these games today? Well, you are in luck! There is still a way to access a living PLATO system today. The people over at cyber1.org maintain an emulated PLATO server, and you can even request an account for the system. Coupled with pterm, a PLATO IV terminal emulator, it's relatively easy to get connected. Cyber1 offers a wide range of games and other software from the 70s and beyond.
There are too many programs, and they are far too varied, to give an overview of them all. Instead I want to focus on a game that stuck out for me: Futurewar. The game was written in 1977, and then eventually restored by the team at cyber1 for it's 40th anniversary in 2017. Futurewar is essentially an RPG, your character starts with random attributes for strength, agility, endurance, intellect and so on. As with a lot of early RPGs you spend most of your time traversing a dungeon, finding money, and fighting monsters. What makes Futurewar stand out is its gameplay and setting.
First off, Futurewar is presented in 3D from the first person perspective. It may come as a shock, but for PLATO games of this era that isn't unique. A lot of RPGs on the system presented their dungeons in 3D. This isn't something on par with later games like DOOM, but it's definitely impressive for the time it was written. Your view of the game world is rendered as a small portion of the screen, but despite that it's definitely playable. What makes Futurewar stand out from other 3D PLATO games is the fact that you wield a gun and as you travel the maze your gun remains visible at the bottom of your view. There's even a little animation of a bullet when you fire. That's right, Futurewar is a very early example of a first person shooter.
Second we have the setting of the game. Most of the other 3D RPGs on PLATO were designed as high fantasy adventures. However, Futurewar is different. It's set in the far-flung year of 2020. In the aftermath of a catastrophic war you and your team(humans, guerillas, barbarians, martians, or cyborgs) is battling for control of an underground bunker. The bunker is full of hazards, rubble piles will block your way, radioactive waste will hurt you, and monsters will attack you. Enemies suit the setting, at least somewhat. This includes mutants, giant lice, robots, and skeletons. Defeating monsters earns you money and loot, but you can also find random first aid kits scattered throughout the maze.
It's a fun game, but it's also pretty hard. I usually die on the first level. The first person view can also be disorienting, you have a limited field of view and the levels are built like a maze. There are no textures so walls look the same, making it easy to get lost. There are the occasional doors, brick walls, and some graffiti, but not enough for me to keep track of where I am without pen and paper. The controls also take some getting used to. Movement is tied to the WAXD keys, with S used to shoot. Menus for in game stats are bound to PALATO's special keys, which pterm maps for you so you don't need an archaic keyboard. Reading the help file (with alt-h) gives you everything you need to know, but it does take some getting used to.
If you are up for a challenge, or want to experience some early computer games, I'd highly suggest giving cyber1 a look. If you want to dive deeper into PLATO's history then you should pick up a copy of "The Friendly Orange Glow" by Brian Dear. It's proved invaluable to me during my research, and beyond that it's just a great book.
And if you want to hear more of my take on PLATO, then you can listen to my episode on the topic here:
Website // Apple Podcasts
In the conclusion to our discussion of PLATO we look at the final incarnation of the system: PLATO IV. How did an educational machine turn into one of the earliest online communities? What was it like to use PLATO at it's height? Along the way we will look at the software, hardware, and video games that made PLATO so special.
Like the show? Then why not head over and support me on Patreon. Perks include early access to future episodes, and stickers: https://www.patreon.com/adventofcomputing
Important dates in this episode:
1964: Plasma Display Patented
1972: PLATO IV Launches at University of Illinois
1973: Empire, First MMO, Developed for PLATO IV
PLATO(Programmed Logic for Automatic Teaching Operations) was an ambitious project started in 1960 with the goal of revolutionizing learning. And despite massive technical advances made by the project it remains relatively obscure today. It started out small, with just one terminal connected to the University of Illinois' ILLIAC computer, but over time PLATO evolved into a robust computerized teaching platform. Over the projects lifespan there were four major interactions: PLATO I, II, III, and IV. The first two versions were essentially prototypes. PLATO I was the single terminal I described above, PLATO II was similar to the first version but allowed up to two terminals connected to ILLIAC to be used simultaneously. PLATO III was the first version to see actual use in classrooms, with some of the first college courses being offered on the platform in 1965.
What's so remarkable about PLATO is that fact that it was able to offer a markedly modern experience decades before any other computers could. The later PLATO IV would introduce things like plasma displays, touch screen interfaces, and networked applications and game. As impressive as those advances are, I think PLATO III is a shocking achievement in it's own right that should not be overlooked.
The core of PLATO III is a mix of old and new technology. Terminals, which connected up to a CDC 1604 mainframe, were actually modified TVs with custom built keysets. Signal flow into the mainframe was relatively simple, each keyboard fed into a multiplexer/switcher then into the computer. The output side of things is a lot more convoluted, but makes a good example of what can be done with limited technology. Two sources were combined to make the final image displayed at any given terminal: a computer controlled slide projector and a storage tube. The slide projector was used as a bit of a work around to avoid loading too much data into limited computer memory, static images could just be turned into slides and loaded up. Some clever programming made it easy to select which slide to display at any given moment. The actual image from the slide was picked up using a scanner. That image was mixed with the image on a storage tube, essentially a CRT tube with that could persist a bitmap image for a short period of time. These tubes were used for more dynamic content that actually needed to be rendered by the computer, and there was a tube dedicated to each terminal. Once mixed together the signal was broadcast over a CCTV setup to it's designated terminal. It made for a robust way to combine graphics and text using the limited computers of the time.
PLATO III was also remarkable for the fact that it was an early time sharing system. Using an operating system called CATORES, written in house, up to 20 terminals could be used simultaneously. This was developed concurrently to other early time-sharing systems like MIT's CTSS, but what I find interesting is that while MIT had an entire project dedicated to time-sharing for PLATO it was simply a step in the road. That seems to be true of a lot of things developed for PLATO, huge advances were made as a matter of convenience.
If you want to learn more about the development of PLATO, here is my episode on the topic:
Website // Apple Podcasts
In the 1960s a small project started at the University of Illinois. This project, called PLATO, would go on to pioneer a truly impressive amount of new technology, including the first plasma screen, MMO video games, and time-sharing. However, PLATO remains relatively unknown today.
Like the show? Then why not head over and support me on Patreon. Perks include early access to future episodes, and stickers: https://www.patreon.com/adventofcomputing
Important dates in this episode:
1952: ILLIAC Becomes Operational
1960: PLATO I Developed
1961: PLATO II Developed
1969: PLATO III Developed
http://tee.pub/lic/4jnwv7m_ZPw
The computer mouse is one of the most ubiquitous devices in the world. It's the primary way we interact with computers. And it's also one of the longest lived computing devices. Since its invention in the early 1960s the overall design of the computer mouse has changed very little. That being said, there has been incremental improvement to the mouse's internals.
The earliest mouse was developed by Doug Engelbart and Bill English at the Augmentation Research Lab at Stanford. Right off the bat, the mouse looks reasonably similar to what we are familiar with today: a puck that fits in the hand with buttons(or in this case a single button) on top. However, under the hood we have a rodent of a totally different species. The ARC mouse was actually an analog device: it used two perpendicular wheels connected to potentiometers to measure it's movement across a desk.
The next update to the mouse came in 1973 at Xerox with the invention of the ball mouse. This new mouse was designed to be used with the Alto, the first GUI-based computer. The largest external change is the fact that this new Xerox mouse uses a single large ball instead of two perpendicular wheels. The other change was a little more hidden, the new Alto mouse was entirely digital. Instead of using potentiometer to measure movement this new mouse used a set of encoding drums and brushes. The surface of each drum alternated between stripes of conductive and nonconductive material. As the drum spun it would alternate between closing and breaking a circuit with the brush, thus creating a stream of binary data.
The final big change, which would become the most popular design, happened in 1980. This new mouse would be built for the Apple Lisa by Hovey-Kelley Design, an industrial design contractor. On the outside is the same familiar mouse, it even glides over a single ball like the earlier Xerox mouse. There were some changes made to make it a more marketable product, a lot of the design of the Lisa mouse came down to making it cost under $35 to produce. However, the largest change was in how it measured movement: the new mouse used slotted encoder disks and optical pickups instead of drums and brushes. These encoder disks are simply plastic wheels with a pattern of slots cut along there edge, as they spin the disk alternated between blocking and letting light through from an infrared source. The light pattern is then read off by an infrared detector on the other side of the disk. The operating principal is the same as the earlier Xerox mouse but the device is much more durable since there is no contact between the encoding disk and the pickups.
If you want to learn more about the history of the mouse, listen to my episode on the matter:
Website // Apple Podcasts
The computer mouse is a ubiquitous device, it's also one of the least changed devices we use with a computer. The mice we use today have only seen small incremental improvements since the first mouse was developed. So how did such a long lasting design take shape, and how did it travel the decades up to now?
Like the show? Then why not head over and support me on Patreon. Perks include early access to future episodes, and stickers: https://www.patreon.com/adventofcomputing
Important dates in this episode:
1961: First Mouse Developed at Engelbart's ARC Lab
1972: Xerox Develops Rollerball Mouse for Alto
1979: Apple LISA Mouse Designed
In this mini-episode we look at a strange event in Microsoft's early history and their first case of piracy. Along the way you will learn about the best advetrizing campaign in history: the MITS MOBILE Computer Caravan!
Like the show? Then why not head over and support me on Patreon. Perks include early access to future episodes, and stickers: https://www.patreon.com/adventofcomputing
Important dates in this episode:
1976: 'Open Letter to Hobbyists' Written by Bill Gates
http://tee.pub/lic/4jnwv7m_ZPw
The BBC Domesday Project, completed in 1986, is a lot of things. Broken up into two LaserDiscs is a massive volunteer-collected survey of Britain, graphable and searchable census data, high resolution maps, and virtualized 3D tours of selected locations. The entire project blurs the line between time capsule and tech demo. Out of all of the varied media that makes up the Domesday Project my favorite part has to be the "Domesday Gallery".
The Domesday Project was distributed on two discs: the Community and National Discs. The Community Disc was comprised of volunteer survey data consisting of images and writings collected from school children and volunteer groups. This made up a view of "Britain by the British", so to speak. The National Disc was the BBC-curated view of the country and was made up of numeric data, images, short videos, and virtual tours(think Google street view) of parts of the country, called "surrogate walks". The Domesday Gallery was the first thing you saw when loading the National Disc, and it served as an interactive menu for that section of the project.
To access content on the disc users would walk around the figure 8 shaped virtual gallery. Hanging on the walls were images that users could approach, view, and pull up more information about. Also along the walls of the gallery were doors that took users to the aforementioned surrogate walks, making the gallery a sort of "hub" for users to step into other virtual spaces. For 1986 technology this is all pretty impressive. The computer used for the Domesday Project is a BBC Master, an 8-bit microcomputer with 512 Kb of RAM. It's not a powerful machine by any means, so how was it able to display a virtual world? Well, it comes down to some tricks, and a lot of pre-rendered graphics.
The computer itself acted as a glorified controller for an accompanying LaserDisc player. The LaserDiscs used for Domesday were in a custom format(LV-ROM) that stored analog images along side a separate digital data track. The magic comes down to that analog track. Higher resolution images were stored as analog data, and the computer could switch the LaserDisc player to any given image on the disc. Then when a user was navigating the gallery or a surrogate walk the computer just had to figure out which image corresponded to the user's current location and display it from the LaserDisc. The images for surrogate walks were, of course, just pictures. The Domesday Gallery part of the disc was built up using pre-rendered 3D graphics.
So how was the Domesday Gallery rendered? Most of the software for the Domesday Project was written by Logica, a UK based IT firm. They also handled 3D modeling and rendering of the Domesday Gallery. Logica's tool of choice for creating the gallery was a Bosch FGS-4000. And, well, that's where things get a little muddy.
There isn't much information about the FGS-4000 online. The machine is probably best known for being used to render the music video for Dire Straits' "Money for Nothing", but outside of that it seems pretty obscure. I've been able to find sample images and videos produced on the system, forum posts, and one ad for the machine from Bosch themselves. As near as I can tell the FGS-4000 was part of a range of stand-alone 3D modeling systems built around the Motorola 68000 CPU with some kind of custom graphics hardware. There are a few images floating around of the computer's console(like in the ad), but I haven't been able to track down a picture of the whole system. I'd be interested to learn more about the system, but until then I'll have to mark it down as one more mystery surrounding the BBC's Domesday Project.
To learn more about the Domesday Project, you can listen to my episode on the topic:
Website // Apple Podcasts
In 1086 William the Conqueror commissioned a survey of England that would come to be known as the Domesday Book. 900 years later the BBC would create a similar survey, called the Domesday Project. This new survey spanned two LaserDiscs holding over a gigabyte of data and 200,000 images, most of which were collected by students. It presets an amazing time capsule of the UK in 1986. Also contained within the disks were 3D virtual walks of the country side, and an entire computer generated gallery. So how did such strange technology come together to commemorate a 900 year old manuscript?
Like the show? Then why not head over and support me on Patreon. Perks include early access to future episodes, and stickers: https://www.patreon.com/adventofcomputing
Important dates in this episode:
1986: BBC Domesday Project Released
The Intel 4004 was the first commercial microprocessor. There is a lot that can be said about this achievement, but what exactly was the chip like to work with? The fact of the matter is that the 4004 would live it's life as a controller for simple devices, but didn't really show up as a CPU powering computers. It's not really possible to make a definitive conclusion as to why this is, you can't prove a negative. However, I think that the underlying architecture of the chip made it more suitable as a microcontroller-like device rather than a general purpose computer.
First off, the 4004 is a 4-bit processor. That means that it is primarily designed to work with 4-bit binary numbers. That immediately puts limits on what the chip is capable of, and you can see those limits directly in the pinout. The chip only has 16 pins, so there isn't much space to start work with. The data bus is only 4-bits wide. There are an additional 4 pins that are used in multiplex with the data bus to form an address bus for accessing memory. Technically, the address bus is 12-bits wide, the full address is sent out over 2 successive clock ticks, but it only uses 8 pins. The remaining 8 pins are used to provide power to the chip, reset/test triggering, two clock inputs, and semaphore for controlling memory chips.
To further complicate things the 4004 isn't a Von Neuman architecture computer. This makes the chip somewhat exotic since most modern computers are Von Neuman architecture machines. That means that, among other things, executable code and generic data are both stored in one shared address space. Instead, the 4004 is closer to a Harvard architecture, it has a separate address space for code and data. While there are some side issues caused by this design choice, the largest problem is that it imposes even more limitations on programmers. The limited memory the chip can address is broken into two smaller segments. You only address up to 640 bytes of memory for data, and 4096 bytes for executable code. That segmentation makes the 4004 look a lot more like a microcontroller than a microprocessor.
Outside the strange memory mapping you get something a little more familiar. The CPU is register based, with 16 general purpose registers. Each are 4-bits wide, and named R0 through R15. There is an additional 4-bit accumulator for storing the result of calculations and a 12-bit program counter for storing the location of the currently executing instruction. That's all pretty standard, later Intel chips would also be register based. If you've used any x86 chips before, you may see what's missing here. There are no pointer registers. That's because the 4004 doesn't implement any real form of a stack. The only thing that comes close is the internal call stack, which is comprised of three 12-bit registers. You aren't going to be getting anything recursive running on here very easily.
All tolled, the details of this 4004 make it a reasonable controller for computerized machines but not a very capable general purpose processor. The biggest issue that I can see just from the spec sheet would be implementing any kind of interface beyond a simple front panel. Text processing would be exceedingly difficult. In the now standard ASCII scheme a single character is 8-bits which would take up two registers on the 4004. That means that doing a simple operation like a string compare would take a lot of juggling. Then we run into the issue of having limited space for code, each machine code instruction on the 4004 is either 5 or 8 bits wide. For simplicity, if we say a program is totally composed of 8-bit instructions then we can have, at most, 4096 instructions. That isn't really enough to get much done. That being said, the 4004 is still quite a feat for such an early microprocessor. In the coming years, Intel would put out much more capable chips.
To learn more about the history of the 4004, you can listen to my episode on the topic here.
Intel is one of the dominant forces in the computer industry today, they may be most well known for their line of microprocessors. These chips have powered computers going back to the early days of microcomputers. How did Intel become so entrenched in the field? Well, it all started with the 4004 CPU, the first "one-chip" computer.
Like the show? Then why not head over and support me on Patreon. Perks include early access to future episodes, and stickers: https://www.patreon.com/adventofcomputing
Important dates in this episode:
1971: Intel 4004 Released
One of the things that makes Colossal Cave Adventure such an fantastic game is that there are so many ways to play it. The game has been ported to just about any computer you can think of, and that development activity isn't limited to the past. There are quite a few recent web-based ports of the game engine. One my favorite web Adventures can be found here: https://github.com/mmastrac/adventure. This implementation is relatively new, as of posting it
looks like code was contributed as recently as 16 days ago. It reimplements the Adventure game engine and but not the original data file, so it's a pretty faithful port.
Another option is, asl awyas, emulation. If you want to go that route then the Internet Archive is a wonderful resource. Archive.org has an impressive and ever expanding catalog of vintage software. And even better, they have a lot of their software archive available to use in-browser vie emulation. You can play Microsoft's port of Adventure on the Internet Archive here: https://archive.org/details/msdos_Microsoft_Adventure_1981.
If you want something more niche, the Internet Archive actually has a good number of ports of Adventure that you can run in browser:
Commodore 64: https://archive.org/details/Adventure_64_Colossal_Cave_Adventure_1986_The_Guild_Adventure_Software
ZX Spectrum: https://archive.org/details/zx_Colossal_Cave_Adventure_v2_1985_Anubis_Software
Classic Macintosh: https://archive.org/details/mac_Adventure_350_point_James
One final option, but this is only for the truly adventurous. A 1977 copy of the FORTRAN source code for Adventure is available. Both the game's engine and data file are direct from the keyboards of Crowther and Woods, making this the definitive way to experience Colossal Cave Adventure. However, you have to compile it first. And gfortran doesn't seem to like it, so there will probably be a lot of work involved with getting it to run. You can find the 1977 source code here: http://www.icynic.com/~don/jerz/
To learn more about Colossal Cave Adventure, you can listen to my episode on the topic:
Website // Apple Podcasts
Colossal Cave Adventure is one of the most influential video games of all time. Originally written for the DEC PDP-10 mainframe in 1975 the game has not only spread to just about any computer out there, but it has inspired the entire adventure/RPG genera. In this episode we are going to look at how Adventure got it's start, how it evolved into a full game, and how it came to be a lunch title for the IBM PC.
Like the show? Then why not head over and support me on Patreon. Perks include early access to future episodes, and stickers: https://www.patreon.com/adventofcomputing
Important dates in this episode:
1975: Colossal Cave Adventure Developed
http://tee.pub/lic/MKt4UiBp22g
Computer viruses in 2019 are a real threat, but that wasn't always the case. In fact, some of the earliest viruses were not even that real. A perfect example of this is The Scarred Man, a sci-fi short story written in 1969 by Gregory Benford. First published in Venture Science Fiction in 1970, The Scarred Man includes the earliest depiction of a computer virus, right down to the name. And when you get right down to the details what Benford describes sounds shockingly like modern viruses. The program, called "VIRUS", starts out as malicious code hidden on a single computer. It then runs at random intervals and attempts to connect to another computer at random(in the story it's via phone lines). The virus is able to spread quickly and infect many computers causing performance issues on affected systems. No one, besides VIRUS's creators, know the true origin of the plague until long after it has spread.
The interesting twist is that the programers who made VIRUS go into the business of removing their malicious code from computers, for pay of course. The Scarred Man was met with poor reviews, both by critics and Benford himself. It definitely falls into the category of generic pulp sci-fi. Despite that, it still serves as a good prediction of things to come. If you want to read the story for yourself Benford has a copy of it, complete with author's notes, posted on his website(http://www.gregorybenford.com/extra/the-scarred-man-returns/). Only a year after The Scarred Man hit shelves the first real virus would be written. This first outing, called Creeper, came about not as an attack but rather as a demonstration program. Originally written by Bob Thomas and later modified by Ray Tomlinson, Creeper was part a larger of distributed computing research effort at BBN in the 70s. The program was first meant as a way to test migrating processes from one machine to another. In this iteration Creeper was a traveling program moving from machine to machine across the ARPANET. Soon after, it was modified to stay on machines it traveled through, and thus Creeper became the world's first virus. But what did it actually do to 'infected' machines? Well, not much. It just printed out "I'M THE CREEPER : CATCH ME IF YOU CAN!".
If you want to learn more about the early days of the computer virus, you can listen to my episode on the topic:
Website // Apple Podcasts
Computer viruses today pose a very real threat. However, it turns out that their origins are actually very non-threatening. Today, we are going to look at some of the first viruses. We will see how they developed from technical writing, to pulp sci-fi, to traveling code.
I talk about The Scarred Man by Gregory Benford in this episode, you can read the full short story here: http://www.gregorybenford.com/extra/the-scarred-man-returns/
Like the show? Then why not head over and support me on Patreon. Perks include early access to future episodes, and stickers: https://www.patreon.com/adventofcomputing
Important dates in this episode:
1949: John Von Neumann Writes 'Theory and Organization of Complex Automata'
1969: 'The Scarred Man' Written by Gregory Benford, Coined Term 'Virus'
1971: Creeper Virus Unleashed
Today I am joined by Julien Mailland and Kevon Driscoll, co-authors of Minitel: Welcome to the Internet and proprietors of the Minitel Research Lab(minitel.us). We talk about their book, how they first started working on Minitel terminals, and the ongoing work to preserve Minitel.
In the 1980s in France there existed a service that was remarkably similar to the later world wide web. That service was called Minitel. It was first launched in 1980 and continued in use all the way until 2012. During that 32 year span Minitel served as both a network to connect the people of France, and a platform for startups and existing businesses to launch new remote services. Minitel was many things to a lot of people, but as of today the network is gone, and the existing terminals and assorted hardware lay dormant. However, there are ways to experience some of Minitel for yourself, thanks to the work of intrepid hackers and historians.
One approach to preserving Minitel is to find a way to connect the actual terminals up to some more modern tech. There are a few ways to do that, the easiest being simply sending serial data to the terminal. Most models of Minitel terminals actually had a serial port, so a lot of these types of projects focus on adapting the serial port to a USB interface. Once connected you can feed whatever data you want into the Minitel.
Another approach is to create your own Minitel server. Now, this is obviously much more complicated than just a serial to USB conversion. This is due to the fact that the network interface on a Minitel terminal is a modem, so you can't just use a web server. One such project, Jelora's Minitel server(https://www.jelora.fr/post/2017/08/27/Serveur-Minitel.html), uses a Raspberry Pi, VoIP line, and a lot of reverse engineering, to recreate a fully functional Minitel service.
On the other end of the spectrum is emulation. Minitel terminals are such simple devices that they are relatively easy to emulate, even inside a web browser. Sites like http://www.3614hacker.fr/ and http://3611.re/ let you experience using a Minitel service all inside your browser. Both those services are also available over phone lines using an unmodified Minitel terminal.
If you want to learn more about Minitel, it's history, and preservation, then I highly recommend checking out the Minitel Research Lab at http://mintel.us, and the labs recent book: "Minitel: Welcome to the Internet".
And for my thoughts on Minitel, you can listen to Advent of Computing's most recent episode:
Website // Apple Podcasts
Today we are dipping back into the deep and complex history of the proto-internet. We are going to be looking at Minitel, a France-Wide-Web that was built in the 1980s as a way to help the country stay relevant in the digital age.
Like the show? Then why not head over and support me on Patreon. Perks include early access to future episodes, and stickers: https://www.patreon.com/adventofcomputing
Important dates in this episode:
1980: Minitel Program Networks France
The rise of the MITS Altair 8800, and it's connection to Microsoft, has one key event: the January 1975 issue of Popular Electronics. This article was the first real press for the computer, which created a huge buzz around it's release. It was also how Bill Gates and Paul Allen were first introduced to the Altair, an event that would lead to the founding of Microsoft and the creation of MS BASIC. So what was in the article that launched both the Altair 8800 and inspired Microsoft? Turns out that it was full of a lot of imagination and some not-so-true statements. Essentially, the "article" was just a six page long advertisement.
This starts at the cover page. The pictured Altair 8800 looks pretty different from the release models. This could be explained away as the photo using a prototype, but that's not the case. The cover photo is actually of a mostly empty cardboard box. MITS had sent a review model of the Altair to Popular Electronics to be photographed, but somewhere along the way the computer was damaged. So a rough model was made using a cardboard box. The only part of the computer pictured is the lights and switches of the front panel, albeit mounted in a cardboard plate.
The actual article isn't much more factual than the cover. The title line boasts "The most powerful minicomputer project ever presented -- can be build for under $400". And, well, even for the time that's just not true. If you want to be nit-picky, the base model of the Altair 8800 sold for $439. Outside of the pedantic, there is a bigger issue in this title. The "under $400" Altair came with 256 bytes of RAM. That's barely enough for a usable program. The article admits the small RAM side, but goes on to say that the Altair "can be economically expanded for 65,000 words". Honestly, I can't understand why they would use "economical" to describe that. A 4k RAM expansion board from MITS cost $264. So to get to 64k(for simplicity) of RAM you need 16 expansion boards. That's $4224 just for the extra RAM, just under ten times as much as the base computer. Adding in the cost of that base computer and adjusting for inflation we get a roughly $22,000 computer.
The rest of the article explains the basics about the computer kit: parts lists, functional block diagram, a short primer on what a computer is, and a description of how an Altair 8800 is assembled. Hiding in that is one of my favorite infoboxes I've ever read: "Some Applications for the Altair 8800". Like it says in the title, this is a list of ideas for what to do with your new Altair computer. What I find interesting and charming about this list is the sharp discrepancy of complexity. Some of the highlights include...
"Programmable scientific calculator"
"Digital Signal Generator"
"Navigation Computer"
"Signal Analyzer"
"Digital Filter"
Those all seem pretty sane, and definitely possible with a base 256 byte Altair. Then you have…
"Time-sharing Computer" -- In the 70s mainframes were only starting to be able to do this.
"Patter-Recognition Device" -- That's in the realm of MIT AI Lab research at this time.
"Smart Computer Terminal" -- The Altair doesn't have any way to interface with a screen or keyboard out of the box.
"Brain for a Robot" -- ...what?
If you want to read the article in full, there is a scan available here(http://www.swtpc.com/mholley/PopularElectronics/Jan1975/PE_Jan1975.htm).
And if you want to hear more about the story of the Altair 8800 and Microsoft's first product, you can find my podcast on the matter below.
Website // Apple Podcasts
Today we are going to be traveling back to the late 1970s to take a look at the early days of the home computer. And specifically how Microsoft found a foothold at just the right time and place. And for Bill Gates and Paul Allen that would come in the form of BASIC.
Along the way we will cover the Altair 8800, vaporware, and how Bill Gates violated Harvard student conduct.
Like the show? Then why not head over and support me on Patreon. Perks include early access to future episodes, and stickers: https://www.patreon.com/adventofcomputing
Important dates in this episode:
1974: Altari 8800 Released
1975: Microsoft BASIC Released
Spacewar is a remarkable game for a large number of reasons. It was one of the first video games ever made, first conceived by Steven Russel and his colleagues at MIT's AI Lab sometime in 1962. And despite the game's age it presents a core experience not that far off from modern video games. There were numerous firsts to come out of Spacewar. However there are factors outside the game itself that make the story of Spacewar so compelling. One of those factors is the continues efforts at preserving the nearly 60 year old game.
A lot of early video games, or early programs for that matter, have been lost to time. Luckily, due to Spacewar's popularity and the open nature of the computer scene at the time there were a lot of copies of the game floating around. Both source code and paper tape of the game circulated through institutions all over the country in the 60s. And having access to the software does make preservation easier, but that only solves half the equation. To actually play Spacewar you still need either a running PDP-1 or some kind of replacement.
The problem here is that only 53 PDP-1s were ever produced. That and the age of the machine makes it no small feat to find a machine. Of the production run only 3 are known to have survived to the modern day, and all of those machines are currently housed at the Computer History Museum in Mountain View. Of those machines, one has been fully restored to working order and is on exhibit. Twice a month, or during special events like the Vintage Computer Festival Far West, the machine gets fired up for public demonstrations. So if you can make it to Mountain View you can get a chance to play Spacewar for yourself on it's original hardware.
If you can't make it to Silicon Valley, there are still plenty of ways to experience Spacewar. One option is to track down a port or adaptation of the game. But while releases like the 1973 Atari 2600 version or the 1985 of the game are similar to the original, they aren't entirely the same game. For the accurate experience, you need to track down an emulator. Luckily, commonly available multi-system emulators like SIMH and MESS can easily run PDP-1 software. By using an emulator you can faithfully run the original version of Spacewar as written in 1926.
Lets say you don't want to bother installing MESS, well there are even easier options. More recently JavaScript based PDP-1 emulators have started to appear. This means that you can now play Spacewar in your web browser without needing to install anything. There are a few web pages out there running the game(https://spacewar.oversigma.com/html5/, https://www.masswerk.at/spacewar/). Some even allow you to load and play different versions of Spacewar.
So why not go play a round or two? After playing Spacewar myself I can tell you it feels shockingly modern, and surprisingly fun.
To learn more about Spacewar and the dawn of video games, listen to my episode on the topic.
Website//Apple Podcasts
It really seems like in the last decade video games have gone from a somewhat niche hobby to a widespread part of our culture. Nowadays, there are a multitude of ways to get out gaming fix. Consoles, handheld game systems, and even smartphones make video games more accessible than ever. But when and how exactly did video games start to creep into the modern consciousness?
In this episode we look at some of the earliest video games and how they came to be.
Like the show? Then why not head over and support me on Patreon. Perks include early access to future episodes, and stickers: https://www.patreon.com/adventofcomputing
Important dates in this episode:
1962: Spacewar! Developed
In this mini-episode we look at the Jargon File, an early primary source about hacker culture.
The most recent version of the file lives here: http://catb.org/jargon/html/
If you want more of my voice, I was also recently on the What Do You Do With That podcast talking about restoring an IBM PS/2 Model 25. You can find all their episodes here: https://wdydwt.blubrry.net/
There isn't such a thing as a single event we can point to as the "birth of the internet", but we do get close to an event like that during the Cold War. That was when ARPANET, an early iteration of widespread networking, was designed and built. And while there were an uncounted number of contributors to the design of the final network, I think that the work done by Paul Baran at RAND is an interesting mark of the time that ARPANET came from.
Paul Baran was a computer scientist working on the problem of reliable networking at RAND in the early 1960s. The RAND Corporation is a civilian company that was started as an offshoot of the US Military with the express purpose of carrying out research for the Armed Forces. So it should come at no surprise that the work Baran was doing would have a militant streak to it. The "reliability" part of his research is much better termed as "survivability", that is investigating how to create a network that could survive an upcoming nuclear war with the Soviet Union. Luckily that war never came, but a lot of the choices that ended up forming into the modern internet came from this mindset.
In 1964 Baran would release his findings in a massive report, spanning multiple volumes. Inside he detailed a network very similar to the modern internet: a distributed net of computers sending data as binary packets. If you are familiar with networking, then that's basically a point for point description of todays internet. But what's interesting about Baran's work is the intent behind a lot of the choices he made. To underline this I want to quickly go over how Baran himself summarized his RAND report on networking. In the final volume he breaks his findings down to 7 bullet points:
"1) It appears theoretically possible to build large networks able to withstand heavy damage whether caused by unreliability of components or by enemy attack."
The "enemy attack" here is referenced throughout the paper, and it is made clear that the primary concern if for a nuclear-backed attack on American soil. But the fear of failing components is also relevant, you have to remember this is in an age not far removed from vacuum tubes. In both cases, the redundancy of Baran's proposed distributed network add a layer of safety and reliability.
"2) Highly reliable and error-free digital communication systems using noisy links and unreliable components can be built without exceeding the present-day state-of-the-art of electronic components--provided we use digital modulation."
It was never a given that any network would be digital, an analog network could have just as easily been proposed in the 50s or 60s. However, digital does have some key advantages specifically for long-distance communication. Since digital signals are effected much less by noise they can be carried by worse lines. In this case, the report is talking about using existing, and noisy, phone lines to carry digital data. Analog simply would have degraded too much over any distance on telephone cables.
"3) We are beginning to understand, or at least to appreciate, the cause of time delays and overloading phenomena in communication systems handling competing users with different levels of importance. There is a basis for hope that one day we may be able to automate highly sophisticated priority systems. Such systems may even be so effective as to provide the operational equivalent of exercised judgment."
Priority messaging isn't something that really exists in the internet today, but a lot of earlier networks had plans for this feature. Basically, this boils down to the fact that any network at this stage in development would be government funded, and any government wanted to be able to jam through priority messages for time-sensitive stuff(think nuclear launch codes).
"4) it appears that a proper direction in which to move in attacking the secrecy problem in large military and commercial communication systems, is to design the cryptographic provisions as an integral part of the digital switching system."
This part is interesting to me. Today we have security schemes like SSL/TLS that encrypt data as it's sent over a network, but those standards didn't come into being until the 1990s. But that just hides the data being sent, not where the data is going.
"5) Digital communication systems able to serve highly automated sources can be more readily designed from the viewpoint of bit-transportation systems rather than the conventional approach of a tandem connection of real-time links."
Digital data is better sent as binary chunks than as an unending stream. This is basically the idea of packet-switching, where a large message is broken down into small packets of data as it's sent and then reassembled. Since digital data can be represented as discrete numbers, you can do this easily and it gives you a lot of flexibility.
"6) One day in the future (and we are not foolhardy enough to predict an exact date), for economic reasons alone in the military environment it may be necessary to break away from existing analog signal communication network concepts in favor of all-digital networks."
We are solidly in the digital future, but I still don't think anyone can exactly put a date on when we fully migrated away from analog systems. It's wild for me to see a paper from the early 60s that is ostensibly about computing talking about the need to stop using analog systems. This feeds back into the point I was making earlier: it was never a given that the future would be digital.
"7) It is appropriate to redesign user input-output instruments, such as telephones and teletypewriters, for the described system in order to gain the full benefit that accrues to an all-digital communications network."
This may be my favorite part. Here, Baran is basically saying we will need all new technology to fully utilize an all new network. Instead of thinking about how a digital network could be made to work with existing technology, he is phrasing it as we need to change our current paradigm to work with a new digital network.
If you want to go deeper down the rabbit hole, the whole report is archived at the Internet Archive(https://web.archive.org/web/20101228070851/http://www.rand.org/about/history/baran-list.html) And if you want to hear more about the history of ARPANET, and how America first became networked, then check out my latest episode.
Website // Apple Podcasts
In this episode we are going to explore the ARPANET. This is a companion to the last episode, which covered contemporary Soviet attempts to create an early internet.
Like with last time, today we are still in the Cold War era. Now, this won't be a point by point comparison of Soviet to US networks. They are totally different beasts. Instead, what I want to do is look at how ARPANET was developed, what influenced it, and how it would kick start the creation of the internet.
ARPANET was the precursor to the modern internet, or at least the network infrastructure we are familiar with today. The design phase of the project started in the early 1960s, with the first infrastructure being placed in '69. Eventually the project would grow into the internet we know today, but there were earlier attempts at large-scale networks. Specifically, the Soviet Union had a series of attempts at creating nation wide networks going as far back as 1959.
Some of the first of these networks were military defense and monitoring grids built in the US and the USSR just after WWII. These networks are interesting and deserve their own separate discussion, but they weren't general purpose. Part of what makes the modern internet so important is that it can transfer general data, that and the fact that anyone can get access to the entire network.
Most Soviet network plans hinged on a crisis occurring just as computers started to hit the Russian scene. The nation was based on a planned economy, in which the government controlled all production and distribution. This is counter to the supply and demand driven market economies of capitalist nations. The goal of a planned economy is to, ideally, create a perfectly efficient economy. Or at least an economy that the government can easily shape. As the name suggests, to do this takes a lot of economic planning. And in the 50s it was becoming clear that human power alone could not create a perfect plan.
This was around the same time the first computers were being constructed in the Soviet Union. The number-crunching potential of computers offered a new avenue of investigation to put the economy back on track. But it turns out that modeling an entire economy, even backed by computer power, is difficult. To create a perfect model of the whole economy you need perfect information on everything that goes on inside the country. Then to process that information you need a lot of computing power.
One solution to this problem was to create a massive country-wide network. Pretty soon after the introduction of computers in Russia plans for a network started to be made. Starting in 1959 with Kitov's EASU proposal, and continuing on into the early 70s, some of the best minds in the Soviet Union would offer their own designs on a networked nation.
The most fruitful of these attempts was Glushkov's OGAS. This was planned to be a decentralized network that would span the entire Soviet Union and be used primarily to collect data on and plan for the economy. The network was laid out in a different way to our current internet. Instead of being distributed as ARPANET would later be designed, OGAS was a 3-tier decentralized system. A central node in Moscow would be connected to a series of regional centers. A final lower tier of access points would connect to the nearby regional nodes.
A key part of the proposal was to automate away the problems the Soviet government faced, by using a network of computers to generate both economic plans and automatically make government decisions. But outside of that, OGAS was also groundbreaking for being a civilian-accessible network. Access points would be spread through the country allowing Soviet citizens to get online decades before the advent of the internet.
Ultimately, OGAS and all other attempts failed to take hold. This was due to a lot of factors, including factionalism and resistance inside the Soviet government. It's interesting to think what the modern web would look like if any of these projects had succeeded.
For an idea of what OGAS may have looked like if fully completed, checkout this map made by u/dom_bul from the ImaginaryMaps subreddit. Note how a series of nodes spread around the nation all connect back to a main computing center in Moscow, as opposed to a more spider-web like network we would see today.
To learn more about OGAS and other Soviet networking attempts, check out my episode on the matter. If you still want to dig deeper, I'd highly recommend "How Not to Network a Nation" by Benjamin Peters.
Website // Apple Podcasts
Often times people assume the US is the homeland of the internet. Funded by the US Department of Defence, the first attempts at a large-scale network were started during the height of the Cold War, and a large part of it's design was redundancy and robust-ness. Some of the researchers were quite frank about it's purpose: to create a network that could survive an upcoming nuclear war. This military-hardened infrastructure was known as ARPANET.
But that's only part of the story, and the US wasn't the first to the party. The fact is, the internet was born during the Cold War. This was an era that saw huge advancements in science, both for better and for worse. The space race put humans on the moon, and the nuclear arms race put humans dangerously close to annihilation. So it should be no surprise that America's counterpart in this age, the Soviet Union, was working towards their own proto-internet.
With the recent release of the Raspberry Pi 4, I thought it would be a good time to go back and look at the system that inspired it: the BBC Micro. First released in 1981, the Micro was part of a largest push from the BBC to educate the public about computing. But, this initiative didn't happen in a vacuum. During the 70s it became clear that cheaply available computer chips would fundamentally change the world economy. The invention of the first microprocessors in '71 paved the way for cheap automation, since a full could be built for a few dollars instead of hundreds of thousands. This quickly lead to large scale unemployment, since many humans could be replaced with a single computerized system.
In the wake of this the BBC started the Computer Literacy Project. The goal of this program was to help the UK shift into the new computerized job market by training the public, both in and out of the classroom. This initiative was composed of educational materials(books, courses, TV and radio series) focused around a central computer. However, as the BBC was planning the project they ran into the issue of choosing a computer. Short on time(from initial proposal to first launch for the Computer Literacy Project was about 2 years) the BBC needed outside help.
Through a harrowing bid process Acorn Computers became the manufacturer of choice. Part of this process was creating a working prototype of what would become the BBC Micro. Due to timing constraints Acorn's dev team would end up having only four days to go from rough sketches to a functioning demo-able computer. And amazingly, the accomplished just that. On short order, Acorn had a contract for 12,000 units that would eventually grow to over 1.5 Million shipped BBC Micros.
An interesting side note is that one of the other companies involved in the BBC's bid was Sinclair. Obviously, they didn't get the contract. The computer Sinclair developed during the BBC bid process would go on to become the Sinclair Spectrum and be a wildly successful and iconic computer in it's own right.
The Computer Literacy Project hit the public airwaves in 1982 with The Computer Programme. This 10 part series would serve as a jumping off point for a much larger endeavour. Over the next 9 years the BBC and its collaborators were able to help shape the curriculum both primary and secondary schools as well as colleges around the country. Via this push and the BBC Micro a whole new generation of programmers were minted.
To hear more about the BBC Micro and Computer Literacy Project, check out my episode on the topic. Special thanks to Neil from Retro Man Cave for sharing a personal perspective on the matter with me.
Website // Apple Podcasts
Initial Computer Literacy Project proposal.
Alburt, Robert, & Allen, D. (1979) Microelectronics
Original rough specification form BBC Micro.
Coll, J. A. (n.d.). Outline specification for the BBC MICROCOMPUTER system. Retrieved from http://www.bbcbasic.co.uk/bbcbasic/beebspec.html
Interviews with BBC Micro development team.
News.bbc.co.uk. (2019). BBC NEWS | Technology | BBC Micro ignites memories of revolution. [online] Available at: http://news.bbc.co.uk/2/hi/technology/7307636.stm
Retrospective and analysis of the Computer Literacy Program and BBC Micro.
Blyth, Tilly (2012) The Legacy of the BBC Micro. Nesta
The Raspberry Pi had been a huge success at its stated goals, and continues to be. But, this isn't the first time a British company would design and develop a computer as an accessible platform for learning programming. In fact, if you've read much about the Pi then you've probably seen people calling it a "BBC Micro 2".
So what was the BBC Micro? What did the BBC have to do with creating a new computer? And how is any of this connected to the 21st century version?
Today I want to share the story from a slice of a somewhat forgotten age: BBC's involvement with Acorn Computers and how they worked together to educate a generation of programmers. Along the way we will see how a small UK company created an impressive series of computers who's legacy may not be known in the States, but has had a surprising impact on the world.
Special thanks to Neil from Retro Man Cave for sharing his memories of the BBC Micro. You can find him on YouTube here: https://www.youtube.com/channel/UCLEoyoOKZK0idGqSc6Pi23w
The IBM PC is, undeniably, one of the most influential computers of all time. It spawned a legacy that goes on to today. Nearly all computers in 2019 are descended from the PC architecture designed at IBM in the 1980s. However, a lot of its spread and rise to power came from outside of IBM. I'm speaking, of course, about PC clone hardware.
Computer manufacturers scrambled to get a slice of the market in the months following the spectacular release of the IBM PC. The PC was an mostly open platform: it used all off the shelf parts, and all the code and hardware design was published by IBM themselves. However, the BIOS firmware used to manage the low-level functions of the PC was copyrighted. So making a PC clone hinged on being able to circumvent the BIOS copywrite.
One of the issues I ran into while working on this episode was finding which computer was the definitive first PC clone. A lot of systems are touted as such, but I couldn't find much verification. It seems like the main issue is that most early clone manufacturers were startups or small companies, so only the successful ones like Compaq lived long enough to tell their story. Complicating that is the fact that some of the early clones used BIOS versions that weren't 100% PC compatible, but were advertised as compatible. Others just plain copied IBM's BIOS and were sued over it, such as Eagle and Cordata. The closest I could find to an answer was the Columbia Data Products MPC 1600. That machine was announced in June of 1982, and supposedly had a 100% compatible clean room BIOS. You can even find dumps of it's firmware and run/test it yourself. However, I couldn't find sources confirming much for that computer, or information on it's design process.
In a "history is written by the victors" type of thing, Compaq has really good documentation of it's PC clone. There is a lot of writing on the Compaq Portable's design process from both in and out of the company. FThe book "Open: How Compaq Ended IBM's PC Domination and Helped Invent Modern Computing" written by Rod Canion, Compaq's co-founder, provides a good narrative of the creation of the Portable including the clean-room BIOS development process. However, it may not be the most neutral source since it is from within Compaq. One thing of note that ties into the muddied waters of PC compatibles in this era is that Rob mentions the MPC 1600 in passing as a incompatible PC clone.
Once we get out of the 1982/1983 era, the clone market starts to be a little easier to parse out. Partly because all the major players are already established. This is also when Phoenix Technologies hits the scene with their licensable BIOS. Phoenix created a similar clean-room BIOS to Compaq but used a few more safety measures. Their BIOS was written by one programmer who wasn't familiar with the x86 architecture, and Phoenix kept a paper trail of memos with all the information that developer had access to. There are also pretty good primary sources on Phoenix, mainly in the form of articles written around the time their BIOS was released(https://books.google.com/books?id=zzAEAAAAMBAJ&pg=PA8#v=onepage&q&f=false, https://books.google.com/books?id=Bwng8NJ5fesC&lpg=PA6&pg=PA56#v=onepage&q&f=false).
If you want to hear more of my take on the early era of PC clones and how it changed the computer market, here is my episode covering it:
iTunes // Website
Today, I want to share with you the story of the first PC clones and how they cemented the rise of the x86 chipset.
Most of this story takes place between 1981 and 1984, but I think it's fair to say that these 3 years are some of the most influential for the PC's rise to domination. So lets start the story with a discussion of the IBM PC, how it was special, and then examine how reverse engineering it lead to the current x86 monoculture we see today.
In this byte-sized episode we look at edge-notched cards. A punch card adjacent technology with a strange connection to the early internet.
What are the origins of our modern day text-to-speech systems? In this episode we will dive into the rich history of electronic talking machines. Along the way I will tell you the story of the vocoder, the first singing computer, and a little about the father of modern synthesized speech.
Now, as the name suggests this is the second part of a series on the history of UNIX. Part 1 mainly covers the background leading up to UNIX. If you haven't listened to it yet, I strongly suggest you go do that now. A lot of what was covered in part 1 provides needed context for our discussion today.
Just as a quick recap, last time I told you about CTSS and Multics, two of the earliest time-sharing operating systems. Today, we are going to be picking up where we left off: Bell Labs just left Project MAC and decided to start their own time-sharing project. What they didn't realize was that this new project, called UNIX, would soon outshine all of its predecessors. But when this all started, in 1969 on a spare mainframe at Bell Labs, there was no hint at it's amazing future.
Many people have never even heard of Unix, an operating system first released in the early 1970s. But that doesn't change the fact that all of the internet, and nearly every computer or smart device you interact with is based on some variant of Unix. So, how was such an important project created, and how did it revolutionize computing?
Today we will dive into the story leading up to Unix: time-sharing computers in the 1960s. This is really just the background for part 2 where we will discuss the creation and rise of Unix itself. However, the history of early multi-user computers is itself deeply interesting and impactful on the evolution of computing.
The original Apple Macintosh, later rebranded the Macintosh 128k, is inarguably one of the most recognizable vintage computers. Even it's design has become iconic: a single 3 ½ inch floppy drive and 9 inch black-and-white CRT built into one small rounded beige box. Even on its release in 1984 it was heralded as a visionary and groundbreaking machine that could even rival the success of the IBM PC. Today, we are going to look at the enduring legacy of the Macintosh and answer the questions: what did Apple invent and what did they borrow, and are all interfaces that follow clones of the Macintosh.
A lot of newer technology doesn't expressly say it's going to "revolutionize the human experience", but sometimes, that line may actually be closer to the truth than you would expect. Today, I am going to tell you about a time when that was very much the case. Today we go back to 1968 to look at Doug Engelbart's "The Mother of all Demos"
You can watch the entite archve of the demo here: http://www.dougengelbart.org/content/view/209/448/
Today, I want to share with you a technology that shambles among us as a corpse that refuses to die. That is, of course, the punch card. In this episode, we will be talking about the storied history and influence from beyond the grave of the punch card.