"A Solution to Computer Bottlenecks" - Science Reporter TV Series

Search transcript...

INTERVIEWER: Which serves more than 40 New England colleges and universities. The heart of this center is this IBM 7090 high-speed, general purpose, digital computer. In addition to the routine work which takes place here, experimentation is underway to develop a new technique of computer usage called time sharing. At consoles like this one, located in laboratories and offices throughout New England, hundreds of people will one day be able to use tomorrow's computer simultaneously.

This man had been using the computer to solve a relatively simple mathematical problem. And while he thinks about what he wants to do next, the computer is busy working on someone else's problem. In this way, scientists hope to break one of the major bottlenecks in the use of computers.


Hello, I'm John Finch, MIT science reporter. I guess most of us are aware of the fact that the computer has come to play an increasingly important role in our everyday lives. It processes the checks that we write. It handles our payroll. And it even keeps track of the availability of airline reservations. But in addition to solving our problems, the computer has also generated some new problems of its own, most of which revolve around the relationship between the man and his machine. I'd like to have you meet Dr. Fernando J. Corbato, who is the Associate Director of this center. Dr. Corbato, maybe you can tell us about some of these problems to put this whole business in perspective for us.

CORBATO: Well, to do that, we have to go back about a decade, about the early 1950's, when the real problem was to try and put together computers of this size and speed.

INTERVIEWER: You have to get computers to work.

CORBATO: That's right. They were pretty unreliable in the beginning. And they had to be-- or people were afraid they'd be unreliable. They managed to lick all those problems. By about the middle 1950's, they were being used very heavily already.

INTERVIEWER: So what would've been the next problem?

CORBATO: Well, the next problem was that of communicating with the computer. The computer basically only understands numbers. I mean, you put numbers into it, and these represent something. Well, the next major improvement was in the language that one talked to the computer with.

INTERVIEWER: You can teach the computer to understand English?

CORBATO: Well, no. But we can actually put a particular synthetic language, which is largely technical, and which is, to some extent, algebra 2. And this jargon, which is understandable to a person, is much easier to work with than numbers.

INTERVIEWER: I see. So once the-- you're able to talk to the computer, then what next?

CORBATO: Well, the next major problem is that of the ability to interact with the computer. The man machine interaction is very poor. Now, this largely stems from a problem of the fact that we must put only one problem in the computers at a time, fundamentally.

Now, in the process of trying to put one problem in the computer at a time, in the early days, we wasted a lot of time putting in each problem and taking them out and then bringing in the next man.

INTERVIEWER: And these computers cost a lot of money?

CORBATO: Yes, indeed, they do. They are between $300 and $600 an hour.

INTERVIEWER: So you don't want to waste time?

CORBATO: No, we don't want to waste time. So we, as most other centers, have resorted to a procedure of batch processing.

INTERVIEWER: What is that?

CORBATO: Well, we combine a great many people who want to submit a job to the computer on a single input magnetic tape. Now these magnetic tapes are made using computers, such as this one here. And they're prerecorded. Then they're taken to the main computer and used as an input tape through the main computer.

INTERVIEWER: Oh, I see. So you solve everybody's problem in turn?

CORBATO: Well, in a batch. A group of people are like catching a bus. And the computer calculates this batch through, and produces an output tape, and then the output tape is brought over to the computer, and the results are printed out. Well, as you might imagine, this takes a few hours to get anything through the computer at all.

INTERVIEWER: So that raises more problems?

CORBATO: That raises a lot of problems. And people are very frustrated with this type of interaction.

INTERVIEWER: And what are you planning to do?

CORBATO: Well, what we are trying to develop is a new scheme of using the computer, which we call time sharing. Which consists of attaching a large number of consoles to the central computer. It's a little noisy out here. I think it would be a lot easier if I could explain to you in my office how to use one of these where I have one remotely attached.

INTERVIEWER: The idea, I gather then, is to allow a whole lot of different people to use the computer all at the same time.

CORBATO: That's right. This is one of the consoles they might be using in the future.

INTERVIEWER: It looks very much like a-- just a regular typewriter-- electric typewriter.

CORBATO: Well that's right. That's what it really is. It's a small amount of electronics in the bottom. And it's attached to the computer. That's the real distinction.

