Hacking on the PDP1 Raspberry Pi Emulator - Computerphile

Añadido: 2026-05-11

[00:00:00]First we will look a little bit into the history of these machines and uh we uh we use the PDP1 here as sort of our central uh starting point. The PDP1 um designed in like the 8 the late 50s 59 uh sold starting in 1960 and about 50 were built and sold by deck. Um, and I think it's a very good uh starting point to explore this whole history if you're interested because um, we then have a couple of PDP models branching out from this, but there's also a history to the PDP-1. So, >> so the deck is a digital electronics corporation.

[00:00:39]>> Digital equipment corporation.

[00:00:41]>> Equipment corporation. Okay. And they were obviously a computer manufacturer in America.

[00:00:44]>> Yeah. They didn't call it computers back then because that evoked uh notions of IBM style like payroll business machines very hard to access like you give your punch punch cards to someone and so on and these are uh a different tradition very interactive and more personal and the PDP1 uh was sort of the first one that you could buy in that lineage.

[00:01:12]The PDP1 was an 18- bit machine. You can see it here. 18 bits and 4 kilows of memory originally. So a word is again 18 bits. Didn't have any bytes yet. That came in the mid60s. So after the PDP1 which was a little bit more experimental. Deck was a startup essentially at that point. When they had more customers, they had different needs and the company was expanding. So the first model after the PDP1 was surprisingly not the two or three. That was like an old business strategy that didn't pan out. Um, but it was actually a PDP4, uh, which was also an 18- bit machine, but not really not compatible with the PDP1. Like they had the same peripherals to some degree, but not quite. And they reused these uh, architectures again.

[00:01:59]They built new machines that were more or less compatible. So the seven was the next. And that one is perhaps a bit famous for being the machine that Unix was developed on by Ken Thompson. 1969.

[00:02:10]Uh they again built in a machine in that uh family the 9 and the 15. Uh we're not going to talk about that.

[00:02:19]>> Those just kind of different capacities or >> Yeah. So essentially they they rededicated like they flipped one bit from being an address bit uh from being an instruction bit to being an address bit. So you get 8 kilows of memory on the PDP4 and in this family, but you get only half of the instruction space. Um, and so in Unix, uh, you see that, um, because the kernel has 4 kilobytes of memory and the user has 4 kilobytes of memory and with a PDP1, you would only have like 4 kil time sharing on a PDP1 was done a bit differently. Um, >> so yeah, kilows is a new one to me, but I >> Yeah, people are not used to kilow, 24 words then.

[00:03:00]>> Yeah. Okay.

[00:03:01]>> Right. Um so that was uh sort of the first thing that uh uh that they built and afterwards uh came the PDP5.

[00:03:11]>> What sort of things were these used for?

[00:03:12]Were they were they what who were their customers?

[00:03:15]>> Um so the idea initial idea was to make a more a cheaper uh PDP-1 essentially and also use it for things like process control lab equipment that sort of stuff. um things where the computer is part of a system and not just the system itself crunching numbers like uh like a mainframe would do uh like doing scientific I don't know weather simulations or whatever and eventually you you'd have uh the result but it was something that you know talk to talk to the real world >> and so there was a smaller uh uh family um which is kind of a stripped down 18- bit family condensed into 12 bits.

[00:03:57]That's the PDP 5, 8, and 12. Uh so these are very minimal and really just to like more more of the lab equipment type and uh process control even though people did time sharing and such on the PDP8 as well. Um and it's a very popular machine. There's a big PDP8 fan community. Um and the PDP8 was the first uh that Oscar made. And on the other end we have the PDP 6 and the PDP 10. So the PDP 6 and 10 uh were 36bit machines uh meant for time sharing such that multiple users could use the machine at the same time. Also sort of designed to run lisp well which was a popular programming language uh in AI circles and around MIT where these machines came to be. Um, and yeah, so so that is like the the on the wide end of the word size 36 bits.

[00:04:58]>> I'm just going to ask a question if that's all right because obviously you've mentioned the word AI, right? And we're now talking about the 1960s. I mean, this is, you know, become massive nowadays, but it isn't this, you know, what we're going through now wasn't the start of AI, was >> right. uh AI at the time at that time meant something like um symbolic differentiation or chess programming um stuff like this um so symbolic AI good oldfashioned AI not the neural networks uh I mean the neural networks uh go back quite some time but this was not really what people uh did because the computers weren't there yet so this is sort of the uh the PDP family and there's one important piece missing which is the PDP11 introduced in 1969 like around uh 70 and this kind of uh pulled everything or almost everything together a bit. So uh it's a single architecture that is uh that has small machines PDP 1105 for things like what a PDP8 would do maybe um but also bigger machines um maybe a PDP1140 which ran Unix or on the bigger on the higher end a PDP170 which was quite um yeah quite a capable machine.

