Hello folks, welcome back to our IBM 1401 exhibit. Our dinosaur computer from the 1960s. This is Mike Albaugh, and we are with our 1401 exhibit, here using the machine we call the Connecticut, and we're going to attempt to compile a Fortran program? Right. And this is the first example in the manual, and we figured that was as good as any point to start. Alright. OK let me take it from another angle here, so we see the cards. I'm missing a card, wait. Oh! We need to load the tape. And we have been laboring for... A month? (Laughter) A few hours a day. A few hours a day. The tough part was to remake the tape of the Fortran, but we think we have made a good one We don't know. We can hope. So, we're afraid the beginning of tape marker fell off the tape, or we didn't see it. In which case the tape will rewind and go off the reel. There you go! Oh! It was in there. All ready. Cool! Right. Wow! It read... it read a few records, and then I saw the tape move, not the reel but the tape. It got a reader check. Oh! That's good news. It means it wants to read something. And, it's not reading the other cards. It's not reading them. It wanted to print something, that's why it stopped. Oh yeah! That's working. That's chooching over there. It compiled? That's the listing. It lists as it reads it into memory. It read it. Well that's as far as we have even gotten, eh? So what's the next step? The usual last card restart. Ah, OK. I should have put a blank after that. Wow! And? Lots of red. Oh, whoa, we have a whole bunch of red lights here. Yeah. Houston, we have a process error, a reader error, a storage error. And a B and an A register parity problem. Well this is as far as I've ever gotten, Michael. This is pretty amazing! And this is the instruction it was trying to run, and it got a - it's a three? It's an "L". Oh. It was doing a load, which could be a tape read. What the heck is that? But - yeah. We have the little character cheat sheet on that one. What is "B, A, 8, 2, 1?" So the character we have down here is a "B, A, 8, 2, 1", Which is a dot, which Michael, who speaks fluently 1401 assembly, says it's a Halt We have "B, A, 8, 2, 1", So why do we have a parity error? It should have this bit on. It should, well, anything in memory should be an odd parity. And then we have - so this bit, which is parity bit, should be on, and it's not, and then it went "ugh" that's not a good number, and we've got the process error, and the storage error. Everything went haywire. We can do the time-honored thing that customer support always tells you to do: try it again! It's a op code 1 which means read, but... Here we go There we go. OK. How come it didn't read the tape program? Oh, it did! We've a reader check for the last card Oh, hey, it's compiling! It is compiling. It's doing something. All right. Reader, stop. It stopped. Finished. I think, if I press start, it will run. Yeah, it finished compiling, went to a halt. It's doing something. *Printer noises* It did it. You got it! Printing numbers. What is it supposed to do by the way? I forget at this point. It's been a couple of months since I typed that in. It's in deep trance here... It's calculating hard. It's a very very slow machine at doing scientific calculations. So Fortran is really a stretch for the 1401 I mean, it's totally amazing that they were able to put it in there. *Printing noises* It's calculating a table of something. And it just halted. Michael I think you did it. Successful compilation and running. Why don't we look at the output? Oh, I don't know, but OK, sure. Start of FORTRAN compilation. Okay. That's the one we got, that's fine, with the parameters. Machine size specified is 8,000 meaning characters of storage. Actual machine size is 16,000. So we are maxed out at sixteen thousand characters Yes! We've the biggest meanest machine around. And that's the listing of the program. And you still don't remember what it does? It says matrix arithmetic. Alright. Okay, and then the result of the compilation it says, I believe, 800 input characters, so the whole program. Modulus is 5, that's the size of integer variables, mantissa is 15, the size of the mantissa of a floating point variable. Then where the variables are stored in memory Assignments, blah blah And then that's the end of compilation Press start to go! Oh wow, there's a user interface in this thing. Oh, it's a Hilbert matrix. It takes the matrix, does inverse, multiplies it, and inverts it a second time. Oh-ho! Pretty cool. And - It takes a little longer than your iPhone would if your iPhone had FORTRAN. Oh, it does?
Yeah. Wow! That's it! Congratulations! I didn't think it would go that far. That's pretty cool. What program did you get? Did you compile something? Yeah. Here is the listing. You're kidding me? No! My goodness! These are examples one and two from the manual the first comments on page whatever of C24 dash whatever So, how many decades did it take to run? No, it was pretty quick actually. Not bad considering a 90 kilohertz machine. Oh my God! I can't believe this. Look at this. Floating point numbers. Floating point! Did you ever imagine floating point format out of the 1401? I'm not only imagining it, I did it. It wasn't an IEEE format, wasn't it? Actually IEEE format didn't exist then! Alright. So how did you get the big records? Well, that's complicated. So one of the most difficult steps we had to go through to revive the Fortran compiler was to create a tape of it. And in order to understand how we did that, I have to show you a little trick that we use. So if you go to the back of our tapes here, you will see that, one of the connectors - this is a regular one - but this one, looks like it has a suspiciously modern cable attached to it. And it goes to a black box here, and this is our tape emulator. Let me show you from the other side. So here - pay no attention to that evil computer. It just allows us to send commands to the tape emulator. So this guy is the other side of the box. I can open it up. And... You have serious hardware in it. Designed by a few of the restorers. And so, this hardware pretends to be six vintage tapes to the 1401, and you can see the interface here on the computer. Right now I have three open, and you can do as you would expect in a real tape, right. You can load it, you can change density, you can start it and basically, what that reproduces is the same array of buttons that we have over here, on a real tape. To give you an idea of what's in the file that's the executable mounted on tape one. Merge program over here. Upload - Rewind. Start. This is the data So this is the original tape formatted in a way that the tape emulator understands it. Load - rewind, start. All right, both at 0. So, we're trying to recreate a new FORTRAN tape. A real tape from an emulated tape Step one is to put it in. And you have to wind it past the Beginning Of Tape marker. If I can - there it is This guy, that's the Beginning Of Tape. If I'm past that it will rewind and find the load point when it gets on the reflective marker All right, load rewind. There you go. It's loaded. Start. And then we make it tape number 3, so this is going to be a real tape number 3. There we go! So now it's working. It's writing on our tape. Printing it. And then we should see it on the emulator advancing, yes, at record 1093. 1122. So it's executing this program, taking the data from this emulated tape, writing it to this real tape, and having a bowl printing what it's writing. Which we didn't really want to happen, but you know... Actually hat's not bad. So that's the FORTRAN tape. This is a pretty darn complex program. It's listing it as it's writing on the tape.
Right. So now that we have recreated the FORTRAN tape, we are not done because we need to recreate the source deck, and we didn't feel like punching it by hand. So here it is, the source. And you can tell it's a short FORTRAN program with a little auto-punch program at the beginning of it. So we'll get the 1401 to punch it for us, and that's the self-executing tape that will punch the card deck. Upload file, load rewind, start. OK. Back to the real machine here. Two ends to the 1402. That's the reading end, and that's the punching end. All right, so... Now we're going to punch a set of cards.
Oh wait 12 edge.
Yeah, so it's 12 edge on this side, and 9 edge on the other. Yeah, because they're supposed to be able to mix in one pocket, they want to be both facing the same way. So now we are going to do similar thing is, load the emulated tape program and have the 1401 punch a FORTRAN source card deck. Recreate, right. We're punching! So the blank cards go here. Woops, it's already done. And the fresh deck is over here. These have holes in it? It has holes in it. I'm checking whether the card says "end". And it seems to. So that's the end card of the FORTRAN source. Okay. Yes, so the 1401 punches real fast, but doesn't print what it has on top of it. Let's go duplicate some cards to see what's on it. So the first card should be parameters? Yeah, like the options for the compiler. Right, so what Michael is going to do, he is going to duplicate the cards on the 026 and the 026 has a printer on it. So it's going to reveal what it actually has. And it says... So yes, the first card here just shows the duplicate. So now we can see what's on it. It says param I 990 0515 Can we get a FORTRAN statement? So basically it's one FORTRAN statement line per card. Might be another comment. It does look like another comment. And it says... Matrix arithmetic. We should be getting into actual code soon. Probably a "dimensions" or something like that. Yeah, that's real code. And yes, so that's declaring our arrays. Finally, we have a FORTRAN statement here. Dimension A 77 vector 7 B 7 7. All right! Cool. So the whole deck is like this and then the last one is an end card? That's the end card. So, one parameter card, then the whole Fortran thing line by line, and then an end card, and that's the source code, that's your file. Now we can go try to compile it. Source code over there. I have to make tape - this tape one, right? Yeah So this now is the real thing, tape one, which I actually have to rewind. Okay, so, we rewind our compiler, our freshly made compiler. I have to unhook the emulated one. So now we're back into a historically correct state. I don't need the emulator anymore. Unload. Clonk. Gone. So this guy, all that modern, ugly stuff, that's not counting anymore. We are going to do the real thing. All right! Do we have the printer ready? It's all good. All right. Com-pile. Is it waiting for the reader? Yeah, it's waiting for the reader. Reading the cards. You get the last couple cards. Okay. And now it's compiling. Machine is working pretty hard. And so it does it one pass at a time, and so it's reading the passes right here. Sixty-three passes. It just read another pass. And it's rewinding, it's done! Alright, so now we're going to run the program by pressing start. And... It is calculating. Here you go. That's it! It did it. So, it took a Hilbert matrix, inverted it, that took it a while, then it multiplied both and got identity, it's all ones on the diagonal, mostly, zero otherwise. Mostly. And then it inverted it another time. And that was the end of the FORTRAN scientific demo.
and here I am coding in Fortran in 2020, using F2008 and crying for the simplest syntax errors
That was a really interesting video. Extremely cool stuff and admirable dedication to preserve the beginnings of computing for posteriority!
Where’s this? CHM?
Fun. It takes me back. In college we had an 1130 and in my first job after college we had an RCA Spectra T-70 which ran a 1401 emulator for the jobs that had been run on a 1401. We also had a physical card sorter also running production jobs. That sorter had to have wiring changed on a sort of bread board each run.
EDIT: the 1130 had an APL compiler and keyboard which did a fine job with matrix arithmetic.
Does it run Crysis ?
I remember working in a place that had a ton of similar machines that were still used. Could never get my head around how you worked on them without the ability to see what's happening on a monitor.
One of the most impressive things about this to me is the tape reel servos; they're slinging a lot of mass and stopping on a dime.
Also interesting is that the tape runs down into a vacuum chute for tensioning.
How many tape drives were required, and how many passes did they need to make? Conceptually, it seems like it should be practical for even a small machine to get by with one read-only and one write-only tape drive attached to the compuer, along with a card reader attached to a write-only drive, and a printer attached to a read-only drive, using the sequence:
Having a second read-only drive to hold the compiler and/or patch loader could improve efficiency by eliminating a tape-swap step and also eliminate the need to store redundant copies of the patcher code on the executable-jobs tape. On the other hand, even a minimal system with just one read-only and one write-only tape drive--both requiring manual rewind--would seem like it would be capable of handling a large volume of jobs efficiently if they all used the same compiler.
One of my first languages but on a 1620