INTERVIEWER: So you might have one here in this office, and I might have one, say, in my office, and there might be one in some university? Something like that?

CORBATO: That's our hope. We think that can be done.

INTERVIEWER: How many might you have all together?

CORBATO: Well, at the moment we're just working with a-- at the very moment-- five. And in a few weeks, we should be up to about 20. And ultimately, we'd hope to see hundreds. But we'll probably have to have a better computer before that.

INTERVIEWER: But I still don't understand how all these can be using the computer at the same time.

CORBATO: Well, to really explain that, I have to backtrack a bit, and talk about a little bit about how a computer really works.


CORBATO: Let me show you. We're at the blackboard. First of all, let me explain just for a moment what a program is. I mean, how a computer really works. I'm going-- the computer's organized around a large set of pigeon holes, which you might say is really called the memory, usually. And each memory-- the memory consists of these various cells-- or pigeon holes-- which I can put a number into.

Now the computer, say, has particular numbers in each cell and it's very hard to read this way, of course, but some of the numbers represent instruction. And some of the numbers represent data. And the person who prepares these instructions and data is the one who keeps it straight what they are.

INTERVIEWER: I see. Those numbers might not mean numbers, as such. They might mean to add something in one pigeon hole to something else in something-- other pigeon hole.

CORBATO: That's right. There is-- some of them are instruction, some of them are data. Now, the real computer, in the sense that the-- oops-- device that does the computation is a central processing unit which has calculating parts. And this is usually called CPU.

INTERVIEWER: That's where the work is actually done.

CORBATO: That's right. This is the device that really does the work. And it is able to operate on one instruction at a time. And it does-- the arrangement is that it does first one instruction, then the next instruction, whatever that one might be. And keep doing instructions. And then some of the instructions cause the program to go back and loop. Now, this collection of instructions, as I just said, is called a program. And they do a particular job or-- and somebody has to prepare them in advance.

INTERVIEWER: How do you get it into this memory?

CORBATO: Well, normally one is read it in from punch cards, or something of this sort. The-- and this comes back to the problem of how to use a computer. In the past, what we used to do is we have a computer-- the 7090, for example, and we used to read them in by card. But then we got a little more worried about efficiency. And so we now read them in from magnetic tape which has been prerecorded.

Now, this calculates inside the computer, and it's just one problem at a time, remember. That's the problem. And after several minutes, the output results are accumulated on magnetic tape, and they're taken over to another computer. Printed later. Now this is the older batch processing technique.

INTERVIEWER: One problem at a time.

CORBATO: One problem at a time. And it's pretty clumsy. Because of the weak interaction between the man and the machine. Now what we're trying to do is superimpose on this, a set of parallel consoles, which are not all near the computer, in fact. In fact, most of them are remote. And let the users use these with a reaction time of a few seconds rather than a few hours. It takes a few hours to get through this path because of the batching and queueing, and it takes, we're hoping, and we're actually able to do at the moment-- a few seconds. We'd like to get it down to a fraction of a second eventually.

Most of these are typewriter consoles, much like we saw. And we actually are getting to 21 consoles. Eventually we'd like to see graphical display on this kind of a console. There are technical problems still. But, as an experiment to get-- to try out some of these more elaborate advanced ideas, we actually are trying to tie two small computers to this one. We have one PDP1 computer of the DEC corporation. And we have also a 1620 computer of the IBM corporation.

These are more experiments, but they're a little too advanced to explain today.

INTERVIEWER: Well, I can see now what you'd like to do. But I don't see how you do it.

CORBATO: OK, well I have to go back a little bit more. Let me come back here to the same drawing of the memory and the processor and which can only work-- be at one place at a time. Now let me redraw this a bit. What we have, is we actually have one master program, which I'll call a supervisor. And this is the program that is going to run everything. And normally this computer, when it's in the time sharing mode is operating a program in the supervisor.

We also have a program for each of the typewriter users. So, U1, U2, U3, U4, and so forth.

INTERVIEWER: They might not be the same size as you've indicated.