[00:06:15]Um it did not quite replace the the PDP 6 and 10 uh style machines. Um but they later uh built the vax the like a 32-bit reinterpretation of the PDP11 but this was 16 bits and so they had this these two uh as their flagships uh essentially and this became like ancient history which is why people don't know so much about them anymore. And these are very familiar. These have bytes like bite addressing which people take for granted these days but these don't have bytes yet. These are all word addressed. Um >> so that those B I mean they they were pioneering machines those ones but basically we're going to have a look at what came before.

[00:06:58]>> Yeah. I mean everyone was pioneering at the time had no choice but uh yeah people had to figure out uh what computers should be like. Um, for instance, Gordon Bell, who was the architect on essentially all of them except for the PDP1, uh, said this this 18- bit line was a mistake because it was not compatible with the with the 18- bit PDP-1 and they didn't, uh, appreciate the like portable software yet, being able to run, >> being able to write, >> right? they they thought oh well you just write the program for the new computer and then but yeah uh software quality like the the value of software was not uh was not on people's minds apparently back then >> and and I suppose um when I say pioneering I think I guess I mean they laid some of the foundations that we still use today but yeah >> yeah like the PDP11 uh and vax are like very normal computers from today's stand points of view you can you can read PDP10 assembly or vax assembly and it's it's not too foreign. Whereas when you go back to these older machines, it becomes a bit less familiar. Um but on the other hand, they are also very simple. Uh like the PDP1 is not a complicated machine for instance. Um so you can still understand it. It just takes a little shift in the perspective perhaps.

[00:08:14]>> Mhm.

[00:08:15]>> And so there's also prehistory which we're not going to cover, but the PDP1 had uh was preceded by the TX0 and these were one of machines. Now that we're talking about, these were like production machines that were sold, even if maybe not too many. Um, but the earlier stuff only existed uh once. So the TX0 was also an 18- bit machine, but much simpler than the PDP1. Um, there is also a TX2, which was a bigger uh 36-bit machine uh famous for being the machine that Sketchpad uh was written on by Ivan Sutherland. uh the uh first CAD system, you might say. Um and this it goes uh back a little further to the memory test computer which was really part of project whirlwind.

[00:09:08]So whirlwind one was there was that machine um originally to do um cockpit simulation but it didn't really pan out and they built a digital computer instead. uh I call it the first uh microcontroller except it took up a whole building but essentially that was the idea to have a computer that interacts with the real world. So this is where it starts.

[00:09:32]>> What what era is that then? uh well when one was operational more or less or became operational during 1950 and >> so it's kind of post-war kind of things >> right they had difficulty with uh finances because the war stopped and uh well luckily for them the cold war started so they got money again >> and uh that is how the whirlwind 2 you might call it but it's perhaps better known as the computer of the sage system uh the an FA Q7 um that was like a a bigger version of the whirlwind one essentially built all over the US for airspace monitoring. Um it was never it never really had a purpose because shortly after they had intercon uh intercontinental uh missiles and like they never got to use it essentially. So yeah, this is uh the the history that we're talking about and the whirlwind one was what what core memory was invented for here. We got modems and like displays were already were on the whirlwind and this kind of uh goes down into the tree. So we have this whole uh history of interactive controller type um personal perhaps uh computers. And so again the PDP1 is uh sort of our central piece here and uh we will now look a little bit into what the computer how it works and what to do with it how to use it using the PDP1. Um we're first going to look a bit at the front panel, what it shows and how to use it. And then we'll use it to uh draw the circle uh that uh uses the algorithm that Marvin Minsky discovered. Um and also the Minskyron which is based on that uh algorithm which is a very uh nice looking demo and it's also you can play with the switches and uh it's very satisfying to play with. So what you see on the panel, all these lights are almost all of the state that the the PDP1 has. All the internal flip-flops are visible as lights on the panel, which you need because if the machine isn't working, and back in the day, the machine was not working quite a bit. Um, you have to make it work again and you have to see uh the machine state. Um, this panel doesn't have all the lights.

[00:11:59]there was an IO panel and peripherals would have more lights and so on. But this shows everything important really.

