Operating the machine

Loading...

Из курса от партнера Princeton University

Computer Science: Algorithms, Theory, and Machines

63 оценки

Princeton University

Computer Science: Algorithms, Theory, and Machines

63 оценки

This course introduces the broader discipline of computer science to people having basic familiarity with Java programming. It covers the second half of our book Computer Science: An Interdisciplinary Approach (the first half is covered in our Coursera course Computer Science: Programming with a Purpose, to be released in the fall of 2018). Our intent is to demystify computation and to build awareness about the substantial intellectual underpinnings and rich history of the field of computer science. First, we introduce classic algorithms along with scientific techniques for evaluating performance, in the context of modern applications. Next, we introduce classic theoretical models that allow us to address fundamental questions about computation, such as computability, universality, and intractability. We conclude with machine architecture (including machine-language programming and its relationship to coding in Java) and logic design (including a full CPU design built from the ground up). The course emphasizes the relationships between applications programming, the theory of computation, real computers, and the field's history and evolution, including the nature of the contributions of Boole, Shannon, Turing, von Neumann, and others. All the features of this course are available for free. No certificate will be offered upon completion.

Из урока

A COMPUTING MACHINE

Every programmer needs understand the basic characteristics of the underlying computer processor being used. Fortunately, the fundamental design of computer processors has changed little since the 1960s. In this lecture, we provide insights into how your Java code actually gets its job done by introducing an imaginary computer that is similar to both the minicomputers of the 1960s and the microprocessor chips found in today's laptops and mobile devices.

Data Types16:31

Instructions10:28

Operating the machine8:23

Machine language programming19:52

Познакомьтесь с преподавателями

Robert Sedgewick
William O. Baker *39 Professor of Computer Science
Computer Science
Kevin Wayne
Senior Lecturer
Computer Science

So now that we've seen a program,

we can look at how people

actually used to operate such machines beginning at the computing.

So this is what the front of the machine looked like,

and again this is our imaginary machine.

It doesn't look that different than a real computer and might be hard to believe.

But this is the complete user interface of a lot of early machines.

We've got switches, we've got lights and we've got

a few control buttons and they're labeled with pretty much what they do.

So first thing that we have to do to use the machine is turn it on,

and sometimes that would be just plugging it in or sometimes there was a key.

But for Toy you just press the on

off button and then it lights

up to say that it's on and that's the only way you'd know that.

And then what you need to do next is load your program into memory.

So this is the little program that we just did that adds to numbers.

And by the way this was before post-its even

existed but we'll pretend that there's a post-it that's got the program.

It would be a small scrap of paper with scotch tape on it actually.

So to load an instruction then what you need to do

is there's a set of eight switches labeled address,

and a set of 16 switches labeled data.

So you have to set the address in binary.

So that's flicking up that switch,

so that represents 1 0 and helpfully the light lights up.

And then we have to put the data switches to set what the instruction and coding is.

So the first one is eight,

that's 1 0 0,

next one is A, that's 1 0 1 0.

You might think of A as 10 in binary, then 1 0 1 0.

Maybe do the conversion of binary first one digit at a time

you get to do this pretty quickly after a while.

Next digit is one,

next digit is 5 0 1 0 1.

Flip up those bits.

So now we forgot the switches set to the instruction

and we've got the address that we want to put that instruction in,

so now we hit the load button,

and that'll load the instruction from the switches into the address memory word,

and after it loads the light goes off.

So there we go, we've got one instruction in the machine,

and then flick the switches down.

Good practice to flick them all down.

And you could do that by running your hand across them,

and that's why those go off quickly.

And let's go to then the next instruction,

and the next instruction we do it all over again.

I load the address,

in this case it's 1 1,

key in the instruction.

It's eight and then b 1 0 1 1.

And then a one and then six.

So now we've got that instruction encoded and we can press the load button,

and now we have the second instruction.

Flip the switches down, do the third one.

Third one is location 12 1 0 0 1 0 0 1 0.

Right now, you can see why you want to be working in hex,

if you're trying to do all this in binary,

it would get even more confusing.

Now do the data switches to do the instruction encoding,

and you can also see how quickly you can convert from hex to binary so C is 1 1 0 0,

A is 1 0 1 0 and B is 1 0 1 1.

Now that instruction is encoded in the switches and its address is there.

So we press the load button and

load it in and then flip the switches down into the next one.

This is the store instruction,

and it's in location 13 and then 9 C which is 1 1 0 0 1 and 7 0 0 0 1 1.

Now that's encoded and we press load and flick the switch is down.

And then go to load up the halt instruction,

and the halt instruction is easy.

That's it. Location 14.

The data is 0 0 0 0 0.

So we're done with that,

and then we just press load and it's all loaded.

So at that point we have our program loaded into the Toy memory.

We have to kind of trust that it's in there,

but there is a button that helps us at least double check that we got our program right,

and that's the look button.

So if you want to double check that you loaded

your program properly and didn't have a bug like

putting the wrong hex digits somewhere what you can do is set your memory switches again,

so 1 0 and now when you press the look button it'll tell you what is low,

what is in that memory location.

Just press the button and then in the lights it'll

tell you the contents of that memory location.

In this case that's what we wanted, 8A1 5.

And typically if you're a cautious programmer you'd go

through and double check that every memory location has

the right instruction and consequences of a bug are a little harder to

deal with in a program like this than in a java program on your laptop.

So now we've got our program in.

And then what do we do next?

Well, we want to load data in.

Well how do we load data in?

Exactly the same process.

No distinction between data and instructions.

So we load our address in,

15, our data is 8 0 0 0 8.

I hit the load button and it's loaded.

And then we have one more data thing and that's in location 16.

So that's 0 1 1 0 0 binary six,

and then set the data switches to five and then press our load button.

And now we're set to go.

We forgot our program and our data loaded into the memory.

Now we want to run a program.

So what we do is that to run a program,

set the address switches to the address of the first instruction.

In this case it's 1 0,

and press one, run.

And what does run do?

It just starts that fetch, increment execute cycle.

When you press run,

the program starts running.

Now the data lights might flash some times.

But what's going to happen is after a while the run light goes off.

Maybe you noticed it went off.

Goes off when the hault instruction is reached and that's

the only clue that you have that your program executed,

is the red light goes off.

So then how do you figure out what it did.

Well, we have the look button to see the output.

What we're going to do is set

the address switches to the address of the expected result in the memory.

In this case it's 17.

Notice we don't have any way to look at the registers there

temporary we just have ways to look at the memory.

So we look at 17 and hit the look button and it tells us our result,

D. If we want to run the program again and enter different data we can do that,

enter different data and press run again and write down

those the answers on those post-its that are in a piece of paper.

That would be the way that we would enter and run a program in an old machine like PDP-8,

that we're representing with our imaginary machine Toy.

Nowadays, I think many people find it unbelievable that people programmed in this way.

Did people really program in this way?

I'd have to say yes, absolutely.

In fact there's a guy programming a PDB-8.

People used to program in white shirt and ties too.

And I have to say I spent three years of my life programming in this way.

We'll talk in more detail about this process later on.

Ознакомьтесь с нашим каталогом

Присоединяйтесь бесплатно и получайте персонализированные рекомендации, обновления и предложения.

Coursera делает лучшее в мире образование доступным каждому, предлагая онлайн-курсы от ведущих университетов и организаций.

© Coursera Inc., 2018 Все права защищены.

Загрузить из App Store

Загрузить в Google Play