CORBATO: No, they're not all the same size. That's quite right. That's what I meant to try and convey. Now the consoles have to type in to the computer. And they type into the supervisor and back out. So the messages are handled by the supervisor for each of the programs. Now the supervisor is going to relay these messages to the particular programs as they are-- and keep track of which user's talking to which typewriter, of course. And so forth. And this would be straightforward enough, except that, quite often, we'll get more programs than we have room for here. So we have a problem.

And what we have here is another device called a disk-- magnetic disk memory. Which I can illustrate this way. Of course, just schematically.

INTERVIEWER: It's a big whirling disk in which you can put--

CORBATO: That's what I meant to suggest.

INTERVIEWER: --whole lot of tape.

CORBATO: Right. Well it's a magnetic material much like magnetic tape on the disk. And it uses essentially a comb of reading heads to read material off the track like a phonograph, pretty much.


CORBATO: It has a very large capacity. Here we're talking about nine million words of computer memory. A word is basically the information of six letters or 10 numbers. This is the kind of thing we're talking about. The basic memory of the computer is 65,000 words. So this gives some idea of the scale that we're talking about.

And in particular, the supervisor can cause programs to read back and forth from the disk memory. So this is the magnetic disk memory. And we are keeping all the old programs of the different users on the magnetic disk. As well as-- woo, the chalk. A little soft.

INTERVIEWER: That's where the supervisor tells the magnetic disk to put something into the active memory over here, or this regular--

CORBATO: So it's playing a juggling game, to some extent, keeping all the right programs in the right time. But I still haven't really explained the idea to you.

INTERVIEWER: No. Because as far as I know, that computer can still only do one thing at a time.

CORBATO: That's right. And it does just that. It runs one program at a time. And in particular, in proceeds to start in one program operated for a short burst, just the first time. By a burst, I mean maybe, and this-- at the moment, we're doing-- dealing at about two seconds.

INTERVIEWER: Oh, that may not be enough to do the whole program.

CORBATO: No, it may not. And the way it-- and if it isn't enough, there's a special device we have, which is essentially an alarm clock. I use the term alarm clock. It isn't like the conventional one. What is does is as soon as the program has run for a certain period of time, the computer is brought back to the supervisor automatically, without the user's program saying anything. And the supervisor now can reassign the computer back to another user. Now this simple round robin is the basic principle of the computer and time sharing. If the computer's fast enough to get through all the different users, and still maintain a reasonably continuous service at the different consoles.

INTERVIEWER: It just seems as though the computer is handling all these programs simultaneously. But actually, it's just going around and around very fast.


INTERVIEWER: One to the next.

CORBATO: You can draw several analogies. One nice one is that of a-- if the supervisor program could be compared to, say, a chess master in a tournament. And the chess master is playing a large number of people all at once. Now, the chess master is usually very fast and clever and he can essentially analyze the situation rapidly and make his move. And his opponents normally require considerable time to think it over and figure out the implications. And this is the way it is here. The opponents are essentially the people at the console, who need quite a bit of time to ponder over what the computer has just done for them. Or to not be under any pressure. And the computer can be racing back and forth, servicing each one as he needs attention.

INTERVIEWER: Does it give each one of them exactly two seconds? I was just thinking if somebody isn't busy, somebody may have gone out to lunch. What happens to that man's console?

CORBATO: Well, there are two things. First, we don't bother to serve anyone who doesn't ask for anything.

INTERVIEWER: Skip right over here.

CORBATO: Right. Skip right over here. But there's an addition. We've refined it already a little bit. The simple scheme will work. But we can actually refine it a little bit. And what we do is we say, the man who hasn't had any computation done for him at all has the first priority. And so he gets served right away in a short burst of say, two seconds. But if he doesn't get-- if he isn't satisfied with that, and he needs more, than we put him in a second priority and we give him lower priority. But when he does run, he gets a longer burst.


CORBATO: So this sort of smooths things out and gives the people that need the smallest amount of high priority attention the first crack at the computer.

INTERVIEWER: Incidentally, does this save time by not having to reenter a whole program every time? Let's say you were really going to be using the same set of instructions for a number of problems. Under the batch system, you'd have to put that set of instructions in every time, wouldn't you?

CORBATO: That's right.

INTERVIEWER: Every time it came your turn, your problem.

CORBATO: That's right. And this is, of course, would be a very difficult task if we had to do it through the console. So what we really are doing is we're keeping all those old programs. One of the things that are in the disk memory are old programs of each user.