[00:12:06]So we have two registers up here, the program counter and the memory address.

[00:12:10]Program counter is the same as you would expect today. It's the address at which to fetch the next instru instruction.

[00:12:17]Memory address is the register that holds the address for the memory word that is being addressed by the computer.

[00:12:25]So it's just an address and the memory buffer is the data that either came out of memory or was written back into memory. So at the end of a memory cycle uh the MB register would show what is in memory at that location shown at memory address. And the accumulator and inout register are what the programmer uses.

[00:12:45]And as you can as you can tell from the name in out is also connected to the uh peripheral equipment IO stuff. So the accumulator is the arithmetic register that control with with your program uh more or less and IO was also used for uh like as an auxiliary register also when we display a point it will be x and y coordinates one register is x one is y and uh the address in the uh in the basic machine is 12 bits here but we have a memory extension we can use up to 64 uh kilohz 12 only gives you 4 kohz and uh 64 kil other words for the maximum what a PDP1 could do. So here we have uh like a run light and a cycle light and so on. These uh run is obviously when the machine is running it's not running yet. And this is internal flip-flops that we're not going to uh go into in much detail. Uh the power switch obviously turns off the power and on again the sense switches could be used by a program just to read like general uh inter user interaction.

[00:13:47]you can read them and the program flags are kind of similar. They can be set and read by the program to its will and they can also be connected to some uh peripheral uh equipment like when you uh use the light pen and it sees a spot uh it might uh light uh set the program flag for the pen here. Uh and we have the instruction register so five bits that encodes the instruction. So now let's uh put something into memory. We have the Minsky circle algorithm here.

[00:14:16]Um, it's not a lot of words. And we have the symbolic assembly on the right here.

[00:14:22]And I just wrote down the binary code, an octal, uh, that encodes these instructions. So, um, you have to know octal, of course.

[00:14:34]Oh. Oh, and on the left we have the the address where this where we put this into memory.

[00:14:38]>> So, because yeah, just to remind me, that's base eight, isn't it? Octal. Is that right?

[00:14:43]>> So, three bits are one octal digit. It's very easy to u like it it's very quick uh to get into really. So if you have the upper bit that's a four. If you have the middle bit that's a two and if you have the lower bit that's a one. And so if you have multiple you just add them.

[00:15:00]So that's five. And at some point you just don't think about it anymore. You just read octal and toggle in binary or you read binary. Um so let's do a couple of instructions manually with the front panel. We start at address 1 0 0 and the word that's supposed to go here is 7 all up six which is four and two one and the rest zeros.

[00:15:26]Now uh pressing deposit up uh puts this into memory. We see memory address 1 0 0 and memory buffer 7 6 1 0 0. Oh, actually I made a mistake. That's the second instruction. That's no problem. We could just change the address and put it in location 101 instead. Easy. But now we have to do the first instruction of course. So that is two 0 0 1 1 3.

[00:15:58]So 2 0 0 1 1 3. Uh so you can already tell it's easy to make mistakes and that is why I don't really want to do this on the front panel so much. It's very tedious. Um but just to make sure uh that we also check the examine uh switch. Let's look at our previous previous word and uh press examine. And then we see our six uh 761 again. So now let's do the rest not on the front panel but actually using the debugger DDT. DDT is the debugger and it's uh it's an insecticide. So a debugger. So I have DDT mounted as a paper tape in the reader. It will be above the front panel here. We have it on screen. Um and when you press read in the machine knows the format of the tape and goes through it and you can see the address being counted up here where things is things are being put into memory and eventually it's going to jump into DDT.

[00:17:02]Okay. So now we're interacting with a typewriter here.

[00:17:06]>> Would that have been the sort of speed a paper tape to to run or is it?

[00:17:09]>> Yes, it's the original speed like uh there are different numbers given but uh 400 lines per second is is about right something like 300 400. Um okay so now let's confirm that what we have put into memory is indeed correct. So uh at address 10 0 0 we have exactly the instruction uh that I wanted to put there. And by pressing backspace we can check the next one and equals gives us the octal.

[00:17:41]And so now I just do the rest. Um I can do sum in octal directly. This will be the next instruction.

[00:17:52]and and the next one and the rest one uh the other ones I will just do symbolically because that's something DDT can also do. So we are now at 104 and that is supposed to be DAC 114 deposit accumulator. Okay, so now we finished uh putting this into memory using DDT and we see um by examining uh successive locations that uh we have this code in memory now which is the one that I want to execute. DDT was quite popular on other machines as well. There is a whole tradition of these interactive debuggers. It doesn't start with DDT but uh DDT is fairly wellnown.