INTERVIEWER: And they're all filed, so they don't get mixed up?

CORBATO: That's right. And not getting the next up is really the crux of the problem. The disk memories have been available now for about a year or so. But not many people know how to use them because you have to get awfully organized. And the real difficulty is keeping each person separated from the other. And we have had to solve this-- in order to solve it, we have one section of the supervisor which has nothing but that responsibility. And it's a major job.

INTERVIEWER: Just to keep things from getting mixed up.


INTERVIEWER: Well could we, say, take an example, actually try this out. Why don't we call ourselves user number one, and go through a process here.

CORBATO: OK. Well, I can illustrate this best by going-- the person would actually type something in at the console to the supervisor. The supervisor would then start to take action on the basis of that. Now the way the person really initiates anything in this system is he types commands to the supervisor. There are about in the order of a few dozen commands. We-- and these are mostly fairly basic instructions like I want to log into the system or something. Or I want to start typing in a program. Or I want to run a program. Or I want to put something away on the disk. These are rather basic manipulating commands.

So in general, the commands are typed to the supervisor. And they cause something to happen from the programs that are on the disk. Now let me-- actually, let me explain just a moment what really happens. What really happens is when a man types a command into the supervisor, the supervisor goes and gets a program out of the disk which it starts running as, say, you want program. It brings it in for him and starts to run as his program.

And of course that-- that's-- at that point, he's got a program working for him. It may do something standardized in a standard way for him, and then drop out of the picture. Another command, and a particular one of them is he may want to start an old program, so it'd bring in an old program for him. Now that's what we saw at the beginning of the program. And I'd like to illustrate that first.

INTERVIEWER: I'd like to see that, now that we understand it a little better.

CORBATO: I'm going to type the start command. And that's the first one [INAUDIBLE].

INTERVIEWER: And that will bring our old program, which is already on file, into a position where we can actually use it.

CORBATO: That's right. Now, as soon as I type start, I've actually started my program. So, in order to see this clearly, I think we'll have to bring the camera in pretty close.

INTERVIEWER: We can do that, all right. We get a good look at what's being typed out.

CORBATO: I'm moderately familiar with this keyboard. Of course, you'd want to get more and more facile as you get used to it. And this is one of the problems. We have to study the human engineering too, of people learning to use equipment. Too often equipment in the past has sort of been designed for other machines, really, not for people. If I start out by pushing one button, and then I'm off-- I think I'm off to a very-- let's see how this goes. Wow. Now, the computer's pausing there. The little pauses there are actual hesitations when it's switching from one user to another.

INTERVIEWER: Oh, that wait, for instance, meant that it wasn't ready for you just at the moment.

CORBATO: Well, the wait meant that the supervisor had gotten my command.


CORBATO: And it actually started pulling in that program. If I wanted to type there, I would really be trying to put input into that command program. Now that particular-- well, it's an actually old program that I wrote. That particular program, that I illustrated on the board, doesn't need any input. And so it would've been ignored by that if I'd tried to type. Instead, it wanted to talk to me. And in particular, it says hello. I do square roots and compute hypotenuses. Please type either root or triangle.

INTERVIEWER: Now, would this be a typical program, or is this a particularly simplified one for our purposes?

CORBATO: This is an extremely simple one. And not at all typical of what we'd use.

INTERVIEWER: That gives us a chance to understand it.

CORBATO: But I have to pick an example which is good for pretty much everyone, in a language that everyone understands. And it's illustrative of the technique of man machine interaction. I think it's very clear that this is the technique that would work in say, an airline reservation or a small business asking about a payroll problem. Or something of this sort.

INTERVIEWER: So, why don't we do a square root?

CORBATO: OK. So we type root. Please type a number up to six digits with decimal point. Want to pick one?

INTERVIEWER: I'll try to think of one I know the answer to. How about 49?

CORBATO: 49? OK. I don't think-- the computer, of course, doesn't have to have the simple ones.

INTERVIEWER: I have no way of checking it if it's any more complicated than that.

CORBATO: Now, one thing that's important here is that we could spend considerable time arguing about what the right number to have picked was. And it really wouldn't have mattered, because the computer is working for other people. And we're not losing any of this rather valuable computer time. I guess the computer's right. It said seven.