[00:18:34]Okay, so we now finished putting the program into memory. Uh we can examine the memory locations with DDT and we see the code which is the one I uh wanted to put in there. And now we want to start this program. Uh one way to do it is with the front panel. So we stop DDT because we're still running. So run is now off. And we put in our start address which is 1 0 0. Hit start.

[00:18:58]And there we see the circle.

[00:19:00]>> So what's happening there? It's kind of the equivalent of find a point, print a dot there, move a bit, print a dot there. Um right it starts with a single point and essentially with a little bit of uh approximate trigonometry you you would move the point uh with a small angle but if you approximate it it spirals out because it's just an approximation. So Marvin Minsk's discovery was that uh you don't calculate the new point from the pre previous point but that the x and y coordinates are sort of linked and if you do the math you find out that it actually remains stable. So that was a very cool discovery and there is a program called the Minskyron obviously named after Raminsky which is three of these circles kind of linked together.

[00:19:47]So one oscillator is is connected to the second one, the second to the third, and the third one again to the one to the first. And you have settings on the switches which control them. And you have a very cool demo. And this is exactly what we're going to do now. So um we we'll put the >> So this is where we use the magic of the emulator to load it back in. Right.

[00:20:11]>> Right. Uh oh, actually no. Uh let's do one one thing first. We want to perhaps punch this onto paper tape because we like this program and want to run it again without toggling it in again. So, we go back into DDT, which is at 600 0.

[00:20:26]So, stop the machine, start there. We're back in DDT. And now we uh punch a tape.

[00:20:32]Uh we start with a title, capital L, and we might call it circle.

[00:20:38]And we see it punched on the paper tape as >> as just so you can read it. Uh, >> so you know what that tape is, >> right? With tap, we go into punching words now. And our words start at 1 0 0 and it goes up to 114.

[00:20:55]And now we see the words being punched.

[00:20:57]And we just have to give it our starting location now, which is 100 or 10 0.

[00:21:02]There it is. And now we can like rip off the tape. Uh, which we do with the emulator here. Uh, >> so you're basically saving that, right?

[00:21:12]program.

[00:21:13]>> Exactly. So, we now storing that the file already existed. It's fine. So, uh we now have our paper tape which came out of the machine and now we want to put it back into the reader. So, here we go. There it is. And obviously, we still have it in memory, but it doesn't really matter. So, just read in the tape goes in and it jumps into the circle program.

[00:21:36]>> Ah, so that last instruction on the tape is basically run, >> right? It it just executes the instruction from uh from paper tape really >> and on the tape I think we've done a video on paper tape and computer file before but each line is basically some code is it >> yeah one word is three lines and there's different formats like readin has a special hardware format but it's not the most space efficient and so there's more efficient loaders but yeah uh but that's how it works and that's how you would perhaps program the machine and punch a program onto tape and Yeah, very interactive and nice to use. Um, you could of course use an assembler, but that's a bit more uh involved. Okay, so now let's uh go into the Minskyron. So we uh load this demo tape here and read it in. Takes a while.

[00:22:28]Uh that's the snowflake, but we don't want that. Uh we want Minskyron. It starts at 5 0 and it needs some initial switches. If we if we start like this, it's just very noisy because all these shifts that are done in the Minsky algorithm which is a very easy division by a by a number power of two number um we can set these shifts now. So let's just try something.

[00:22:53]>> So you just randomly well >> more or less random. I have some intuition but not too much. Um but you can see how we have this feedback between these three oscillators now.

[00:23:04]>> And if you observe it for a while it will go crazy. Or if you change the switches you can just change them and hit start and you get a different pattern. And you can you can really have fun uh exploring all these possible patterns here. And sometime like this is the the typical display after after some time it was would just go crazy.

[00:23:25]>> Say PDP1 you're drunk go home.

[00:23:27]>> Yeah exactly.

[00:23:29]Uh but it's very very fun to explore for sure and I can really recommend doing that. There's a very good website where you can do it as well. Um Masvak Minskron. If you Google Minskron you will find it easily. Um so kind of in a chaotic mode right now. Let's see.

[00:23:50]But yeah, this is this is what you can do with a with this very simple circle like just goes character by character.

[00:24:04]So we get that uh compare against the uh end of the string marker and uh until that is the case we just uh print the character on screen. So to see that in action, uh let's call the B command and give