INTERVIEWER: Now what's it saying? Do you wish to continue?

CORBATO: Sure. No, let's type that.

INTERVIEWER: When it said yes or no.

CORBATO: Well, I think the point here is, we didn't really have to know exactly what to type See, the program was prepared to check and see if we made one of the-- what it expected us to assume was the right answer, yes or no. But when we didn't do it, it's able to come back and ask a question about it.

INTERVIEWER: That's interesting, because this would be one of the problems I imagine in the batch system that might've taken you 24 hours to find out that you had given the wrong instruction or the wrong answer.

CORBATO: That's all too true. That's completely the case. And it's one of the infuriating features of the older way of doing things, and what slows down most problem preparation.

INTERVIEWER: That's good.

CORBATO: So let's say what we should've said, I guess. It says, please type either root or triangle. So we're back there again.

INTERVIEWER: All right. Well why don't we do a triangle this time?


INTERVIEWER: Now this is going to give us the hypotenuse of the triangle? I remember earlier, it said something about--

CORBATO: Yes, that's right.

INTERVIEWER: --your hypotenuses.

CORBATO: It says give me two sides, and I will give you the hypotenuse. Type up to six digits, the decimal point. The first side is. Oh, let's pick something a little more difficult than ones we know.

INTERVIEWER: All right. You pick one out.

CORBATO: OK. Let's try-- typing one.

INTERVIEWER: The other side.

CORBATO: Let's see, the other side let's make 12.


CORBATO: Not sure. I think the answer's going to be 13. But I don't remember for sure. No, it's not 13.

INTERVIEWER: 12.04. Well, we gotta tell him, no, we're finished. Do you wish to continue? No.


INTERVIEWER: We won't make any mistake this time. Tell me one thing. What--

CORBATO: Oh, this is a good program. At this point, it's sort of cleaning up the details.

INTERVIEWER: I see. Now does this-- it seems to me that this would actually save a lot of time in that you might wind up with the same problem you had before the computer [INAUDIBLE]

CORBATO: It's a complicated question about saving or using time. We actually saved quite a bit of time in the sense that the person is able to be more selective and be more shrewd in his use of the computer. He doesn't set it on brute force approaches to problems. But actually can probe around, and examine some of the smaller answers first before he decides to go ahead. So this saves time.

But then there are other factors which make it look the other way. And one-- well one of them is the fact that we do have a certain amount of overhead switching between one user and another. Now this is controllable. But, and we can keep it, say, down to 10%. But it's one aspect of the system that uses more time. Probably the most frightening part, though, is the fact that we really made the computer extremely easy to use here. And so it's very clear that in the long run, we're going to increase the need for computer time by a large amount.

INTERVIEWER: Well, we already have increasing needs for the computer. They're being used more and more in all sorts of businesses and science and defense, and so on. What would happen if we don't institute such systems as time sharing?

CORBATO: Well, to see that better, I really ought to show you our present operation with a high-speed printer.

INTERVIEWER: Oh that is really printing out a lot of material, isn't it? What is all that?

CORBATO: Isn't it though? This is output from the computer, people using it in the conventional way. Notice a tremendous amount of material has to come out.

INTERVIEWER: That might all be one problem? One person's problem?

CORBATO: Yes, it's just one person. The reason he has to ask for so much, is that he really couldn't anticipate having what he needed to know. So he asked for more than enough.

INTERVIEWER: So what's likely to happen in the future?

CORBATO: Well, just imagine having 10 times as much computer here. We'd have 10 times as much paper. This would leave us with freight cars of paper coming up to the computation center.

INTERVIEWER: Well by time sharing, for instance, in the demonstration that we did, how much time did we use up on the computer?

CORBATO: Well this-- the output here when we logged out said we only used 18 seconds.

INTERVIEWER: Well thank you very much, Dr. Corbato. So next week, we're going to visit the bathyscaphe Trieste, which is in Boston to help locate the ill-fated submarine Thresher. We're going to meet some of the Naval officers who operate the Trieste and learn about some of the scientific experiments that they've conducted in the ocean at depths as much as seven miles. This is John Finch, your MIT science reporter. I hope that you will be with us then.