Difference between revisions of "Processors in Programming Languages"

Latest revision as of 00:13, 27 November 2021

really

come in a version that

sorry

trickle its way through but Burroughs had this distressing

set of traits

of having the best hardware architects

really in the world for many years and

they could never ever implement these designs partly

because the hardware architects are a little bit purest

major

figure here is Bob Barton who is a

well-known iconoclast

remarkable man he's I think

he said still

my first this is B five thousands the

third machine I ever learned I learned it in 1962

I happened to be in the Air Force and

they had a Burroughs 220 Burroughs

220 was this huge vacuum tube

thing with 5 or

bigger than this room and you could heat coffee

on top of it wait

old machine and had a couple of interesting features on it that actually

partially triggered off some of the ideas to be 5000

Martin first

was really a philosopher he was a philosophy

major at the University of Connecticut and

gotten interested in proving he's already reading philosophy

books and books not logic

a man of parts

and I guess he started coding around

1951 or sellin

boroughs bought a company called datatron

and they set up

they've made a machine called the 204

in the 2:05 were true run taste machines

and a 205 in the borough's 220 was the same

xcept that the tool fire was completely based on a drum

it had the registers on the drum also many

copies of the residues just placed around the drum so

that you didn't have to wait for a full revolution this way to get

things in those days and

they set up this whole latch up in a Safeway

store in Pasadena partly

because of that location they formed the early

association with Cal Tech back

canoes first machine was the

205 and the 220 and this

horrible thing known as mix in the

canoes books is a very reminiscent

of the 205 into 20 in

other words it was a decimal machine

ach position

had

10 decimal digits

and a sign digit and each

one of these had four bits in it so I had

44 bit words and the sign

position for some

reason known only to them and to God they

decided to have all ten possibilities

for the sign position okay

and because there's only plus and minus and then eight more they

decided to assign some meaning to those it was

meaning assigned to those extra sign positions that

that led to

ideas in the be 5,000 I won't go through the whole history but it's very

interesting to watch how these ideas come about one of the sign positions

was saying position six which marked

this thing as a piece of code

okay and in fact the

the machine would not

if you if you tried to

fetch through something if you

tried to fetch a piece of code there

for instance they were trying it would we try

and do a job in other

words they both protected things in a limited way in

memory and there are certain side effects that can be triggered off by

touching things in memory it was that idea which is

being played around with in the 50s that that led to part of what

to be 5,000 was okay the most important

thing about this is

that in 57 and 58 there

is a language developed called Algol 58

and alcohol

58 was a reaction

sort of a purist reaction of the Europeans

Plus Alan Perlis a few other people in this country

too Fortran so they thought

was absolutely detestable but a Fortran had come

arlier so they sat down and designed this thing it was cleaner

and except for the fact of not

having data structures except for arrays and

strings and integers and

floating point typical

alcohol data structures but not having Pascal

data structures this language is essentially what Pascal is

in other words it has one level

of definition

for global

procedures

etc

and [Music]

the some of the versions of this I could

o recursive subroutine calls and other ones couldn't the separate procedures

have local variables

there are a couple other features

language it was basically a very simple but vanilla

language and Barton

head of the project to put this on the burst to

20 and doing so they

a thing that had only been really discovered in

56 57 by by

a few people in Europe which is called the stack the

staff was originally invented for doing compiling and

you have to realize that back in these days in 1952-53

when they're still thinking about compiling

arithmetic expressions this was considered to be an AI problem

okay

what Fortran was was the world's first automatic

programming system that's what it was called automatic

programming was how to get away from writing having

ive explicit sequence when writing machine code

ok so the first task of automatic

programming was to not have to specify sequence

for thanks and the

first parser is back in the early 50s actually

went in and parenthesize effect Fortran yeah

they went and actually put all the parentheses in to

the source code okay

and then went through and removed all the parentheses by

going okay was unbelievable but

that this is the in the days before it be an F there's

no such thing as a compiler compiler so

some Germans

pop up Bower and

a couple of other people

you er can't remember the

other guy Sam Wilson says yeah Santa Valerie

invented

a stack algorithm for doing compiling

arithmetic expressions that used precedents it was the first

precedents algorithm Martin just loved this he just

sucked this up and

the basic idea I won't go

you know you either know it or you don't at

this point this is part of the

that used to be important for people to know but

is yeah the noise now as far as I'm concerned

but basically the idea is you kept

opera Diana from the arithmetic expression you kept operands

if you had something like a plus B times C as

you chucked your way through this thing

you would have shoved into

the stack everything

up until the time side which is the

something and do something with the city and the B and

either have to sometimes they have

two stacks you put the operators and 170 you plus there'd be

an A to B maybe

you push it all the way down so you'd have time

silent CPA here and

as soon as you could find out there's

nothing more for you to do over here and then you know you could generate

code for these guys okay

ou kept on going through in the stack kept

these intermediate results bargain very quickly realized that

a stack could be a dandy idea de for doing

subroutine calls in

fact they were just starting to mumble about the idea of recursive

subroutines for doing problems

so when they implemented the system on the on

the burros b20 they had the idea of

that they were

going to get enough do

things in this order and then generate code through

an assembler multi pass assembler and

they're going to use a stack for subroutine calls they

also had the idea that this

group of global contact should probably be

represented as some kind of table in storage

that had it in either pointers to

arrays allocated somewhere else or

had numbers in them

and in this particularly

implementation the code had to know what these were supposed to

be okay so one

fine guy I don't know when it was 59 or so

after all this had been done

Barton was reading a book

by Lucchese which logic and

what Lucchese which had done is in order to

do certain logical manipulations of things which requires symbolic

manipulation it invented a notation that

had no parentheses

and in fact it was a

I think Lucchese which is

notation was a prefix notation can't

remember can you remember Steve can't

remember whether this prefix anyway the two possibilities for an

expression like this or either saying

something like BC times a

nd

yeah I think the case which is was actually prefix

which there are various ways of writing

that you can say x b c

plus a or plus

a times b SI

prefix use a stack

until you get to something it will actually

has a couple of operands

and think

about Barton is one of these guys has a mind like a net

almost completely

intuitive

your life because he never knew

when he was going to have a good idea in fact he lived for quite a

nd he feared he was never going to have another the

fact he had good ideas all the time I used to absolutely

destroy PhD theses at

Utah where I ran into him because

he'd be working with a thesis student for six months and

all of a sudden he'd wake up in the morning with a total

solution to that thesis and that was the end of that

thesis and so the smart thesis students

like me stayed away from them we

didn't want him to solve our problem and

even though I was a natural

to be his thesis student I went to Dave Evans and

Barton would not talk for me for five years because of that

that's the kind of guy is he's sort of like

William F Buckley to talk to there's

an incredible command in the English language and he's very

very snide delightfully snide

it's a Barton okay

when this when

Bart made the connection between this and this

his mind just started working and

in 48 hours he had designed to be 5,000

okay it was one continuous hit according

was just literally stayed up for 48 hours and everything

fell into place I'll certainly give you an

idea the things that led into it

was the Barton's basic snobbery that

said I never want to write machine code again higher-level

anguages are a good idea then by god what's right in them

never want to write an operating system in the lower level

language never want to write anything in

the lower level language tomah's

the compilers weren't the

machines weren't a good environment for this kind of

thing so he had in the

back of his mind the idea what let's build a machine to run algal

if we think that's a good language and

in fact the Algol that they built it for was this Algol

58 B 5000 doesn't have

all the hooks in it for the

6006 he came along while they're in midstream

machine so here's here

are some of the things he thought about

first thing he did was to

say well

I know we're

gonna be running lots of different jobs in fact the first be

5000 you have to realize in fact most of these machines

had multiple processors on it right from the beginning

teeny little machine -

it was only a 4k 48 50 words had

swapped off a 32k drunk

this is a mainframe computer

and they don't knew they were gonna have to

do lots of fun lots of batch jobs and do compilations

and all those things one of the things that always happened in those days

as a program would start writing into somebody

else's programs core now would lead to strange

results and that

was not a good thing so one of things that they wanted to do is

to protect so we decided that

the

consequences I don't know how he all came to all of us at

once because the interesting thing about to be 5000 is not that

it has a stack that was the least interesting

complete innovation those days there's only one other machine

that has sort of a stack that was called the KDF right

so here's what he did he said

when a program is running

some kind of code here

ach

I only have two kinds of things that I'm really worrying

about there are things that denote operations

and those are things that are going to appeal

directly to the machine so those are

pretty safe and the only other thing I have to worry about

are things up to note variables I notice he didn't say values

because some higher-level languages

don't have values they have variables everything comes down to looking

like a like a variable and

so he asked himself what is a variable and

a variable actually is

some item in this list here or

some item in the list of the procedure and that's all it

is so he immediately misses came

out of this table already but immediately said

there are two kinds of variables are local and global and

all those things are our numbers that are offset

from the beginning of whatever this list is and

since we're going to be running so if

this is the red list here and

this is the red procedure and

over here we have another job that has a green

list and a green procedure

than

any particular variable

like this one down here it's

like variable 19 that's

red and this one over here is variable

19 that's green

completely two different things because they're reference

relative to this guy to this guy

they

said okay that's that's great what we need to have now

is a register that the code can't see the points

to this so that registered

it's called the PRT

whenever a piece of program

is running this PRT register is pointing to one of these table

I'm going to draw it as a table map

okay and now what code turns out to be is

something that can be rather small in

fact this thing I think was up to a thousand law

these are 48 that words

and so to

worry about any

one of these guys the code for that is only needs

to be ten bits long worry about

that and

for various reasons

they

could have done this there's whether they say it's really terrible

criticize this but you know after 20 years and a few

things have been discovered but

they decide also to make the operator

set be 10 bits long so

they could have a thousand operators never

only had more than a few and then to distinguish these two

there are a couple of extra bits

on as headers that told you what kind of code symbols

these were four kinds of code syllables

if I can still remember these

there's an operator

I think I want to get to use three of them

is basically

the operator a what is called a value

call and what is called a

name called

I'll

tell you what those are in a second

so code in this machine was 12

bits long because it had

48 bit words the

register up here for

would hold for instructions

at a time so to have a little instruction cache on

it and just attach those is one of the consequences

of e 5000 and only have to cycle memory every for instructions

now going back to how

executed Barton quickly discovered

that going to post fix is much more efficient

then he asked himself how

am I going to implement the stack I think the first way he thought

of it is that he would simply have another

register here called the s register

that would point into the top of memory

and there would be

the

stack then he realized he needed a couple

of registers to hold stuff

was going to go through the arithmetic part of the part

of the system and so put in two registers

two Hardware registers now actually

what I should do is

let's be consistent here

put the staff like this

okay so I put in a couple of hardware registers that

were logically the top of the stack called the a and B registers

the a and B registers had

an extra bit that marked whether there was something

in the register or not okay

let's call the presents bidder

so

the idea was if you chugged up to a-plus

and there

wasn't a + requires two operands and both

of these guys weren't on this this

machine would know to cycle the stack to make sure there are two operands

in the registers so

did the most efficient thing that it could

would only cycle a stack when absolutely

necessary to memory that all happened automatically

okay so

I'm very logical to think of these these

things are called syllables the code syllables

would have a register to know

what this was called but I'll call it was either called C or

P or something like that

here are

a bunch of code syllables so

this bc times a plus

would be turned into something that would look like

value call for wherever be was

maybe be is number three here so this

would be something like value call

three this

would be value call maybe seven

word see

our operator

50 or something which is a plus

and value call

whenever a is maybe 30

plus

I'm sorry this is x operator

45 which is plus

so

that's what that turns into and this thing

had been this thing had been in originally

an assignment statement into a variable called

e

and the code would have come out

he

underbar a sign

and that would have turned into here

would have been a name call

on wherever D is

these at 50

say Lane called 50 op

sign

they just we

numbers there and just draw these things in

okay so

what name call does is to

generate an address that becomes an operand assignment

is an operation in this machine and

there are a couple of interesting

this is penetrating at an instant

of the most important things you can ever do in

a higher-level language which is to be able to

give other senses for store and fetch

and in the hardware of this machine never been done

programming like reports in the hardware this

machine will talk about what's right and what's wrong with weight it turns

out you did it the wrong way but you be forgiven

because nobody thought before in fact borrows

use of it because most of the programs that borrows do not understand

this particular feature she

okay now a

wonderful thing

further

about this machine is that if a and

B or C we're procedures the

code is exactly the same okay

compiler does not care for

the following reason that one of

the bits in this program reference table

it's called

a flag bit and

it is there to distinguish direct

operands like integers and floating

point numbers and the

way integers and floating point were stored was such that

there's only one Plus that you needed there's

only one operation over here and the

system could tell whether there was an integer floating

point when the flag bit was zero it meant what was stored

here was either an integer or floating-point

okay when the flag bit was one

meant there was something that needed to cause

an interrupt to be triggered off to other parts of the machines hardware

yeah yeah this is what we

want to do is look at these guys when the thing is marked is

what so what I'm saying here is that

there's no such thing number one is the code knowing

what it's going to work on it doesn't it's

a direct translation of this which

in this form B could just as easily be an integer procedure

as anything else and your function

okay and number

two the code is not allowed to

see any of its own state and

note that the code cannot see

its segment that it's in unless

there happens to be a pointer for it in this program

reference tables everybody see that okay

the code contains no addresses and in

fact there's no way for the code to generate any addresses the

only addresses it can ever use are

that's been given in these registers this code

cannot see these registers the code cannot see the

a and the B register it can only use the

absolutely critical this is what it's so clever

all modern protection schemes are based on

this idea this is the idea that turned into what is now known as capabilities

but

done almost perfectly the first time around

when I was done in Baltics it

okay so let's take a look at

these are these

48-bit words with the flag bit of one

they had enough room in here that

they decided what they would

also do is to make the storage conform to the exact

objects that the programmer wanted to use which are little variable length

segments okay and the segment

he thing that not only has a starting address but

also has an ending address okay

so for instance

an array would have something like

the following format

his would be the base address of the array

this would

be the length of the array this

would be the fact that it is an array as

it's additional type information there'd be a couple

of extra bits here one of which would

indicate whether the thing was in storage or not

the idea is this bit where

zero when you ran into it here meant

you had to go out and fetch it before you could use it okay

so what this was was a protected

segmenting scape another interesting

one here is procedure

is one of these guys

think of this code if you want

as a base address

it has a length

as a present spit

so

forth and there a few other ones

okay so what do we have

here we have a scheme

I got draw I haven't shown everything

yet not to show how subroutines are done let's

review for a second we've

got a scheme and where the the code only refers

to off set of registers that can't see

no object in storage

can be referenced directly by the code the

code wants to see something there has to be one of these

guys in its program reference table

what's in the program

reference table is in there unambitious lee because the flag

bit it's not in there as bits if the code has to remember what

the heck it was so

what can you do with this well suppose

one

of the things you can do for instance is replace see

here with

a procedure suppose

we want to enrich in this thing without changing the code

you just put a one flag bit of one and point

this off to another piece of code down

here every time you go through and execute this code

and execute the procedure and generate the result from it

his procedure can just as easily access

a file one of these things can be a

prominent going to another process the process is one

of these whole conglomerations

another one over here

okay so the

in this machine you can implement directly

things like streams in UNIX

okay what you implement it just simply any variable

can act as a stream but

so far we've only talked to that about them as sources

let's go through the how

execute some code here

suppose suppose we have the code

e5

okay right at this point we don't

happen to know whether there is an array or a

procedure and if the caller doesn't know

either what it does is it says but

I'll do it different color so you can see it says now you call

oh I

know what the other one was

no it's no it's just small subscripts

actually it was was a small immediate

operands that's what it was

0 0 0 1 1

0 1 1 yeah

these are small integers

operators

o

this thing would be immediate

five now we put the five

in the top of the stack

then the

I'm not going to go through

right now exactly how

this how this does in fact

president was slightly more baroque way than

it needs to do then

would do a value call assuming it's on this side of the

assignment arrow do a value

EU never is one of

these guys in here down here so if you value call on

95 or something

now if it comes in here

and the flag bid is on the flag that is off

there's a little little more code

generated here if the five minutes is off it's

going to complain it's an opera

opera hat waiting in the stack if the flag

that is on here remember the five is is in

the stack already then

going to look further than if it sees it's an array what

it will do is automatically index

the array against the base address but what it does

is it checks the this guy against blanks first

and everything if everything is okay it generates this

other way generates a bound check error so BAM is checking

done automatically by the hardware here if everything is all right

then what it will fetch into the top of the stack is

the

value from that particular array

important thing to realize is that

arrays there's an array

point razor

things like this program reference table arrays have flag

bits also okay

so it's a multi-dimensional array fetching in one

that has a flag bit on it's going to trigger off another indexing

and we'll start peeling the staff dry from

all the indexes of the rail just appeal so rays are stored

as trees on the be 5000

until you get to something that's an operand then

I'll finally fetch that and answer it will have the answer

even more fun

that comes in here to E and just discovers

it's a procedure it does exactly the same thing except

he procedure with this guy as a parameter

so bharden having a somewhat

symmetric line

ask himself the question of what suppose I

had something like this

what should i do

there now the answers is this is a by

being on this side of the assignment operator this

part of the thing is going to be replaced with a name

what I want you to wind up with is an address

that this thing can operate

on okay so far so good and

happens with array is it ripples through the same way except it doesn't

fetch the last guy just we use the last guy in

the top of the stack this guy can

work on so for symmetry he decided

that if this guy happened

to be a procedure and it was called with the name call he should actually

do something rather than complain this was the master stroke

and what he does do is to call

in such a way that the procedure itself can discover

what it's being asked for a name or a value that

was a test you can make in this language

called Bal Gulf was in the beginning of a

saying if somebody want me to generate an address or to somebody want

a value from me and so in

the complex Bal gall procedures were actually

two-part procedures each part was a function that would produce

a value it was also a procedure for calculating

what that address was

that works for many

ou want to do turns out it doesn't work for all the things

you want to do but it's very close it certainly

allows you to simulate arrays and other

data structures I think you can see that if you

put this thing in you can simulate the semantics

of most data structures completely

cover up whatever representation is actually being

and this was something that was used to a limited extent as

programs didn't really understand this in

particular you can replace variables with files

you could have input

and output pipes it would fire off

things that's what a lot

now the final set of mumbo-jumbo

here is how the

stack was used to

also

store subroutine state

that

that way is as follows there's another register called the F

down here

let's

think of what it has to get shoved into the stack when you call us every

day somehow we

have to have the following information there's

a program counter that must be here somewhere

that is indexing

into this code notice the program counter is

relative to see

okay see see could

be anywhere this is was the first computer to ever have

so the various things we need to store are the program

counter of where we were and that counts

as guess what one

procedure segments these

two guys just bottle up

in there we need to

know where the previous stack

frame was and we have to know

where the current one is because we have to get these

guys relative to this frame register

so the several ways of doing this

at the be 5,000 does not do this in the cleanest possible

fashion a modern

way of doing this is as follows

is to

point in have the frame register point into

here and index local variables

negatively relative

to this so the local variables and the

frame information

the old program counter and stuff like that indexed

negatively going that way and use this

stuff here for the arithmetic operations in the new procedure

ok that's the way small talk does it

the way to be five they didn't realize

they could do this on the me five thousand so they they went through

a more complicated thing of

marking the stack first and a few other little goodies but

this is good enough to show

hat

what is in part of this thing is the Preet the old F

which is a pointer back down the stack

into the previous frame okay

information you so think chugs along as much

as it wants as soon as you hit a new procedure thing that triggers off

a procedure call it bottles up this guy and

that guy into the stack assuming

that in typical Polish postfix

form that these all of these variables

here have been loaded into the stack first

okay it just doesn't even know it's going to call

a procedure just go chucking along the early eventually

run into a procedure call and all of a sudden it discovers

all of the variables have already been

evaluated and they're stuffed in the stack in the right order

and when this F register goes in then the

parameters are just this

reason it knows is that these ten bits

that this thing is built up

into for these two guys is actually broken up into

two smaller segments

for global and local

so that's basically how the

machine works when

you do an inter process call you run into

something that's a process it bundles up

more than this it actually talks all

of the state of what's going on

into the top of the last sack that

you have and stashes that in a program

reference table in the operating system program reference table

the operating system is the scheduler okay

because that's what it is you want scheduler

a bunch of things that have just processed descriptors

in there and you just go from one to the other and

you're either executing or closing them up so the subroutine

call time on this 1961 the machine was

just a couple of microseconds

almost as fast if the operations were itself because

it have to do it didn't have to do much more than

what it was doing on operations the result of

this thing is that the procedures that you wrote

were very close in

thinking to the notion of extending the whole

operator set of the of the computer is like a programmed operator

set that you find in blessing machines like the

but fit

into this one homogenous scheme

so what we have on the unbe 5000

is have complete protection one

this is one of the few architectures that actually

exists today they're still selling these goddamn machines forget

what it's called fifty seven hundred fifty nine hundred out

every couple years they upgrade the

hardware on it but it's basically such a sound

design I have so much code written for it that they're still

selling the goddamn things the reason

is you can't break the operating system just

cannot break it because there's no way you

have to do extremely special things in order to be

able to get any kind of descriptors which what these things are called

- any piece of code or any piece

of segmenting the very first

he third one of the first multiprocessor

systems and again you can see why because

protection is nearly absolute

as you can get you can afford to have several processors kicking around at

the stuff that's there and the prizes are

put to good use because the storage swapping was so slow

that one of the processors would be running was

omething while the other guy was trying to swap stuff yeah

you have programmable data

on balance

checking automatic subroutine

calling and process switching

and a limited amount of code cache one

batch for every

okay so that's that's sort of a quick pass

through what to be 5,000 wise now

funny thing about this sort

of the despair of anybody who actually knows about

this machine is that almost nobody knows about these

ideas these ideas would look goddamn good on

a chip from Intel er Motorola today believe me

I think we can all use them and they're a couple of

things that we might like to do to to fix up going

after Pascal like data structures but this would be one dandy

Pascal machine and it's one of the things you have to realize

that one of Klauss worst teachers was Bob Barton

Klauss went and Dave Evans

okay Klaus was a graduate student

of Dave Evans when Dave and Harry husky when Dave was at Berkeley

and he

then came over to work with Bill McKinnon at

Stanford where they had a be five thousand and thousands

first two languages were

there's language called Euler which is a particularly

good good design it was implemented as

this this whole thing that led to Pascal P codes is

right here okay Pascal P codes

are sort of a crummy software way of doing what this machine did

in hardware this is what is so amazing about the

as most things that you would like to have in a programming

language they had to extend Balga or to

handle features like multi processing the

the protection the fact that you could actually change types

dynamically here which bound all didn't allow but it's

like they came up with a language called s Paul

I can't remember what s Paul stands

for anymore but it's basically an alcohol extended

for systems programming and it had all it was language

that used all these features directly that's what they wrote all the

operating system they never wrote a line of

assembly code there was never a sembly the

fate of this machine was kind of funny because

I remember when when

burrows was Hawking it they were

so proud of what this

machine could do but they went out and hired a bunch of college

graduates as salesmen and actually

taught them what the machine was worst

mistake they ever made because they immediately

went out and completely snowed all of data-processing

managers remember this is 1961-62 telling

them about this machine that was distinctly not like

IBM system they'd ever seen before and

it just scared the out of everybody they made up they

sense of humor they made up a game called compiler

games it was a board game that you played

like Monopoly except what I would do was show you it

would actually generate would take any piece of alcohol

code and generates burroughs syllables

he just went through it had the stacks the little

the stacks you know you just went through and it had a me

and you just went through the thing and by god the thing

would showed you how simple compiling was on

this system that scared everybody that's

how I learned how to compile when I was in the Air Force using

this damn compiler game I'm looking for one ever since

must be some around the other thing they

did is they came out without Fortran on

the grounds that alcohol 58 was infinitely better than the

soon to be a now the algaas they upgraded this to Algol

60 was infinitely better than Fortran which was

true and they could run Algol 60 with no

appreciable overheads unlike how and on the other

machines nobody bought it in fact

this machine languished for years until

they wrote a preprocessor the translated

Fortran into alcohol and then compiled that

into these things and that is

how that is how they finally sell the machine they fired all of the college

graduates and got guys like the old SDS

salesmen you ever asked them a question they would say I don't

know the answer but can I buy you a drink

sent them out and then they finally people started

noticing that the machines didn't crash very often like once every

two years and that

they could even these small machines could

twenty four thirty jobs at the same time interleaving

all the stuff they're incredibly efficient

okay so

generally speaking a a

system like this is this

is sort of the place where

you start thinking what you start about higher-level languages and if

you're thinking about doing Pascal a couple

of modifications this gives you a damn good Pascal

machine it is essentially the algorithm

that the Mesa people

put in micro code in the Xerox

PARC machines Mesa is sort of a super Pascal it's

the algorithm that Cosworth put in the

Loess machines

that were spin-offs of the park

stuff does pretty well what's

wrong with this

well first thing is

that it has such a determined way of

doing things that

one might ask the question

is how does this dough do less okay

the most natural way of doing Lisp here is to

have these guys point to segments that are only two words long

it turns out that is a disaster

because remember the thing thinks it's trying

to swap segments the whole system had

an assumption about how long segments are like they're an average of

40 words long which is a reasonable swapping

size and strings were longer than that so the

first first time Lisp was tried to be put

on the powers be 5000 just

he last time McCarthy ever looked at a machine like this

he made the incorrect assumption

that since list wouldn't run out of be 5000 that a

higher level architecture is a wrong idea that is false

but it was such a failure that an

apartment in fact Burroughs has compounded that error

over the years they grew to love

this with a passion approaching that

of religion and essentially decided

that didn't run on this wasn't a good system

okay which is the usual way he defined

the problem out of existence and

so as a result Barros has never entered the

mainstream of research never ever

and the current borrows machines don't do much better on Lisp than

the old ones did and I

found that this is sort of to my heart because I adapted this architecture

on the first machine I ever designed around

1967 or so tried to do a desktop

machine that directly executed a higher-level language

of the euler type but with multi

processes as being the basic idea that it turns out

it doesn't work the reason it

doesn't work is basically

cost performance

what

do I mean by that well this

to balance what this does for you with how

much machinery actually have to put in there with

how many times you're actually using it with

how many times you're going to change your mind and what the

data structures are going to be like and

notice you can you can make any kind of a

data structure you want here with a programmable system

is it just gets cumbersome because this isn't a good way

of extending things so when we finally

set out to do small touch we had a model in mind

and small talk actually if you squint at it

you discover that this thing

in small talk is what we call the instant state

and it's usually much smaller and

these stack frames and

most of the small talks are actually separate objects called activation

records which are allocated separately rather than

on a single stack and if you do that

then you wind up having an object oriented architecture

okay

that was that was partly led to by reflecting on how Simula might

be executed on this on this machine

but the thing that you have to take care of is

this basic assumption about what storage is

going to be the real question is how much

can you afford to pay for

machinery on data structures most of

don't know what they're going to be when you start out and

at Parc was instead of building any machinery on

this thing we tried to make the Machine run enough faster than

main memory so that we could change our minds frequently

in the microcode as we went along and

we finally staff settled

on a few standard formats larger than the number that's be 5,000

had that would do about 95% of all the

structures that you could construct in small

talk this particular direct

has anybody seen any of the bugs I know

Steve Steve Saunders knows all these but

notice one of the things that happens when you do a process

which is pretty unfortunate

is anybody see

in the stack that you don't want to have in the stack when

you do a process switch

and we can have integers in here that's okay

doesn't matter what else can be in here

yeah we can have some addresses of data and

addresses that they are absolute addresses

okay and that means that

you can have an one

of these array descriptors or a procedure descriptor in

here that's pointing to something in

storage and a frozen process that you're not going to use for

might like to do is to clear out core and

let the new process run for a while and

the problem is if you do that then the chances of these things

to these guys when you come back and is going to be zero so

that led to some immense first

set of immense clue juries which

persists actually to it to this day they're on the

6700 has this horrible

instruction I forgot what it's called but its

purpose is to chase down the stack and find these guys

and make them turn them from absolute guys

the relative guys will then get triggered back

it does it does this when when it something

is going to be moved that belongs to this guy yeah

barf terrible

that one we can't pin on Barton

he was long gone by the time they put that one in there

but it brings up the notion here that the mapping

scheme which worked so well on this fairly primitive machine

doesn't extend I think

the one that yeah

would check to see that

no reason okay the

storage manager made sure that that happened

but one of the one of the problems with it is that

in most of the early successful system they actually used

this structure as the map also in

other words the operating system would look through this thing

and this would be besides the program reference table

for the program it was also the storage mapping structure

of the whole system which is trying

to make do a little bit too much double duty

you see what I mean because you know you

have integers there's there are too many side

that can happen and make it go on so the weakest thing on

this machine they realized by the time we

this stuff at Parc was that the storage mechanism wasn't

sat down and thought about it we realized that we in

actually know almost nothing about allocating

storage it was

problem in the B 5,000 it's just be simply that

getting caught and we're always spending the most time trying

to figure out how to allocate storage how to

how to use it and

in small talk the scheme

that we had was to have much shorter

addresses and the addresses weren't based addresses at all but

actually names of objects

okay so the instead of pointing to anything in core these

things denoted the entire object and the object was found by

looking up in a step separate storage table that

would tell you where the thing was it's more

it's a cleaner solution to the thing and it actually worked

small talks schemed was the first

segmenting scheme that actually worked thanks to Ted

Kaler and Dan Ingalls they actually figured out how to do it

what you have to do in order to make one of these schemes work

is amazing why

should anybody go to that trouble well if

you are swapping objects

thank you always are interested in knowing is what does

this thing called

working set working

set in most operating systems is the

that you have to have in so that you won't swap more

than every like 10 milliseconds or something

like that in other words you want to have enough context

in storage so that you're not swapping on every other reference

and paging

is terribly inefficient because the matter how

allocator is it's always allocating the wrong objects

on pages and the

discovered when we did this in small talk was that

the packing efficiency of having objects

packed in the core by a compacting allocator was

a factor of 15 over what pages give

you okay that is

tremendous it's like having 15 times as much core

unfortunately the overhead for

getting objects is much worse right

you have many more objects and

several thousand objects and stories instead of a you know a

small number of pages you have to go through much

worse mapping scheme it's not just a table lookup anymore

you have to do hashing my name's

you have to fetch small objects off digital

disks which is not good when you're writing things out you have

which is worse and

that was what

caused this scheme to fail and the Flex machine but

then as I say Keller and Engels that

people pitching in from the sidelines came up

with a composite scheme that solved all of those problems

using partly a technique

of realizing that the last thing you ever wanted to have

in storage was written on objects

okay and so whether you whether the system wanted to

r not it was constantly jumping through every couple of seconds it would jump

through and write out every object that had been written on whether

it needed to or not and so only I

think something like 4% of the occasions

bring something in did you ever have to write anything out to make

room it was always clean stuff in court

that turned out to be the key that was adapted

from the great old algorithm on the SDS 940

the Butler Lampson thought out but this time for

objects rather than pages so the result of it is

that the page the swapping efficiency of

Smalltalk 76 worked out to be a factor

of 9 over paging in

fact the in that particular system never ran in

more than 80 K bytes ok every

demonstration we ever did in small effects 76 only swapped

an 80 K bytes something that is quite

and part actually just after we discovered at work we

actually decided to keep it at that size because that was a size

it was going to be possible in commercial machines

very very shortly the equivalent

performance to a system like list was equal to about

almost 10 times that amount of storage it

took a kinder list on the darada you

have to have something like 350 k words

16-bit words in order to get the same swapping

inefficiency and difference they have almost an order

of magnitude which was remarkable okay

so that is that

is the basis for thinking about these

systems now let's talk about a little bit about the wrist

chip

very interesting what they tried to do

wrist chip was designed

an innocence or at least a partial innocence

of the be 5000 which is probably just as well first

hing after learning something like this is to forget it you

know it's sort of a useful fashion you

don't want to remember anything directly just want to survive

the air but this yeah you wanted to seep through

your consciousness when you're designing but you don't want

to try and imitate it

one of the things to realize is that most

of the early machines were reduced instruction set

computers there's only the IBM

and Remington Rand corporation

and control data had this thing where they sold

computers on the night and

that led to a whole bunch of what we used to call it drop

screwdriver instructions debugging

the machine and screwdriver drops inside and shorts

something out the machine does something you

it a feature rather than a bug and write it into the 500

or so instructions

this is what literally what they used to do a

long time almost none of them can be

compiled - and most of them can't be understood by machine code

either you know they just sit there with

cubic feet of hardware to try and execute them

machines like the PDP one and

other delightful things that sprang out of the world

when computer he had these very very

simple way about going to do things and people noticed that they

were pretty efficient even though they hardly did

instruction the reason of course for that is that

yeah if didn't take any time the machine was incredibly

efficient it didn't have to hardly do anything machines

are really sort of like ticking clocks

o from in the sixties

what is the entropy of the program

so in Paterson and se

caen wanted

student project they wanted to do a processor they

had a chance to look at this thing called the OM

processor at Cal Tech which was a

attempt to do an extremely clean computer science

e type processor by Ivan

Sutherland and Carver Mead turned out that was an utter failure

it really was one of these

things where they got so enamored in dealing in the

what the machine was supposed to do they put it I mean

you know all the things that you read about in the books that are good

they tried to do in this thing and it turned out to

be a flop because the chip got very very large

still only a 16-bit processor

just didn't do very much so

basically what

what they did was to take a bunch of

C code and pascal code and

use a variety of ways of

analyzing it's a thing called a gibson

mix analyzer which is a dynamic way of

analyzing what percentage of instruction is getting executed

they look at the code statically

they came

up with I think everybody has the the document

they came up with a set of

percentages of what things got executed when and what you

had to do and they decided they had only optimized

two things one

was to try and have the

instructions that executed 90% of the time executed

one cycle and the other one was to

try to reduce subroutine overhead

okay and that is what they

that is what they did

and so they came up with this mead Conway

design which is

traightforward in architecture as you could want

and

several interesting things about the architecture I'm going to need some help here

sigh I actually didn't get a chance to prepare for this

because I I gave up my copy of that document which I haven't read for

like six months but

so call out

when I start going astray

because of the simplicity and

regularity on this thing they got an incredible

ratio of controls day to

act action state

you know what it is but

I think this is like 25% it's like 75%

maybe it's

30 70 that's about almost opposite

from what it is in most chips

most chips at least half of the stuff

that's on that ship being in control gates one kind

of another so control is very very simple here almost

all of the silicon area on this thing is used for doing real

things and because of that on a forty thousand transistor

chip they could build a full

32-bit machine that's

what they did so this is 32 bits wide

and survive

it really into two parts

and the

uninteresting part is sort of this part here

and that is where

things are actually done there

are bunches of latches and ALU

shifters shifters first I

Wi-Fi recall and

some buffers and so

forth that's where stuff actually gets done

on that ship then this part of

the chip has I think 132

registers and if I remember the number correctly these

registers are mapped registered registers

words they're not registers you can get to directly

but their registers that are used implicitly

by the code in the in the machine and the mapping

is kind of clever let's see if I can remember it

he register

space for each process is 32

so you can get to 32 registers

if I if I'm correct I believe nine

nine of these are

and the

other 24 are local to

each subroutine

then somebody thought of a real clever idea this

is an incredibly clever

yeah they had two problems they hadn't saw one problem

is how do you pass parameters back for instance

parameters are passed in the top of the stack just

as opera and the be 5000

and the other problem the problem

is how can I map these guys

in here in a very rapid way so I

don't have to futz around I want to have 0 over again somebody

got to what we should do is think

of these registers as

being overlaid like this

so

I guess they grow from the bottom to the top so let's do it that way

here's 24

what we do at 60

we're 16

cuts off we overlap the next set of 24

okay

result result of that is that these

two guys share six registers those

registers are what it used for passing parameters forward

and back these are if you will the in/out

variables of the Pascal type

thing that they're doing and thus on it

goes now what that means is that the

start address is of each register block that you care about

is on a boundary

that can be gotten to you by straight logic

okay in other words they only in

order to get one of these offsets they only have to or a

number in to what ever

they don't have to do any actual additions

just or whatever if you want

to get variable five and this guy

here variable

5 this guy you're just oaring a zero 101

into whatever

one this this thing is in this array

so there's no add here

to calculate any of these things just slam the things together

and whichever one is active goes

up and down how many let's see how

many of these is what is this 10 frames

or something 10 frames 12 frames

everybody know 16 so it's probably

9 frames or something like that so you could store

nine frames and of course in a language like

Pascal which is almost never used recursively

this is a perfectly reasonable

depth there's

statistics showed that most processes that were

written and passed down especially in C never

went to more than a depth like this so it means that the thing

never touches storage for all of its temporaries so

it just runs like a bat out of hell

right this

this particular this particular scheme is not nearly

as good for less for instance

for several reasons we'll look at it's not very good for

small target because as we noted the small has

both an object state and an activation state there's

no place in here for the object state it

has to stay outside so if you want to use this chip for

doing something like small talk then you have to

do something to it the

other drawback on this is that the code on

this thing what he thought was is

I want the object code to be like micro code so

the code is humongous every instruction is 32 bits

long whether you want it to be or not that's ridiculous okay

that is what the does that is what the design of this chip

is so if you're willing to put up with 32 bit code

on every squad this thing

will run each instruction that

it has in one cycle through

the thing so there's no appreciable overhead on any of the

calculations

that take place in here that use this thing the cycle

on this thing could be I think the chips that they're making now their first

ones are are executed 200

nanoseconds of crack and the design

this thing was to execute instructions at 100 nanosecond

crawling their way up to that now it's quite easy if you see

there's nothing but the thing is doing look at a 68000

which is less than twice the size of this and it's

a nightmare this thing is just laid out like Manhattan

Island and it's very very simple

the control is very simple so

now

you look at this thing you have

thinking thoughts because a hundred nanoseconds an instruction time

is not that bad especially if you know ahead of time that most

of those instructions are really working for you you've got something

that you're worth it's really worthwhile thinking about building

we know

or at least we pay lip service to the idea that we want

higher-level languages here but very high level

languages so the machine that simply execute

spaz gal and see very rapidly it's

not nearly as interesting and Atari research

as it is in HDD turns out

Apple is very interested in this machine they have been courting Patterson

for some time because

this is their language is

a Lisa is

a language that is

basically Pascal with classes okay

so those some of the things that small talk

so what can you do to this check

I just I think what

I'm gonna do is just give you a couple of hints and into

the next one one of these that we do on this thing will

go through the schema more detail one

of the things that we can do

make it a little bigger

what we sure would like

to feed in here our bike coats

these things like those

code syllables one of the most ridiculous things

in the world if you have a reduced instruction set

is to have the instructions be 32 bits long

why can't we make use of the fact that we're

actually doing a higher-level language unless we know where

is going to be it's really all relative addressing so

we'd like to we'd like to use that but

to keep the control simple at some place

we have to have a PLA that will translate one of these

guys to the wider paths necessary to control everything so

one of the simplest things that we can do here

is to

think of this area as being an instruction cache

now in all the all

of the studies on caching it's only a few facts have

remained one of the caching works where paging doesn't because

ratios between the two memory speeds are different

okay that's basically what it comes

to catching has very small objects

and the ratios are usually no worse than a factor of 10

so it works paging has very large objects

usually in the ratios or factors of thousand or a hundred so

it doesn't work the other thing that's

known about caching is that code behaves much better

than data does like

a reasonable set up machine code

has the

a very important feature that you

override it in the cache you never have to store it back

out so the cache is just sucking stuff in

then the question is what is the cache look like is

it a full of sociation is it a overlapping

code segment

thing that held has to do with how complex

the Association paths for interpreting

addresses are that went down this way this control

side here right up here would

be a barrel shifter

actually limited barrel shifter

that is taking

these syllables and feeding

them can think of these things is really proud of the

variable size maybe 8 16 and 32 besides

things what

it's doing is looking at the leading order bits of whatever's there

making a decision as to how much it's going to map down

through the PLA that's going to cause control to

determine standard sizes

true enough

yeah we should mention besides

being a general man about

town and a good fellow Steve Saunders thesis

was on minimization of code size through

various kinds of compiling techniques and by

going as he says by going to a variable

length by taking the language that you got and going a couple

of steps further than the risk people you can build a compiler

that will generate optimal size code which

can be peeled out just as easily as

variable size of a few things definitely

true providing that

the largest size is no larger than this

otherwise everything else is really quite easy

okay the two more things that you have to do to

make small talk or a language like

it work on this chip there has to be

a place where instance state is put I'm

going to talk about that more next time let's just think that

let's put their turns out in a

language like small talk there's almost no depth of stack

I think you can sort of because

control is always passing sideways to objects you're

rarely going deep you're going sideways all

the time and so the typical stack

depth in the small talks is less than five

so you need to have a cache for

instance state here

we can talk about what that looked like later

on then the final thing that we have to have to make

a scheme like this work for small talk or Lisp is

we have to let arithmetic run quickly

or another way of

putting it there is a subset of these byte codes that

have to fulfill two purposes one

is they have to refer to

operands that are protected like in the B

5000 okay these guys better

not know they're going after the integer or all is

lost so that

hey're picking up it has to be something that was protected by

one of those flag bits somehow and

cause an interrupt of what I picked it up as an address to

something more interesting in an integer okay

that procedure in Lisp is called unboxing

typical Lisp we're

small talk address space so what a small

talk is laid out in small talk 76

16 bits

pointers

so that gives

you a range of 65,000 things you can refer to

each

thing knows how long it is and the storage

manager knows where they are okay so these things

are actually names the average object

size in Smalltalk 76 was about

20 bytes so this

gives you 20 bytes

is about four and a half bits so

this gives you about a 20 and 1/2 bit address

space okay

equivalent objects does everybody understand

I'm sure in

other words so we we could refer to about a million words

using only 16

bits for a pointer size

turns out you'd like to refer

to more than a million words

ixteen is maybe a

power of two but boy that's all it is

everything else is wrong 24

is much better turns out but

then in order to there's

certain small things that you'd like to have implicitly encoded

empty addresses in particularly

encoded I forget what the way wound up

but at one point it was like - mm the integers between

- mm + mm

were encoded into a section

of that that is they never existed as explicit objects and storage

assistant

and resse is in this range that these things are actually integers

that it should unbox these are called boxed integers

there's a box around them

other images were actually encoded as real objects

part

smaller okay

small arms in this

okay and the

so whenever these are encountered

they have to be translated into something

that's a real integer that can be go through the

operation that translation has to be done at the last moment 3600

has a fair amount of circuitry to do that

one thing we could do on this

system what's supposed

to be moseying the thing up to 32 bits wide

like this machine is now

I don't think we feel too bad

about having a flag bit

the fine bit can be very simple in

fact I think in the scheme that I came up with

I put the flag bit forward there

and let it be zero if it

okay

and if it was if it wasn't one then the thing

else in the other words we give up half the address space

for numbers it's like what to be 5,000

does and then I think we can see

that if

we decide to have a particularly simple encoding between direct

operands and addresses

and by the way I

think you all realize that when I say one bit I mean

but one bit is enough for doing all

operating system things we want to do and essentially they're

what we're what we need to do is to have some of this

control state let the action

go ahead because

after the ALU there's this latch here

that has to be in the right state in order for the

operation to mean anything okay and so

one way of handling this problem of how can we write an

system in a really high-level language is

just say every time we do a primitive operator like

plus we realize that the plus may have lots

of different meanings the small cog for instance that are probably

25 different meanings for plus 25 different routines scattered

through the microcode and small talk code for plus 150

meanings are print but

there's one plus that better run as fast as the machine

can run it and that is the one that adds two integers

together okay the way to do that on

this machine is to just let

the right here you

get to get a chance to look at both flag bits just

let the operation perceive and

then the decision

whether to recycle is back on the C bus or the BB

bus like this machine has it has to

state of those two bits are if they're both zeros then

you got the right answer they're not both zeros you're going to have to

do something more in which case the way you to do that is

interrupt but then looks at these things more closely

basically ideas you have the generation generality

you're willing to pay for but if what

not general then you wanted to have no appreciable

overhead whatsoever you do

that you now have a machine that will run if this thing runs in 100 nanoseconds

doing what we doing what we said

it will run it'll still run a higher-level language and run all

things that have to work quickly to do an operating system at

that very same speed you've got

a very nice little chip we'll talk about in more detail next

eve probably has some comments

yes you

might mention something about the kinds of encoding

efficiencies that you get when you actually look at

syndrome

pop-pop-pop-pop

them do an operation with all the

attendant shuffling bits around if you

tell tell the operation what the compiler

knows about it namely whether its operands

we're

computed basically have to been pushed

on the stack or whether they're direct

in which case all you feed it is an address and it just gets it

you

can save a lot of Pushpa

that combined with

variable

size fields dynamically variable size fields

four addresses the only

happening locally

known names besides the locality varies

just to do those things straightforwardly

roll that together with the overlapping

in fact that's where the small named

what kind of packing efficiencies did

you get in here thesis over listen

bliss 11

was taken as justice unity

ctype language right yeah

thousand

benchmark immunity

my thesis stuff without any

optimization that was the set point just

just not customizing

straightforward nation on this variable

and that's that many fewer benches form

with that much smaller phone sessions

that's

why I say 30% like this the reason

this is a very nice for Atari this

is a very nice area and

generally speaking there are other things you'd rather optimize

first like the graphics situation but

once you sort

you can do there this is the next interesting thing which

is how can you run say

artificial intelligence programs of some scope on

a consumer level machine without going

six year you know the double cycle

to get enough memory on the things

this is one way of doing it small

talk was predicated on the idea that there would be some

sort of solid state swapping device like a bubble memory

that would match

up so it turns out a bubble memory is a perfect

device for the particular algorithm that we developed a

small talk 76 because it's not too fast

it turns out it works better

when the on a crummy disc it does huh yeah

what you have is not as good as you'd

be in a particular way we went about doing things where

it's much better and you

get a system that can do real live no IRA is PI

system which is an enormous enormous

system done in a small time he uses everything in them that the dam

system had there's huge millions of bytes of code swapped

in 80k bytes and it ran quite

acceptable e running byte

codes at the rate of about 300,000 per

okay this thing can run what we call byte codes which are those fast ones

at the rate of 10 million per

speaking of aortic recep another piece of work

diversity

this kind of a mechanism which is in fact a general

simple processor the only simple system

that one should wire into it is the exceptionally simple

one of small integer array

there are other simple powerful

subsystems in general simple systems

there are more primitives

out there that ought to run faster we have yeah

absolutely I'd like to I'd like to

some of those some

of the stuff that underlies set

set theory

really be useful yeah well as a

would have the same kind of disadvantage than 55-thousand he had that

programmer would realize that he needed it

but

I think there are a few

simple systems

on a different style than small

integers that would turn out to be the right ones

or a lot of what we do but

I think that you know the this

whole coprocessor thing it's not done very well right now

I don't

I don't think that's right I think

it should be you know you ought

to be a mother s you

that there are that

there are coherent small

simple systems will provide useful basis for things

address arithmetic is really where all the action

is going on and all the stuff small pogrom

is okay but there are a few other things like

hashing functions okay those

only become address or it would take through the contortions

or not why not pick one that's that's Universalist

and build it in reverse so that hashing

is a cheap thing just like indexing

okay think of the power ahead gets you also

reverse rotations for lost

transforms and teas and stuff we

know my list of what I came to Atari I first

started thinking about designing a processor

then I gradually dawned on me that a processor

is actually very low on the totem pole priorities

priorities I came up with us

at the number one in the number two priorities

have to do with sort of frame buffer

and graphics

chip a deadly embrace

between those two because they

trade off against each other so much number three is doing

storage management

ell

you one thing we trade trade this chip and

no storage manager for a 286

the storage manager chip any day of the week

and then finally down here is something

like this is a reasonable CPU that

will actually do something for you one of these

interesting things you can get

efficiency here and then give up a factor of 200

once you start swapping if you haven't worked

out a thing so it's it's a question of where

getting probably these things is that there's so much easier to understand

than these things that's

why no hardly anybody works on these it's nobody

said nobody really understand you build one of these things and

you don't build it programmable you're dead

Difference between revisions of "Processors in Programming Languages"

Latest revision as of 00:13, 27 November 2021

Navigation menu

Personal tools

Namespaces

Variants

Views

More

Search

Tool box

Tools

@@ Line 5: / Line 5: @@
 |autoresize=false
 }}
+<subtitle id="0:1:1">really</subtitle>
+<subtitle id="0:1:4"> come in a version that</subtitle>
+<subtitle id="0:1:7">sorry</subtitle>
+<subtitle id="0:1:10"> trickle its way through but Burroughs had this distressing</subtitle>
+<subtitle id="0:1:13"> set of traits</subtitle>
+<subtitle id="0:1:16"> of having the best hardware architects</subtitle>
+<subtitle id="0:1:19"> really in the world for many years and</subtitle>
+<subtitle id="0:1:22"> they could never ever implement these designs partly</subtitle>
+<subtitle id="0:1:25"> because the hardware architects are a little bit purest</subtitle>
+<subtitle id="0:1:28"> major</subtitle>
+<subtitle id="0:1:31"> figure here is Bob Barton who is a</subtitle>
+<subtitle id="0:1:34"> well-known iconoclast</subtitle>
+<subtitle id="0:1:37"> remarkable man he's I think</subtitle>
+<subtitle id="0:1:40"> he said still</subtitle>
+<subtitle id="0:1:49">my first this is B five thousands the</subtitle>
+<subtitle id="0:1:52">third machine I ever learned I learned it in 1962</subtitle>
+<subtitle id="0:1:55"> I happened to be in the Air Force and</subtitle>
+<subtitle id="0:1:58"> they had a Burroughs 220 Burroughs</subtitle>
+<subtitle id="0:2:1"> 220 was this huge vacuum tube</subtitle>
+<subtitle id="0:2:4"> thing with 5 or</subtitle>
+<subtitle id="0:2:7"> bigger than this room and you could heat coffee</subtitle>
+<subtitle id="0:2:10"> on top of it wait</subtitle>
+<subtitle id="0:2:13"> old machine and had a couple of interesting features on it that actually</subtitle>
+<subtitle id="0:2:16">partially triggered off some of the ideas to be 5000</subtitle>
+<subtitle id="0:2:19"></subtitle>
+<subtitle id="0:2:22"> Martin first</subtitle>
+<subtitle id="0:2:25"> was really a philosopher he was a philosophy</subtitle>
+<subtitle id="0:2:28"> major at the University of Connecticut and</subtitle>
+<subtitle id="0:2:31">gotten interested in proving he's already reading philosophy</subtitle>
+<subtitle id="0:2:34"> books and books not logic</subtitle>
+<subtitle id="0:2:37">a man of parts</subtitle>
+<subtitle id="0:2:40"> and I guess he started coding around</subtitle>
+<subtitle id="0:2:43"> 1951 or sellin</subtitle>
+<subtitle id="0:2:46"> boroughs bought a company called datatron</subtitle>
+<subtitle id="0:2:49"> and they set up</subtitle>
+<subtitle id="0:2:52"> they've made a machine called the 204</subtitle>
+<subtitle id="0:2:55"> in the 2:05 were true run taste machines</subtitle>
+<subtitle id="0:2:58"> and a 205 in the borough's 220 was the same</subtitle>
+<subtitle id="0:3:1">xcept that the tool fire was completely based on a drum</subtitle>
+<subtitle id="0:3:4"> it had the registers on the drum also many</subtitle>
+<subtitle id="0:3:7"> copies of the residues just placed around the drum so</subtitle>
+<subtitle id="0:3:10">that you didn't have to wait for a full revolution this way to get</subtitle>
+<subtitle id="0:3:13"> things in those days and</subtitle>
+<subtitle id="0:3:16"> they set up this whole latch up in a Safeway</subtitle>
+<subtitle id="0:3:19"> store in Pasadena partly</subtitle>
+<subtitle id="0:3:22"> because of that location they formed the early</subtitle>
+<subtitle id="0:3:25"> association with Cal Tech back</subtitle>
+<subtitle id="0:3:28"> canoes first machine was the</subtitle>
+<subtitle id="0:3:31"> 205 and the 220 and this</subtitle>
+<subtitle id="0:3:34"> horrible thing known as mix in the</subtitle>
+<subtitle id="0:3:37"> canoes books is a very reminiscent</subtitle>
+<subtitle id="0:3:40"> of the 205 into 20 in</subtitle>
+<subtitle id="0:3:43"> other words it was a decimal machine</subtitle>
+<subtitle id="0:3:46">ach position</subtitle>
+<subtitle id="0:3:49"> had</subtitle>
+<subtitle id="0:3:52"> 10 decimal digits</subtitle>
+<subtitle id="0:3:58">and a sign digit and each</subtitle>
+<subtitle id="0:4:1"> one of these had four bits in it so I had</subtitle>
+<subtitle id="0:4:4"> 44 bit words and the sign</subtitle>
+<subtitle id="0:4:7"> position for some</subtitle>
+<subtitle id="0:4:10">reason known only to them and to God they</subtitle>
+<subtitle id="0:4:13"> decided to have all ten possibilities</subtitle>
+<subtitle id="0:4:16"> for the sign position okay</subtitle>
+<subtitle id="0:4:19">and because there's only plus and minus and then eight more they</subtitle>
+<subtitle id="0:4:22"> decided to assign some meaning to those it was</subtitle>
+<subtitle id="0:4:25">meaning assigned to those extra sign positions that</subtitle>
+<subtitle id="0:4:28"> that led to</subtitle>
+<subtitle id="0:4:31">ideas in the be 5,000 I won't go through the whole history but it's very</subtitle>
+<subtitle id="0:4:34">interesting to watch how these ideas come about one of the sign positions</subtitle>
+<subtitle id="0:4:37"> was saying position six which marked</subtitle>
+<subtitle id="0:4:40"> this thing as a piece of code</subtitle>
+<subtitle id="0:4:43"> okay and in fact the</subtitle>
+<subtitle id="0:4:46"> the machine would not</subtitle>
+<subtitle id="0:4:49"> if you if you tried to</subtitle>
+<subtitle id="0:4:52"> fetch through something if you</subtitle>
+<subtitle id="0:4:55"> tried to fetch a piece of code there</subtitle>
+<subtitle id="0:4:58">for instance they were trying it would we try</subtitle>
+<subtitle id="0:5:1"> and do a job in other</subtitle>
+<subtitle id="0:5:4"> words they both protected things in a limited way in</subtitle>
+<subtitle id="0:5:7"> memory and there are certain side effects that can be triggered off by</subtitle>
+<subtitle id="0:5:10">touching things in memory it was that idea which is</subtitle>
+<subtitle id="0:5:13"> being played around with in the 50s that that led to part of what</subtitle>
+<subtitle id="0:5:16"> to be 5,000 was okay the most important</subtitle>
+<subtitle id="0:5:19"> thing about this is</subtitle>
+<subtitle id="0:5:22"> that in 57 and 58 there</subtitle>
+<subtitle id="0:5:25"> is a language developed called Algol 58</subtitle>
+<subtitle id="0:5:28"> and alcohol</subtitle>
+<subtitle id="0:5:31"> 58 was a reaction</subtitle>
+<subtitle id="0:5:34"> sort of a purist reaction of the Europeans</subtitle>
+<subtitle id="0:5:37"> Plus Alan Perlis a few other people in this country</subtitle>
+<subtitle id="0:5:40"> too Fortran so they thought</subtitle>
+<subtitle id="0:5:43"> was absolutely detestable but a Fortran had come</subtitle>
+<subtitle id="0:5:46">arlier so they sat down and designed this thing it was cleaner</subtitle>
+<subtitle id="0:5:49"> and except for the fact of not</subtitle>
+<subtitle id="0:5:52"> having data structures except for arrays and</subtitle>
+<subtitle id="0:5:55"> strings and integers and</subtitle>
+<subtitle id="0:5:58"> floating point typical</subtitle>
+<subtitle id="0:6:1"> alcohol data structures but not having Pascal</subtitle>
+<subtitle id="0:6:4"> data structures this language is essentially what Pascal is</subtitle>
+<subtitle id="0:6:7"> in other words it has one level</subtitle>
+<subtitle id="0:6:10"> of definition</subtitle>
+<subtitle id="0:6:13"> for global</subtitle>
+<subtitle id="0:6:19">procedures</subtitle>
+<subtitle id="0:6:22">etc</subtitle>
+<subtitle id="0:6:25">and [Music]</subtitle>
+<subtitle id="0:6:28"> the some of the versions of this I could</subtitle>
+<subtitle id="0:6:31">o recursive subroutine calls and other ones couldn't the separate procedures</subtitle>
+<subtitle id="0:6:34"> have local variables</subtitle>
+<subtitle id="0:6:37">there are a couple other features</subtitle>
+<subtitle id="0:6:40">language it was basically a very simple but vanilla</subtitle>
+<subtitle id="0:6:43"> language and Barton</subtitle>
+<subtitle id="0:6:46">head of the project to put this on the burst to</subtitle>
+<subtitle id="0:6:49"> 20 and doing so they</subtitle>
+<subtitle id="0:6:52">a thing that had only been really discovered in</subtitle>
+<subtitle id="0:6:55"> 56 57 by by</subtitle>
+<subtitle id="0:6:58"> a few people in Europe which is called the stack the</subtitle>
+<subtitle id="0:7:1">staff was originally invented for doing compiling and</subtitle>
+<subtitle id="0:7:4"> you have to realize that back in these days in 1952-53</subtitle>
+<subtitle id="0:7:7"> when they're still thinking about compiling</subtitle>
+<subtitle id="0:7:10">arithmetic expressions this was considered to be an AI problem</subtitle>
+<subtitle id="0:7:13"> okay</subtitle>
+<subtitle id="0:7:16"> what Fortran was was the world's first automatic</subtitle>
+<subtitle id="0:7:19"> programming system that's what it was called automatic</subtitle>
+<subtitle id="0:7:22"> programming was how to get away from writing having</subtitle>
+<subtitle id="0:7:25">ive explicit sequence when writing machine code</subtitle>
+<subtitle id="0:7:28"> ok so the first task of automatic</subtitle>
+<subtitle id="0:7:31"> programming was to not have to specify sequence</subtitle>
+<subtitle id="0:7:34"> for thanks and the</subtitle>
+<subtitle id="0:7:37"> first parser is back in the early 50s actually</subtitle>
+<subtitle id="0:7:40"> went in and parenthesize effect Fortran yeah</subtitle>
+<subtitle id="0:7:43"> they went and actually put all the parentheses in to</subtitle>
+<subtitle id="0:7:46"> the source code okay</subtitle>
+<subtitle id="0:7:49"> and then went through and removed all the parentheses by</subtitle>
+<subtitle id="0:7:52"> going okay was unbelievable but</subtitle>
+<subtitle id="0:7:55"> that this is the in the days before it be an F there's</subtitle>
+<subtitle id="0:7:58"> no such thing as a compiler compiler so</subtitle>
+<subtitle id="0:8:1"> some Germans</subtitle>
+<subtitle id="0:8:4"> pop up Bower and</subtitle>
+<subtitle id="0:8:7"> a couple of other people</subtitle>
+<subtitle id="0:8:10"> you er can't remember the</subtitle>
+<subtitle id="0:8:13"> other guy Sam Wilson says yeah Santa Valerie</subtitle>
+<subtitle id="0:8:16">invented</subtitle>
+<subtitle id="0:8:19"> a stack algorithm for doing compiling</subtitle>
+<subtitle id="0:8:22"> arithmetic expressions that used precedents it was the first</subtitle>
+<subtitle id="0:8:25">precedents algorithm Martin just loved this he just</subtitle>
+<subtitle id="0:8:28"> sucked this up and</subtitle>
+<subtitle id="0:8:31"> the basic idea I won't go</subtitle>
+<subtitle id="0:8:34">you know you either know it or you don't at</subtitle>
+<subtitle id="0:8:37"> this point this is part of the</subtitle>
+<subtitle id="0:8:40">that used to be important for people to know but</subtitle>
+<subtitle id="0:8:43"> is yeah the noise now as far as I'm concerned</subtitle>
+<subtitle id="0:8:46"> but basically the idea is you kept</subtitle>
+<subtitle id="0:8:49"> opera Diana from the arithmetic expression you kept operands</subtitle>
+<subtitle id="0:8:52"> if you had something like a plus B times C as</subtitle>
+<subtitle id="0:8:55"> you chucked your way through this thing</subtitle>
+<subtitle id="0:8:58"> you would have shoved into</subtitle>
+<subtitle id="0:9:1"> the stack everything</subtitle>
+<subtitle id="0:9:4"> up until the time side which is the</subtitle>
+<subtitle id="0:9:7">something and do something with the city and the B and</subtitle>
+<subtitle id="0:9:10"> either have to sometimes they have</subtitle>
+<subtitle id="0:9:13"> two stacks you put the operators and 170 you plus there'd be</subtitle>
+<subtitle id="0:9:16"> an A to B maybe</subtitle>
+<subtitle id="0:9:19"> you push it all the way down so you'd have time</subtitle>
+<subtitle id="0:9:22"> silent CPA here and</subtitle>
+<subtitle id="0:9:25"> as soon as you could find out there's</subtitle>
+<subtitle id="0:9:28"> nothing more for you to do over here and then you know you could generate</subtitle>
+<subtitle id="0:9:31"> code for these guys okay</subtitle>
+<subtitle id="0:9:34">ou kept on going through in the stack kept</subtitle>
+<subtitle id="0:9:37"> these intermediate results bargain very quickly realized that</subtitle>
+<subtitle id="0:9:40"> a stack could be a dandy idea de for doing</subtitle>
+<subtitle id="0:9:43"> subroutine calls in</subtitle>
+<subtitle id="0:9:46"> fact they were just starting to mumble about the idea of recursive</subtitle>
+<subtitle id="0:9:49">subroutines for doing problems</subtitle>
+<subtitle id="0:9:52"> so when they implemented the system on the on</subtitle>
+<subtitle id="0:9:55"> the burros b20 they had the idea of</subtitle>
+<subtitle id="0:9:58"> that they were</subtitle>
+<subtitle id="0:10:1"> going to get enough do</subtitle>
+<subtitle id="0:10:4"> things in this order and then generate code through</subtitle>
+<subtitle id="0:10:7"> an assembler multi pass assembler and</subtitle>
+<subtitle id="0:10:10"> they're going to use a stack for subroutine calls they</subtitle>
+<subtitle id="0:10:13"> also had the idea that this</subtitle>
+<subtitle id="0:10:16"> group of global contact should probably be</subtitle>
+<subtitle id="0:10:19"> represented as some kind of table in storage</subtitle>
+<subtitle id="0:10:25">that had it in either pointers to</subtitle>
+<subtitle id="0:10:28"> arrays allocated somewhere else or</subtitle>
+<subtitle id="0:10:31"> had numbers in them</subtitle>
+<subtitle id="0:10:34"> and in this particularly</subtitle>
+<subtitle id="0:10:37">implementation the code had to know what these were supposed to</subtitle>
+<subtitle id="0:10:40"> be okay so one</subtitle>
+<subtitle id="0:10:43">fine guy I don't know when it was 59 or so</subtitle>
+<subtitle id="0:10:46"> after all this had been done</subtitle>
+<subtitle id="0:10:49"> Barton was reading a book</subtitle>
+<subtitle id="0:10:52"> by Lucchese which logic and</subtitle>
+<subtitle id="0:10:55"> what Lucchese which had done is in order to</subtitle>
+<subtitle id="0:10:58"> do certain logical manipulations of things which requires symbolic</subtitle>
+<subtitle id="0:11:1"> manipulation it invented a notation that</subtitle>
+<subtitle id="0:11:4"> had no parentheses</subtitle>
+<subtitle id="0:11:7"> and in fact it was a</subtitle>
+<subtitle id="0:11:10">I think Lucchese which is</subtitle>
+<subtitle id="0:11:13"> notation was a prefix notation can't</subtitle>
+<subtitle id="0:11:16"> remember can you remember Steve can't</subtitle>
+<subtitle id="0:11:19"> remember whether this prefix anyway the two possibilities for an</subtitle>
+<subtitle id="0:11:22"> expression like this or either saying</subtitle>
+<subtitle id="0:11:25"> something like BC times a</subtitle>
+<subtitle id="0:11:28">nd</subtitle>
+<subtitle id="0:11:31"> yeah I think the case which is was actually prefix</subtitle>
+<subtitle id="0:11:34"> which there are various ways of writing</subtitle>
+<subtitle id="0:11:37"> that you can say x b c</subtitle>
+<subtitle id="0:11:40"> plus a or plus</subtitle>
+<subtitle id="0:11:43"> a times b SI</subtitle>
+<subtitle id="0:11:46"> prefix use a stack</subtitle>
+<subtitle id="0:11:49"> until you get to something it will actually</subtitle>
+<subtitle id="0:11:52"> has a couple of operands</subtitle>
+<subtitle id="0:11:55"> and think</subtitle>
+<subtitle id="0:11:58"> about Barton is one of these guys has a mind like a net</subtitle>
+<subtitle id="0:12:1"> almost completely</subtitle>
+<subtitle id="0:12:4"> intuitive</subtitle>
+<subtitle id="0:12:7"> your life because he never knew</subtitle>
+<subtitle id="0:12:10"> when he was going to have a good idea in fact he lived for quite a</subtitle>
+<subtitle id="0:12:13">nd he feared he was never going to have another the</subtitle>
+<subtitle id="0:12:16"> fact he had good ideas all the time I used to absolutely</subtitle>
+<subtitle id="0:12:19"> destroy PhD theses at</subtitle>
+<subtitle id="0:12:22"> Utah where I ran into him because</subtitle>
+<subtitle id="0:12:25"> he'd be working with a thesis student for six months and</subtitle>
+<subtitle id="0:12:28"> all of a sudden he'd wake up in the morning with a total</subtitle>
+<subtitle id="0:12:31"> solution to that thesis and that was the end of that</subtitle>
+<subtitle id="0:12:34"> thesis and so the smart thesis students</subtitle>
+<subtitle id="0:12:37"> like me stayed away from them we</subtitle>
+<subtitle id="0:12:40"> didn't want him to solve our problem and</subtitle>
+<subtitle id="0:12:43"> even though I was a natural</subtitle>
+<subtitle id="0:12:46"> to be his thesis student I went to Dave Evans and</subtitle>
+<subtitle id="0:12:49"> Barton would not talk for me for five years because of that</subtitle>
+<subtitle id="0:12:52"> that's the kind of guy is he's sort of like</subtitle>
+<subtitle id="0:12:55"> William F Buckley to talk to there's</subtitle>
+<subtitle id="0:12:58"> an incredible command in the English language and he's very</subtitle>
+<subtitle id="0:13:1"> very snide delightfully snide</subtitle>
+<subtitle id="0:13:4"> it's a Barton okay</subtitle>
+<subtitle id="0:13:7"> when this when</subtitle>
+<subtitle id="0:13:10"> Bart made the connection between this and this</subtitle>
+<subtitle id="0:13:13"> his mind just started working and</subtitle>
+<subtitle id="0:13:16"> in 48 hours he had designed to be 5,000</subtitle>
+<subtitle id="0:13:19"> okay it was one continuous hit according</subtitle>
+<subtitle id="0:13:22">was just literally stayed up for 48 hours and everything</subtitle>
+<subtitle id="0:13:25"> fell into place I'll certainly give you an</subtitle>
+<subtitle id="0:13:28"> idea the things that led into it</subtitle>
+<subtitle id="0:13:31"> was the Barton's basic snobbery that</subtitle>
+<subtitle id="0:13:34"> said I never want to write machine code again higher-level</subtitle>
+<subtitle id="0:13:37">anguages are a good idea then by god what's right in them</subtitle>
+<subtitle id="0:13:40"> never want to write an operating system in the lower level</subtitle>
+<subtitle id="0:13:43"> language never want to write anything in</subtitle>
+<subtitle id="0:13:46"> the lower level language tomah's</subtitle>
+<subtitle id="0:13:49"> the compilers weren't the</subtitle>
+<subtitle id="0:13:52"> machines weren't a good environment for this kind of</subtitle>
+<subtitle id="0:13:55"> thing so he had in the</subtitle>
+<subtitle id="0:13:58">back of his mind the idea what let's build a machine to run algal</subtitle>
+<subtitle id="0:14:1"> if we think that's a good language and</subtitle>
+<subtitle id="0:14:4"> in fact the Algol that they built it for was this Algol</subtitle>
+<subtitle id="0:14:7"> 58 B 5000 doesn't have</subtitle>
+<subtitle id="0:14:10"> all the hooks in it for the</subtitle>
+<subtitle id="0:14:13">6006 he came along while they're in midstream</subtitle>
+<subtitle id="0:14:16"> machine so here's here</subtitle>
+<subtitle id="0:14:19"> are some of the things he thought about</subtitle>
+<subtitle id="0:14:25">first thing he did was to</subtitle>
+<subtitle id="0:14:28">say well</subtitle>
+<subtitle id="0:14:31"> I know we're</subtitle>
+<subtitle id="0:14:34"> gonna be running lots of different jobs in fact the first be</subtitle>
+<subtitle id="0:14:37"> 5000 you have to realize in fact most of these machines</subtitle>
+<subtitle id="0:14:40"> had multiple processors on it right from the beginning</subtitle>
+<subtitle id="0:14:43"> teeny little machine -</subtitle>
+<subtitle id="0:14:46"> it was only a 4k 48 50 words had</subtitle>
+<subtitle id="0:14:49"> swapped off a 32k drunk</subtitle>
+<subtitle id="0:14:52"> this is a mainframe computer</subtitle>
+<subtitle id="0:14:55">and they don't knew they were gonna have to</subtitle>
+<subtitle id="0:14:58"> do lots of fun lots of batch jobs and do compilations</subtitle>
+<subtitle id="0:15:1"> and all those things one of the things that always happened in those days</subtitle>
+<subtitle id="0:15:4"> as a program would start writing into somebody</subtitle>
+<subtitle id="0:15:7"> else's programs core now would lead to strange</subtitle>
+<subtitle id="0:15:10"> results and that</subtitle>
+<subtitle id="0:15:13"> was not a good thing so one of things that they wanted to do is</subtitle>
+<subtitle id="0:15:16"> to protect so we decided that</subtitle>
+<subtitle id="0:15:19"> the</subtitle>
+<subtitle id="0:15:22">consequences I don't know how he all came to all of us at</subtitle>
+<subtitle id="0:15:25"> once because the interesting thing about to be 5000 is not that</subtitle>
+<subtitle id="0:15:28"> it has a stack that was the least interesting</subtitle>
+<subtitle id="0:15:31">complete innovation those days there's only one other machine</subtitle>
+<subtitle id="0:15:34"> that has sort of a stack that was called the KDF right</subtitle>
+<subtitle id="0:15:37"> so here's what he did he said</subtitle>
+<subtitle id="0:15:40"> when a program is running</subtitle>
+<subtitle id="0:15:43"> some kind of code here</subtitle>
+<subtitle id="0:15:46">ach</subtitle>
+<subtitle id="0:15:49"> I only have two kinds of things that I'm really worrying</subtitle>
+<subtitle id="0:15:52"> about there are things that denote operations</subtitle>
+<subtitle id="0:15:55"> and those are things that are going to appeal</subtitle>
+<subtitle id="0:15:58"> directly to the machine so those are</subtitle>
+<subtitle id="0:16:1">pretty safe and the only other thing I have to worry about</subtitle>
+<subtitle id="0:16:4"> are things up to note variables I notice he didn't say values</subtitle>
+<subtitle id="0:16:7"> because some higher-level languages</subtitle>
+<subtitle id="0:16:10"> don't have values they have variables everything comes down to looking</subtitle>
+<subtitle id="0:16:13"> like a like a variable and</subtitle>
+<subtitle id="0:16:16"> so he asked himself what is a variable and</subtitle>
+<subtitle id="0:16:19"> a variable actually is</subtitle>
+<subtitle id="0:16:22"> some item in this list here or</subtitle>
+<subtitle id="0:16:25"> some item in the list of the procedure and that's all it</subtitle>
+<subtitle id="0:16:28"> is so he immediately misses came</subtitle>
+<subtitle id="0:16:31"> out of this table already but immediately said</subtitle>
+<subtitle id="0:16:34">there are two kinds of variables are local and global and</subtitle>
+<subtitle id="0:16:37"> all those things are our numbers that are offset</subtitle>
+<subtitle id="0:16:40"> from the beginning of whatever this list is and</subtitle>
+<subtitle id="0:16:43"> since we're going to be running so if</subtitle>
+<subtitle id="0:16:46"> this is the red list here and</subtitle>
+<subtitle id="0:16:49"> this is the red procedure and</subtitle>
+<subtitle id="0:16:52"> over here we have another job that has a green</subtitle>
+<subtitle id="0:16:55"> list and a green procedure</subtitle>
+<subtitle id="0:16:58">than</subtitle>
+<subtitle id="0:17:1"> any particular variable</subtitle>
+<subtitle id="0:17:4"> like this one down here it's</subtitle>
+<subtitle id="0:17:7"> like variable 19 that's</subtitle>
+<subtitle id="0:17:10"> red and this one over here is variable</subtitle>
+<subtitle id="0:17:13"> 19 that's green</subtitle>
+<subtitle id="0:17:16"> completely two different things because they're reference</subtitle>
+<subtitle id="0:17:19"> relative to this guy to this guy</subtitle>
+<subtitle id="0:17:22"> they</subtitle>
+<subtitle id="0:17:25"> said okay that's that's great what we need to have now</subtitle>
+<subtitle id="0:17:28"> is a register that the code can't see the points</subtitle>
+<subtitle id="0:17:31"> to this so that registered</subtitle>
+<subtitle id="0:17:34"> it's called the PRT</subtitle>
+<subtitle id="0:17:40">whenever a piece of program</subtitle>
+<subtitle id="0:17:43"> is running this PRT register is pointing to one of these table</subtitle>
+<subtitle id="0:17:46"> I'm going to draw it as a table map</subtitle>
+<subtitle id="0:18:1">okay and now what code turns out to be is</subtitle>
+<subtitle id="0:18:4"> something that can be rather small in</subtitle>
+<subtitle id="0:18:7">fact this thing I think was up to a thousand law</subtitle>
+<subtitle id="0:18:16">these are 48 that words</subtitle>
+<subtitle id="0:18:19">and so to</subtitle>
+<subtitle id="0:18:22"> worry about any</subtitle>
+<subtitle id="0:18:25"> one of these guys the code for that is only needs</subtitle>
+<subtitle id="0:18:28"> to be ten bits long worry about</subtitle>
+<subtitle id="0:18:31"> that and</subtitle>
+<subtitle id="0:18:34">for various reasons</subtitle>
+<subtitle id="0:18:37">they</subtitle>
+<subtitle id="0:18:40"> could have done this there's whether they say it's really terrible</subtitle>
+<subtitle id="0:18:43">criticize this but you know after 20 years and a few</subtitle>
+<subtitle id="0:18:46"> things have been discovered but</subtitle>
+<subtitle id="0:18:49"> they decide also to make the operator</subtitle>
+<subtitle id="0:18:52"> set be 10 bits long so</subtitle>
+<subtitle id="0:18:55"> they could have a thousand operators never</subtitle>
+<subtitle id="0:18:58"> only had more than a few and then to distinguish these two</subtitle>
+<subtitle id="0:19:1"> there are a couple of extra bits</subtitle>
+<subtitle id="0:19:4"> on as headers that told you what kind of code symbols</subtitle>
+<subtitle id="0:19:7"> these were four kinds of code syllables</subtitle>
+<subtitle id="0:19:10">if I can still remember these</subtitle>
+<subtitle id="0:19:13"> there's an operator</subtitle>
+<subtitle id="0:19:19">I think I want to get to use three of them</subtitle>
+<subtitle id="0:19:22"> is basically</subtitle>
+<subtitle id="0:19:25"> the operator a what is called a value</subtitle>
+<subtitle id="0:19:28"> call and what is called a</subtitle>
+<subtitle id="0:19:31"> name called</subtitle>
+<subtitle id="0:19:34">I'll</subtitle>
+<subtitle id="0:19:37"> tell you what those are in a second</subtitle>
+<subtitle id="0:19:40"> so code in this machine was 12</subtitle>
+<subtitle id="0:19:43"> bits long because it had</subtitle>
+<subtitle id="0:19:46"> 48 bit words the</subtitle>
+<subtitle id="0:19:49"> register up here for</subtitle>
+<subtitle id="0:19:58">would hold for instructions</subtitle>
+<subtitle id="0:20:1"> at a time so to have a little instruction cache on</subtitle>
+<subtitle id="0:20:4"> it and just attach those is one of the consequences</subtitle>
+<subtitle id="0:20:7"> of e 5000 and only have to cycle memory every for instructions</subtitle>
+<subtitle id="0:20:16">now going back to how</subtitle>
+<subtitle id="0:20:19">executed Barton quickly discovered</subtitle>
+<subtitle id="0:20:22"> that going to post fix is much more efficient</subtitle>
+<subtitle id="0:20:25"> then he asked himself how</subtitle>
+<subtitle id="0:20:28"> am I going to implement the stack I think the first way he thought</subtitle>
+<subtitle id="0:20:31"> of it is that he would simply have another</subtitle>
+<subtitle id="0:20:34"> register here called the s register</subtitle>
+<subtitle id="0:20:37"> that would point into the top of memory</subtitle>
+<subtitle id="0:20:40"> and there would be</subtitle>
+<subtitle id="0:20:43">the</subtitle>
+<subtitle id="0:20:46"> stack then he realized he needed a couple</subtitle>
+<subtitle id="0:20:49"> of registers to hold stuff</subtitle>
+<subtitle id="0:20:52">was going to go through the arithmetic part of the part</subtitle>
+<subtitle id="0:20:55"> of the system and so put in two registers</subtitle>
+<subtitle id="0:20:58"> two Hardware registers now actually</subtitle>
+<subtitle id="0:21:1"> what I should do is</subtitle>
+<subtitle id="0:21:4"> let's be consistent here</subtitle>
+<subtitle id="0:21:7">put the staff like this</subtitle>
+<subtitle id="0:21:19">okay so I put in a couple of hardware registers that</subtitle>
+<subtitle id="0:21:22"> were logically the top of the stack called the a and B registers</subtitle>
+<subtitle id="0:21:25"> the a and B registers had</subtitle>
+<subtitle id="0:21:28"> an extra bit that marked whether there was something</subtitle>
+<subtitle id="0:21:31"> in the register or not okay</subtitle>
+<subtitle id="0:21:34"> let's call the presents bidder</subtitle>
+<subtitle id="0:21:37">so</subtitle>
+<subtitle id="0:21:40"> the idea was if you chugged up to a-plus</subtitle>
+<subtitle id="0:21:43"> and there</subtitle>
+<subtitle id="0:21:46"> wasn't a + requires two operands and both</subtitle>
+<subtitle id="0:21:49"> of these guys weren't on this this</subtitle>
+<subtitle id="0:21:52"> machine would know to cycle the stack to make sure there are two operands</subtitle>
+<subtitle id="0:21:55"> in the registers so</subtitle>
+<subtitle id="0:21:58">did the most efficient thing that it could</subtitle>
+<subtitle id="0:22:1"> would only cycle a stack when absolutely</subtitle>
+<subtitle id="0:22:4"> necessary to memory that all happened automatically</subtitle>
+<subtitle id="0:22:7"> okay so</subtitle>
+<subtitle id="0:22:13"></subtitle>
+<subtitle id="0:22:16"> I'm very logical to think of these these</subtitle>
+<subtitle id="0:22:19"> things are called syllables the code syllables</subtitle>
+<subtitle id="0:22:22"> would have a register to know</subtitle>
+<subtitle id="0:22:25"> what this was called but I'll call it was either called C or</subtitle>
+<subtitle id="0:22:28"> P or something like that</subtitle>
+<subtitle id="0:22:37">here are</subtitle>
+<subtitle id="0:22:40"> a bunch of code syllables so</subtitle>
+<subtitle id="0:22:43"> this bc times a plus</subtitle>
+<subtitle id="0:22:46"> would be turned into something that would look like</subtitle>
+<subtitle id="0:22:52">value call for wherever be was</subtitle>
+<subtitle id="0:22:55"> maybe be is number three here so this</subtitle>
+<subtitle id="0:22:58"> would be something like value call</subtitle>
+<subtitle id="0:23:1"> three this</subtitle>
+<subtitle id="0:23:4"> would be value call maybe seven</subtitle>
+<subtitle id="0:23:7"> word see</subtitle>
+<subtitle id="0:23:10"> our operator</subtitle>
+<subtitle id="0:23:16">50 or something which is a plus</subtitle>
+<subtitle id="0:23:19"> and value call</subtitle>
+<subtitle id="0:23:22"> whenever a is maybe 30</subtitle>
+<subtitle id="0:23:31">plus</subtitle>
+<subtitle id="0:23:34"> I'm sorry this is x operator</subtitle>
+<subtitle id="0:23:37"> 45 which is plus</subtitle>
+<subtitle id="0:23:40"> so</subtitle>
+<subtitle id="0:23:43"> that's what that turns into and this thing</subtitle>
+<subtitle id="0:23:46"> had been this thing had been in originally</subtitle>
+<subtitle id="0:23:49"> an assignment statement into a variable called</subtitle>
+<subtitle id="0:23:52"> e</subtitle>
+<subtitle id="0:23:55"> and the code would have come out</subtitle>
+<subtitle id="0:23:58">he</subtitle>
+<subtitle id="0:24:1"> underbar a sign</subtitle>
+<subtitle id="0:24:4"> and that would have turned into here</subtitle>
+<subtitle id="0:24:7"> would have been a name call</subtitle>
+<subtitle id="0:24:10"> on wherever D is</subtitle>
+<subtitle id="0:24:13">these at 50</subtitle>
+<subtitle id="0:24:16"> say Lane called 50 op</subtitle>
+<subtitle id="0:24:19"> sign</subtitle>
+<subtitle id="0:24:22">they just we</subtitle>
+<subtitle id="0:24:25">numbers there and just draw these things in</subtitle>
+<subtitle id="0:24:28">okay so</subtitle>
+<subtitle id="0:24:31"> what name call does is to</subtitle>
+<subtitle id="0:24:34">generate an address that becomes an operand assignment</subtitle>
+<subtitle id="0:24:37"> is an operation in this machine and</subtitle>
+<subtitle id="0:24:40"> there are a couple of interesting</subtitle>
+<subtitle id="0:24:43"> this is penetrating at an instant</subtitle>
+<subtitle id="0:24:46">of the most important things you can ever do in</subtitle>
+<subtitle id="0:24:49"> a higher-level language which is to be able to</subtitle>
+<subtitle id="0:24:52"> give other senses for store and fetch</subtitle>
+<subtitle id="0:24:55"> and in the hardware of this machine never been done</subtitle>
+<subtitle id="0:24:58">programming like reports in the hardware this</subtitle>
+<subtitle id="0:25:1"> machine will talk about what's right and what's wrong with weight it turns</subtitle>
+<subtitle id="0:25:4"> out you did it the wrong way but you be forgiven</subtitle>
+<subtitle id="0:25:7"> because nobody thought before in fact borrows</subtitle>
+<subtitle id="0:25:10">use of it because most of the programs that borrows do not understand</subtitle>
+<subtitle id="0:25:13"> this particular feature she</subtitle>
+<subtitle id="0:25:16"> okay now a</subtitle>
+<subtitle id="0:25:19"> wonderful thing</subtitle>
+<subtitle id="0:25:22">further</subtitle>
+<subtitle id="0:25:25"> about this machine is that if a and</subtitle>
+<subtitle id="0:25:28"> B or C we're procedures the</subtitle>
+<subtitle id="0:25:31"> code is exactly the same okay</subtitle>
+<subtitle id="0:25:34"> compiler does not care for</subtitle>
+<subtitle id="0:25:37"> the following reason that one of</subtitle>
+<subtitle id="0:25:40"> the bits in this program reference table</subtitle>
+<subtitle id="0:25:43"> it's called</subtitle>
+<subtitle id="0:25:46"> a flag bit and</subtitle>
+<subtitle id="0:25:49"> it is there to distinguish direct</subtitle>
+<subtitle id="0:25:52"> operands like integers and floating</subtitle>
+<subtitle id="0:25:55"> point numbers and the</subtitle>
+<subtitle id="0:25:58"> way integers and floating point were stored was such that</subtitle>
+<subtitle id="0:26:1"> there's only one Plus that you needed there's</subtitle>
+<subtitle id="0:26:4"> only one operation over here and the</subtitle>
+<subtitle id="0:26:7"> system could tell whether there was an integer floating</subtitle>
+<subtitle id="0:26:10"> point when the flag bit was zero it meant what was stored</subtitle>
+<subtitle id="0:26:13">here was either an integer or floating-point</subtitle>
+<subtitle id="0:26:16"></subtitle>
+<subtitle id="0:26:19"> okay when the flag bit was one</subtitle>
+<subtitle id="0:26:22"> meant there was something that needed to cause</subtitle>
+<subtitle id="0:26:25"> an interrupt to be triggered off to other parts of the machines hardware</subtitle>
+<subtitle id="0:26:28"> yeah yeah this is what we</subtitle>
+<subtitle id="0:26:31"> want to do is look at these guys when the thing is marked is</subtitle>
+<subtitle id="0:26:34"> what so what I'm saying here is that</subtitle>
+<subtitle id="0:26:37"> there's no such thing number one is the code knowing</subtitle>
+<subtitle id="0:26:40">what it's going to work on it doesn't it's</subtitle>
+<subtitle id="0:26:43"> a direct translation of this which</subtitle>
+<subtitle id="0:26:46">in this form B could just as easily be an integer procedure</subtitle>
+<subtitle id="0:26:49"> as anything else and your function</subtitle>
+<subtitle id="0:26:52"> okay and number</subtitle>
+<subtitle id="0:26:55"> two the code is not allowed to</subtitle>
+<subtitle id="0:26:58"> see any of its own state and</subtitle>
+<subtitle id="0:27:1"> note that the code cannot see</subtitle>
+<subtitle id="0:27:4"> its segment that it's in unless</subtitle>
+<subtitle id="0:27:7"> there happens to be a pointer for it in this program</subtitle>
+<subtitle id="0:27:10"> reference tables everybody see that okay</subtitle>
+<subtitle id="0:27:13"> the code contains no addresses and in</subtitle>
+<subtitle id="0:27:16"> fact there's no way for the code to generate any addresses the</subtitle>
+<subtitle id="0:27:19"> only addresses it can ever use are</subtitle>
+<subtitle id="0:27:22">that's been given in these registers this code</subtitle>
+<subtitle id="0:27:25"> cannot see these registers the code cannot see the</subtitle>
+<subtitle id="0:27:28"> a and the B register it can only use the</subtitle>
+<subtitle id="0:27:31"> absolutely critical this is what it's so clever</subtitle>
+<subtitle id="0:27:34"> all modern protection schemes are based on</subtitle>
+<subtitle id="0:27:37"> this idea this is the idea that turned into what is now known as capabilities</subtitle>
+<subtitle id="0:27:40"> but</subtitle>
+<subtitle id="0:27:43"> done almost perfectly the first time around</subtitle>
+<subtitle id="0:27:46">when I was done in Baltics it</subtitle>
+<subtitle id="0:27:52">okay so let's take a look at</subtitle>
+<subtitle id="0:27:55"> these are these</subtitle>
+<subtitle id="0:27:58"> 48-bit words with the flag bit of one</subtitle>
+<subtitle id="0:28:1"> they had enough room in here that</subtitle>
+<subtitle id="0:28:4"> they decided what they would</subtitle>
+<subtitle id="0:28:7"> also do is to make the storage conform to the exact</subtitle>
+<subtitle id="0:28:10"> objects that the programmer wanted to use which are little variable length</subtitle>
+<subtitle id="0:28:13"> segments okay and the segment</subtitle>
+<subtitle id="0:28:16">he thing that not only has a starting address but</subtitle>
+<subtitle id="0:28:19"> also has an ending address okay</subtitle>
+<subtitle id="0:28:22"> so for instance</subtitle>
+<subtitle id="0:28:25"> an array would have something like</subtitle>
+<subtitle id="0:28:28"> the following format</subtitle>
+<subtitle id="0:28:34">his would be the base address of the array</subtitle>
+<subtitle id="0:28:37">this would</subtitle>
+<subtitle id="0:28:40"> be the length of the array this</subtitle>
+<subtitle id="0:28:43"> would be the fact that it is an array as</subtitle>
+<subtitle id="0:28:46"> it's additional type information there'd be a couple</subtitle>
+<subtitle id="0:28:49"> of extra bits here one of which would</subtitle>
+<subtitle id="0:28:52"> indicate whether the thing was in storage or not</subtitle>
+<subtitle id="0:28:55"> the idea is this bit where</subtitle>
+<subtitle id="0:28:58"> zero when you ran into it here meant</subtitle>
+<subtitle id="0:29:1"> you had to go out and fetch it before you could use it okay</subtitle>
+<subtitle id="0:29:4"></subtitle>
+<subtitle id="0:29:7"> so what this was was a protected</subtitle>
+<subtitle id="0:29:10"> segmenting scape another interesting</subtitle>
+<subtitle id="0:29:13"> one here is procedure</subtitle>
+<subtitle id="0:29:16"> is one of these guys</subtitle>
+<subtitle id="0:29:19"> think of this code if you want</subtitle>
+<subtitle id="0:29:22"> as a base address</subtitle>
+<subtitle id="0:29:25"> it has a length</subtitle>
+<subtitle id="0:29:28"> as a present spit</subtitle>
+<subtitle id="0:29:31">so</subtitle>
+<subtitle id="0:29:34"> forth and there a few other ones</subtitle>
+<subtitle id="0:29:37">okay so what do we have</subtitle>
+<subtitle id="0:29:40"> here we have a scheme</subtitle>
+<subtitle id="0:29:43">I got draw I haven't shown everything</subtitle>
+<subtitle id="0:29:46"> yet not to show how subroutines are done let's</subtitle>
+<subtitle id="0:29:49"> review for a second we've</subtitle>
+<subtitle id="0:29:52"> got a scheme and where the the code only refers</subtitle>
+<subtitle id="0:29:55"> to off set of registers that can't see</subtitle>
+<subtitle id="0:30:1">no object in storage</subtitle>
+<subtitle id="0:30:4"> can be referenced directly by the code the</subtitle>
+<subtitle id="0:30:7"> code wants to see something there has to be one of these</subtitle>
+<subtitle id="0:30:10"> guys in its program reference table</subtitle>
+<subtitle id="0:30:13"> what's in the program</subtitle>
+<subtitle id="0:30:16"> reference table is in there unambitious lee because the flag</subtitle>
+<subtitle id="0:30:19"> bit it's not in there as bits if the code has to remember what</subtitle>
+<subtitle id="0:30:22"> the heck it was so</subtitle>
+<subtitle id="0:30:25"> what can you do with this well suppose</subtitle>
+<subtitle id="0:30:28"> one</subtitle>
+<subtitle id="0:30:31"> of the things you can do for instance is replace see</subtitle>
+<subtitle id="0:30:34"> here with</subtitle>
+<subtitle id="0:30:37"> a procedure suppose</subtitle>
+<subtitle id="0:30:40"> we want to enrich in this thing without changing the code</subtitle>
+<subtitle id="0:30:43"> you just put a one flag bit of one and point</subtitle>
+<subtitle id="0:30:46"> this off to another piece of code down</subtitle>
+<subtitle id="0:30:49">here every time you go through and execute this code</subtitle>
+<subtitle id="0:30:52">and execute the procedure and generate the result from it</subtitle>
+<subtitle id="0:30:58">his procedure can just as easily access</subtitle>
+<subtitle id="0:31:1"> a file one of these things can be a</subtitle>
+<subtitle id="0:31:4">prominent going to another process the process is one</subtitle>
+<subtitle id="0:31:7"> of these whole conglomerations</subtitle>
+<subtitle id="0:31:10"> another one over here</subtitle>
+<subtitle id="0:31:13">okay so the</subtitle>
+<subtitle id="0:31:16"> in this machine you can implement directly</subtitle>
+<subtitle id="0:31:19"> things like streams in UNIX</subtitle>
+<subtitle id="0:31:22"> okay what you implement it just simply any variable</subtitle>
+<subtitle id="0:31:25"> can act as a stream but</subtitle>
+<subtitle id="0:31:28"> so far we've only talked to that about them as sources</subtitle>
+<subtitle id="0:31:31"> let's go through the how</subtitle>
+<subtitle id="0:31:37">execute some code here</subtitle>
+<subtitle id="0:31:40"> suppose suppose we have the code</subtitle>
+<subtitle id="0:31:43"> e5</subtitle>
+<subtitle id="0:31:46">okay right at this point we don't</subtitle>
+<subtitle id="0:31:49"> happen to know whether there is an array or a</subtitle>
+<subtitle id="0:31:52">procedure and if the caller doesn't know</subtitle>
+<subtitle id="0:31:55"> either what it does is it says but</subtitle>
+<subtitle id="0:31:58"> I'll do it different color so you can see it says now you call</subtitle>
+<subtitle id="0:32:1"> oh I</subtitle>
+<subtitle id="0:32:4"> know what the other one was</subtitle>
+<subtitle id="0:32:7"> no it's no it's just small subscripts</subtitle>
+<subtitle id="0:32:10"> actually it was was a small immediate</subtitle>
+<subtitle id="0:32:13"> operands that's what it was</subtitle>
+<subtitle id="0:32:16"> 0 0 0 1 1</subtitle>
+<subtitle id="0:32:19"> 0 1 1 yeah</subtitle>
+<subtitle id="0:32:22"> these are small integers</subtitle>
+<subtitle id="0:32:28">operators</subtitle>
+<subtitle id="0:32:34">o</subtitle>
+<subtitle id="0:32:37"> this thing would be immediate</subtitle>
+<subtitle id="0:32:40">five now we put the five</subtitle>
+<subtitle id="0:32:43"> in the top of the stack</subtitle>
+<subtitle id="0:32:46">then the</subtitle>
+<subtitle id="0:32:49"> I'm not going to go through</subtitle>
+<subtitle id="0:32:52"> right now exactly how</subtitle>
+<subtitle id="0:32:55"> this how this does in fact</subtitle>
+<subtitle id="0:32:58"> president was slightly more baroque way than</subtitle>
+<subtitle id="0:33:1"> it needs to do then</subtitle>
+<subtitle id="0:33:4">would do a value call assuming it's on this side of the</subtitle>
+<subtitle id="0:33:7"> assignment arrow do a value</subtitle>
+<subtitle id="0:33:13">EU never is one of</subtitle>
+<subtitle id="0:33:16"> these guys in here  down here so if you value call on</subtitle>
+<subtitle id="0:33:19"> 95 or something</subtitle>
+<subtitle id="0:33:22"> now if it comes in here</subtitle>
+<subtitle id="0:33:25"> and the flag bid is on the flag that is off</subtitle>
+<subtitle id="0:33:28"> there's a little little more code</subtitle>
+<subtitle id="0:33:31">generated here if the five minutes is off it's</subtitle>
+<subtitle id="0:33:34"> going to complain it's an opera</subtitle>
+<subtitle id="0:33:37"> opera hat waiting in the stack if the flag</subtitle>
+<subtitle id="0:33:40"> that is on here remember the five is is in</subtitle>
+<subtitle id="0:33:43"> the stack already then</subtitle>
+<subtitle id="0:33:46">going to look further than if it sees it's an array what</subtitle>
+<subtitle id="0:33:49"> it will do is automatically index</subtitle>
+<subtitle id="0:33:52"> the array against the base address but what it does</subtitle>
+<subtitle id="0:33:55"> is it checks the this guy against blanks first</subtitle>
+<subtitle id="0:33:58">and everything if everything is okay it generates this</subtitle>
+<subtitle id="0:34:1"> other way generates a bound check error so BAM is checking</subtitle>
+<subtitle id="0:34:4">done automatically by the hardware here if everything is all right</subtitle>
+<subtitle id="0:34:7"> then what it will fetch into the top of the stack is</subtitle>
+<subtitle id="0:34:10"> the</subtitle>
+<subtitle id="0:34:13"> value from that particular array</subtitle>
+<subtitle id="0:34:16"> important thing to realize is that</subtitle>
+<subtitle id="0:34:19"> arrays there's an array</subtitle>
+<subtitle id="0:34:22">point razor</subtitle>
+<subtitle id="0:34:25"> things like this program reference table arrays have flag</subtitle>
+<subtitle id="0:34:28"> bits also okay</subtitle>
+<subtitle id="0:34:31"> so it's a multi-dimensional array fetching in one</subtitle>
+<subtitle id="0:34:34">that has a flag bit on it's going to trigger off another indexing</subtitle>
+<subtitle id="0:34:37">and we'll start peeling the staff dry from</subtitle>
+<subtitle id="0:34:40"> all the indexes of the rail just appeal so rays are stored</subtitle>
+<subtitle id="0:34:43"> as trees on the be 5000</subtitle>
+<subtitle id="0:34:46">until you get to something that's an operand then</subtitle>
+<subtitle id="0:34:49"> I'll finally fetch that and answer it will have the answer</subtitle>
+<subtitle id="0:34:52"> even more fun</subtitle>
+<subtitle id="0:34:55"> that comes in here to E and just discovers</subtitle>
+<subtitle id="0:34:58"> it's a procedure it does exactly the same thing except</subtitle>
+<subtitle id="0:35:1">he procedure with this guy as a parameter</subtitle>
+<subtitle id="0:35:7">so bharden having a somewhat</subtitle>
+<subtitle id="0:35:10"> symmetric line</subtitle>
+<subtitle id="0:35:13">ask himself the question of what suppose I</subtitle>
+<subtitle id="0:35:16"> had something like this</subtitle>
+<subtitle id="0:35:19">what should i do</subtitle>
+<subtitle id="0:35:22"> there now the answers is this is a by</subtitle>
+<subtitle id="0:35:25"> being on this side of the assignment operator this</subtitle>
+<subtitle id="0:35:28">part of the thing is going to be replaced with a name</subtitle>
+<subtitle id="0:35:31">what I want you to wind up with is an address</subtitle>
+<subtitle id="0:35:34"> that this thing can operate</subtitle>
+<subtitle id="0:35:37"> on okay so far so good and</subtitle>
+<subtitle id="0:35:40">happens with array is it ripples through the same way except it doesn't</subtitle>
+<subtitle id="0:35:43"> fetch the last guy just we use the last guy in</subtitle>
+<subtitle id="0:35:46"> the top of the stack this guy can</subtitle>
+<subtitle id="0:35:49"> work on so for symmetry he decided</subtitle>
+<subtitle id="0:35:52"> that if this guy happened</subtitle>
+<subtitle id="0:35:55"> to be a procedure and it was called with the name call he should actually</subtitle>
+<subtitle id="0:35:58"> do something rather than complain this was the master stroke</subtitle>
+<subtitle id="0:36:1"> and what he does do is to call</subtitle>
+<subtitle id="0:36:4">in such a way that the procedure itself can discover</subtitle>
+<subtitle id="0:36:7"> what it's being asked for a name or a value that</subtitle>
+<subtitle id="0:36:10"> was a test you can make in this language</subtitle>
+<subtitle id="0:36:13"> called Bal Gulf was in the beginning of a</subtitle>
+<subtitle id="0:36:16">saying if somebody want me to generate an address or to somebody want</subtitle>
+<subtitle id="0:36:19"> a value from me and so in</subtitle>
+<subtitle id="0:36:22"> the complex Bal gall procedures were actually</subtitle>
+<subtitle id="0:36:25"> two-part procedures each part was a function that would produce</subtitle>
+<subtitle id="0:36:28"> a value it was also a procedure for calculating</subtitle>
+<subtitle id="0:36:31"> what that address was</subtitle>
+<subtitle id="0:36:34">that works for many</subtitle>
+<subtitle id="0:36:37">ou want to do turns out it doesn't work for all the things</subtitle>
+<subtitle id="0:36:40"> you want to do but it's very close it certainly</subtitle>
+<subtitle id="0:36:43"> allows you to simulate arrays and other</subtitle>
+<subtitle id="0:36:46">data structures I think you can see that if you</subtitle>
+<subtitle id="0:36:49"> put this thing in you can simulate the semantics</subtitle>
+<subtitle id="0:36:52"> of most data structures completely</subtitle>
+<subtitle id="0:36:55"> cover up whatever representation is actually being</subtitle>
+<subtitle id="0:36:58">and this was something that was used to a limited extent as</subtitle>
+<subtitle id="0:37:1">programs didn't really understand this in</subtitle>
+<subtitle id="0:37:4"> particular you can replace variables with files</subtitle>
+<subtitle id="0:37:7"> you could have input</subtitle>
+<subtitle id="0:37:10"> and output pipes it would fire off</subtitle>
+<subtitle id="0:37:13"> things that's what a lot</subtitle>
+<subtitle id="0:37:16"> now the final set of mumbo-jumbo</subtitle>
+<subtitle id="0:37:19"> here is how the</subtitle>
+<subtitle id="0:37:22"> stack was used to</subtitle>
+<subtitle id="0:37:25">also</subtitle>
+<subtitle id="0:37:28"> store subroutine state</subtitle>
+<subtitle id="0:37:31">that</subtitle>
+<subtitle id="0:37:34"> that way is as follows there's another register called the F</subtitle>
+<subtitle id="0:37:40">down here</subtitle>
+<subtitle id="0:37:43">let's</subtitle>
+<subtitle id="0:37:46"> think of what it has to get shoved into the stack when you call us every</subtitle>
+<subtitle id="0:37:49">day somehow we</subtitle>
+<subtitle id="0:37:52"> have to have the following information there's</subtitle>
+<subtitle id="0:37:55"> a program counter that must be here somewhere</subtitle>
+<subtitle id="0:37:58"> that is indexing</subtitle>
+<subtitle id="0:38:1"> into this code notice the program counter is</subtitle>
+<subtitle id="0:38:4"> relative to see</subtitle>
+<subtitle id="0:38:7"> okay see see could</subtitle>
+<subtitle id="0:38:10"> be anywhere this is was the first computer to ever have</subtitle>
+<subtitle id="0:38:13"></subtitle>
+<subtitle id="0:38:16"> so the various things we need to store are the program</subtitle>
+<subtitle id="0:38:19"> counter of where we were and that counts</subtitle>
+<subtitle id="0:38:22"> as guess what one</subtitle>
+<subtitle id="0:38:25">procedure segments these</subtitle>
+<subtitle id="0:38:28"> two guys just bottle up</subtitle>
+<subtitle id="0:38:31"> in there we need to</subtitle>
+<subtitle id="0:38:34"> know where the previous stack</subtitle>
+<subtitle id="0:38:37"> frame was and we have to know</subtitle>
+<subtitle id="0:38:40"> where the current one is because we have to get these</subtitle>
+<subtitle id="0:38:43"> guys relative to this frame register</subtitle>
+<subtitle id="0:38:46"> so the several ways of doing this</subtitle>
+<subtitle id="0:38:49"> at the be 5,000 does not do this in the cleanest possible</subtitle>
+<subtitle id="0:38:52"> fashion a modern</subtitle>
+<subtitle id="0:38:55"> way of doing this is as follows</subtitle>
+<subtitle id="0:39:1">is to</subtitle>
+<subtitle id="0:39:4"> point in have the frame register point into</subtitle>
+<subtitle id="0:39:7"> here and index local variables</subtitle>
+<subtitle id="0:39:10"> negatively relative</subtitle>
+<subtitle id="0:39:13"> to this so the local variables and the</subtitle>
+<subtitle id="0:39:16"> frame information</subtitle>
+<subtitle id="0:39:19"> the old program counter and stuff like that indexed</subtitle>
+<subtitle id="0:39:22"> negatively going that way and use this</subtitle>
+<subtitle id="0:39:25"> stuff here for the arithmetic operations in the new procedure</subtitle>
+<subtitle id="0:39:28"> ok that's the way small talk does it</subtitle>
+<subtitle id="0:39:31"> the way to be five they didn't realize</subtitle>
+<subtitle id="0:39:34"> they could do this on the me five thousand so they they went through</subtitle>
+<subtitle id="0:39:37"> a more complicated thing of</subtitle>
+<subtitle id="0:39:40"> marking the stack first and a few other little goodies but</subtitle>
+<subtitle id="0:39:43"> this is good enough to show</subtitle>
+<subtitle id="0:39:46">hat</subtitle>
+<subtitle id="0:39:49"> what is in part of this thing is the Preet the old F</subtitle>
+<subtitle id="0:39:52"> which is a pointer back down the stack</subtitle>
+<subtitle id="0:39:55"> into the previous frame okay</subtitle>
+<subtitle id="0:39:58">information you so think chugs along as much</subtitle>
+<subtitle id="0:40:1"> as it wants as soon as you hit a new procedure thing that triggers off</subtitle>
+<subtitle id="0:40:4"> a procedure call it bottles up this guy and</subtitle>
+<subtitle id="0:40:7"> that guy into the stack assuming</subtitle>
+<subtitle id="0:40:10"> that in typical Polish postfix</subtitle>
+<subtitle id="0:40:13"> form that these all of these variables</subtitle>
+<subtitle id="0:40:16"> here have been loaded into the stack first</subtitle>
+<subtitle id="0:40:19"> okay it just doesn't even know it's going to call</subtitle>
+<subtitle id="0:40:22"> a procedure just go chucking along the early eventually</subtitle>
+<subtitle id="0:40:25"> run into a procedure call and all of a sudden it discovers</subtitle>
+<subtitle id="0:40:28"> all of the variables have already been</subtitle>
+<subtitle id="0:40:31"> evaluated and they're stuffed in the stack in the right order</subtitle>
+<subtitle id="0:40:34"> and when this F register goes in then the</subtitle>
+<subtitle id="0:40:37"> parameters are just this</subtitle>
+<subtitle id="0:40:43">reason it knows is that these ten bits</subtitle>
+<subtitle id="0:40:46"> that this thing is built up</subtitle>
+<subtitle id="0:40:49"> into for these two guys is actually broken up into</subtitle>
+<subtitle id="0:40:52"> two smaller segments</subtitle>
+<subtitle id="0:40:55"> for global and local</subtitle>
+<subtitle id="0:40:58">so that's basically how the</subtitle>
+<subtitle id="0:41:1"> machine works when</subtitle>
+<subtitle id="0:41:4"> you do an inter process call you run into</subtitle>
+<subtitle id="0:41:7"> something that's a process it bundles up</subtitle>
+<subtitle id="0:41:10"> more than this it actually talks all</subtitle>
+<subtitle id="0:41:13"> of the state of what's going on</subtitle>
+<subtitle id="0:41:16"> into the top of the last sack that</subtitle>
+<subtitle id="0:41:19"> you have and stashes that in a program</subtitle>
+<subtitle id="0:41:22">reference table in the operating system program reference table</subtitle>
+<subtitle id="0:41:25"> the operating system is the scheduler okay</subtitle>
+<subtitle id="0:41:28"> because that's what it is you want scheduler</subtitle>
+<subtitle id="0:41:31">a bunch of things that have just processed descriptors</subtitle>
+<subtitle id="0:41:34"> in there and you just go from one to the other and</subtitle>
+<subtitle id="0:41:37"> you're either executing or closing them up so the subroutine</subtitle>
+<subtitle id="0:41:40"> call time on this 1961 the machine was</subtitle>
+<subtitle id="0:41:43"> just a couple of microseconds</subtitle>
+<subtitle id="0:41:46"> almost as fast if the operations were itself because</subtitle>
+<subtitle id="0:41:49">it have to do it didn't have to do much more than</subtitle>
+<subtitle id="0:41:52"> what it was doing on operations the result of</subtitle>
+<subtitle id="0:41:55"> this thing is that the procedures that you wrote</subtitle>
+<subtitle id="0:41:58"> were very close in</subtitle>
+<subtitle id="0:42:1"> thinking to the notion of extending the whole</subtitle>
+<subtitle id="0:42:4"> operator set of the of the computer is like a programmed operator</subtitle>
+<subtitle id="0:42:7"> set that you find in blessing machines like the</subtitle>
+<subtitle id="0:42:10">but fit</subtitle>
+<subtitle id="0:42:13"> into this one homogenous scheme</subtitle>
+<subtitle id="0:42:16"> so what we have on the unbe 5000</subtitle>
+<subtitle id="0:42:19"> is have complete protection one</subtitle>
+<subtitle id="0:42:22">this is one of the few architectures that actually</subtitle>
+<subtitle id="0:42:25"> exists today they're still selling these goddamn machines forget</subtitle>
+<subtitle id="0:42:28">what it's called fifty seven hundred fifty nine hundred out</subtitle>
+<subtitle id="0:42:31"> every couple years they upgrade the</subtitle>
+<subtitle id="0:42:34"> hardware on it but it's basically such a sound</subtitle>
+<subtitle id="0:42:37"> design I have so much code written for it that they're still</subtitle>
+<subtitle id="0:42:40"> selling the goddamn things the reason</subtitle>
+<subtitle id="0:42:43"> is you can't break the operating system just</subtitle>
+<subtitle id="0:42:46"> cannot break it because there's no way you</subtitle>
+<subtitle id="0:42:49"> have to do extremely special things in order to be</subtitle>
+<subtitle id="0:42:52">able to get any kind of descriptors which what these things are called</subtitle>
+<subtitle id="0:42:55"> - any piece of code or any piece</subtitle>
+<subtitle id="0:42:58"> of segmenting the very first</subtitle>
+<subtitle id="0:43:1">he third one of the first multiprocessor</subtitle>
+<subtitle id="0:43:4"> systems and again you can see why because</subtitle>
+<subtitle id="0:43:7"> protection is nearly absolute</subtitle>
+<subtitle id="0:43:10"> as you can get you can afford to have several processors kicking around at</subtitle>
+<subtitle id="0:43:13"> the stuff that's there and the prizes are</subtitle>
+<subtitle id="0:43:16"> put to good use because the storage swapping was so slow</subtitle>
+<subtitle id="0:43:19"> that one of the processors would be running was</subtitle>
+<subtitle id="0:43:22">omething while the other guy was trying to swap stuff yeah</subtitle>
+<subtitle id="0:43:25"> you have programmable data</subtitle>
+<subtitle id="0:43:28"> on balance</subtitle>
+<subtitle id="0:43:31"> checking automatic subroutine</subtitle>
+<subtitle id="0:43:34"> calling and process switching</subtitle>
+<subtitle id="0:43:37"> and a limited amount of code cache one</subtitle>
+<subtitle id="0:43:40"> batch for every</subtitle>
+<subtitle id="0:43:43">okay so that's that's sort of a quick pass</subtitle>
+<subtitle id="0:43:46"> through what to be 5,000 wise now</subtitle>
+<subtitle id="0:43:49"> funny thing about this sort</subtitle>
+<subtitle id="0:43:52"> of the despair of anybody who actually knows about</subtitle>
+<subtitle id="0:43:55"> this machine is that almost nobody knows about these</subtitle>
+<subtitle id="0:43:58"> ideas these ideas would look goddamn good on</subtitle>
+<subtitle id="0:44:1"> a chip from Intel er Motorola today believe me</subtitle>
+<subtitle id="0:44:4"> I think we can all use them and they're a couple of</subtitle>
+<subtitle id="0:44:7"> things that we might like to do to to fix up going</subtitle>
+<subtitle id="0:44:10">after Pascal like data structures but this would be one dandy</subtitle>
+<subtitle id="0:44:13"> Pascal machine and it's one of the things you have to realize</subtitle>
+<subtitle id="0:44:16"> that one of Klauss worst teachers was Bob Barton</subtitle>
+<subtitle id="0:44:19"> Klauss went and Dave Evans</subtitle>
+<subtitle id="0:44:22"> okay Klaus was a graduate student</subtitle>
+<subtitle id="0:44:25"> of Dave Evans when Dave and Harry husky when Dave was at Berkeley</subtitle>
+<subtitle id="0:44:28"> and he</subtitle>
+<subtitle id="0:44:31"> then came over to work with Bill McKinnon at</subtitle>
+<subtitle id="0:44:34"> Stanford where they had a be five thousand and thousands</subtitle>
+<subtitle id="0:44:37"> first two languages were</subtitle>
+<subtitle id="0:44:40"> there's language called Euler which is a particularly</subtitle>
+<subtitle id="0:44:43"> good good design it was implemented as</subtitle>
+<subtitle id="0:44:46"> this this whole thing that led to Pascal P codes is</subtitle>
+<subtitle id="0:44:49"> right here okay Pascal P codes</subtitle>
+<subtitle id="0:44:52"> are sort of a crummy software way of doing what this machine did</subtitle>
+<subtitle id="0:44:55"> in hardware this is what is so amazing about the</subtitle>
+<subtitle id="0:44:58">as most things that you would like to have in a programming</subtitle>
+<subtitle id="0:45:1"> language they had to extend Balga or to</subtitle>
+<subtitle id="0:45:4"> handle features like multi processing the</subtitle>
+<subtitle id="0:45:7"> the protection the fact that you could actually change types</subtitle>
+<subtitle id="0:45:10"> dynamically here which bound all didn't allow but it's</subtitle>
+<subtitle id="0:45:13"> like they came up with a language called s Paul</subtitle>
+<subtitle id="0:45:22">I can't remember what s Paul stands</subtitle>
+<subtitle id="0:45:25"> for anymore but it's basically an alcohol extended</subtitle>
+<subtitle id="0:45:28"> for systems programming and it had all it was language</subtitle>
+<subtitle id="0:45:31"> that used all these features directly that's what they wrote all the</subtitle>
+<subtitle id="0:45:34"> operating system they never wrote a line of</subtitle>
+<subtitle id="0:45:37"> assembly code there was never a sembly the</subtitle>
+<subtitle id="0:45:40"> fate of this machine was kind of funny because</subtitle>
+<subtitle id="0:45:43"> I remember when when</subtitle>
+<subtitle id="0:45:46"> burrows was Hawking it they were</subtitle>
+<subtitle id="0:45:49"> so proud of what this</subtitle>
+<subtitle id="0:45:52">machine could do but they went out and hired a bunch of college</subtitle>
+<subtitle id="0:45:55"> graduates as salesmen and actually</subtitle>
+<subtitle id="0:45:58"> taught them what the machine was worst</subtitle>
+<subtitle id="0:46:1"> mistake they ever made because they immediately</subtitle>
+<subtitle id="0:46:4"> went out and completely snowed all of data-processing</subtitle>
+<subtitle id="0:46:7"> managers remember this is 1961-62 telling</subtitle>
+<subtitle id="0:46:10"> them about this machine that was distinctly not like</subtitle>
+<subtitle id="0:46:13">IBM system they'd ever seen before and</subtitle>
+<subtitle id="0:46:16"> it just scared the out of everybody they made up they</subtitle>
+<subtitle id="0:46:19">sense of humor they made up a game called compiler</subtitle>
+<subtitle id="0:46:22"> games it was a board game that you played</subtitle>
+<subtitle id="0:46:25"> like Monopoly except what I would do was show you it</subtitle>
+<subtitle id="0:46:28"> would actually generate would take any piece of alcohol</subtitle>
+<subtitle id="0:46:31"> code and generates burroughs syllables</subtitle>
+<subtitle id="0:46:34"> he just went through it had the stacks the little</subtitle>
+<subtitle id="0:46:37">the stacks you know you just went through and it had a me</subtitle>
+<subtitle id="0:46:40">and you just went through the thing and by god the thing</subtitle>
+<subtitle id="0:46:43"> would showed you how simple compiling was on</subtitle>
+<subtitle id="0:46:46"> this system that scared everybody that's</subtitle>
+<subtitle id="0:46:49"> how I learned how to compile when I was in the Air Force using</subtitle>
+<subtitle id="0:46:52"> this damn compiler game I'm looking for one ever since</subtitle>
+<subtitle id="0:46:55"> must be some around the other thing they</subtitle>
+<subtitle id="0:46:58"> did is they came out without Fortran on</subtitle>
+<subtitle id="0:47:1"> the grounds that alcohol 58 was infinitely better than the</subtitle>
+<subtitle id="0:47:4"> soon to be a now the algaas they upgraded this to Algol</subtitle>
+<subtitle id="0:47:7"> 60 was infinitely better than Fortran which was</subtitle>
+<subtitle id="0:47:10"> true and they could run Algol 60 with no</subtitle>
+<subtitle id="0:47:13"> appreciable overheads unlike how and on the other</subtitle>
+<subtitle id="0:47:16"> machines nobody bought it in fact</subtitle>
+<subtitle id="0:47:19"> this machine languished for years until</subtitle>
+<subtitle id="0:47:22"> they wrote a preprocessor the translated</subtitle>
+<subtitle id="0:47:25"> Fortran into alcohol and then compiled that</subtitle>
+<subtitle id="0:47:28"> into these things and that is</subtitle>
+<subtitle id="0:47:31"> how that is how they finally sell the machine they fired all of the college</subtitle>
+<subtitle id="0:47:34"> graduates and got guys like the old SDS</subtitle>
+<subtitle id="0:47:37"> salesmen you ever asked them a question they would say I don't</subtitle>
+<subtitle id="0:47:40"> know the answer but can I buy you a drink</subtitle>
+<subtitle id="0:47:43">sent them out and then they finally people started</subtitle>
+<subtitle id="0:47:46"> noticing that the machines didn't crash very often like once every</subtitle>
+<subtitle id="0:47:49"> two years and that</subtitle>
+<subtitle id="0:47:52"> they could even these small machines could</subtitle>
+<subtitle id="0:47:55">twenty four thirty jobs at the same time interleaving</subtitle>
+<subtitle id="0:47:58"> all the stuff they're incredibly efficient</subtitle>
+<subtitle id="0:48:1"> okay so</subtitle>
+<subtitle id="0:48:4"> generally speaking a a</subtitle>
+<subtitle id="0:48:7"> system like this is this</subtitle>
+<subtitle id="0:48:10"> is sort of the place where</subtitle>
+<subtitle id="0:48:13">you start thinking what you start about higher-level languages and if</subtitle>
+<subtitle id="0:48:16"> you're thinking about doing Pascal a couple</subtitle>
+<subtitle id="0:48:19"> of modifications this gives you a damn good Pascal</subtitle>
+<subtitle id="0:48:22"> machine it is essentially the algorithm</subtitle>
+<subtitle id="0:48:25"> that the Mesa people</subtitle>
+<subtitle id="0:48:28"> put in micro code in the Xerox</subtitle>
+<subtitle id="0:48:31"> PARC machines Mesa is sort of a super Pascal it's</subtitle>
+<subtitle id="0:48:34"> the algorithm that Cosworth put in the</subtitle>
+<subtitle id="0:48:37"> Loess machines</subtitle>
+<subtitle id="0:48:40"> that were spin-offs of the park</subtitle>
+<subtitle id="0:48:43"> stuff does pretty well what's</subtitle>
+<subtitle id="0:48:46"> wrong with this</subtitle>
+<subtitle id="0:48:49"> well first thing is</subtitle>
+<subtitle id="0:48:52"> that it has such a determined way of</subtitle>
+<subtitle id="0:48:55"> doing things that</subtitle>
+<subtitle id="0:48:58"> one might ask the question</subtitle>
+<subtitle id="0:49:1"> is how does this dough do less okay</subtitle>
+<subtitle id="0:49:4"> the most natural way of doing Lisp here is to</subtitle>
+<subtitle id="0:49:7"> have these guys point to segments that are only two words long</subtitle>
+<subtitle id="0:49:10"> it turns out that is a disaster</subtitle>
+<subtitle id="0:49:13"> because remember the thing thinks it's trying</subtitle>
+<subtitle id="0:49:16"> to swap segments the whole system had</subtitle>
+<subtitle id="0:49:19"> an assumption about how long segments are like they're an average of</subtitle>
+<subtitle id="0:49:22"> 40 words long which is a reasonable swapping</subtitle>
+<subtitle id="0:49:25"> size and strings were longer than that so the</subtitle>
+<subtitle id="0:49:28"> first first time Lisp was tried to be put</subtitle>
+<subtitle id="0:49:31"> on the powers be 5000 just</subtitle>
+<subtitle id="0:49:34">he last time McCarthy ever looked at a machine like this</subtitle>
+<subtitle id="0:49:37"> he made the incorrect assumption</subtitle>
+<subtitle id="0:49:40"> that since list wouldn't run out of be 5000 that a</subtitle>
+<subtitle id="0:49:43"> higher level architecture is a wrong idea that is false</subtitle>
+<subtitle id="0:49:46"> but it was such a failure that an</subtitle>
+<subtitle id="0:49:49"> apartment in fact Burroughs has compounded that error</subtitle>
+<subtitle id="0:49:52"> over the years they grew to love</subtitle>
+<subtitle id="0:49:55"> this with a passion approaching that</subtitle>
+<subtitle id="0:49:58"> of religion and essentially decided</subtitle>
+<subtitle id="0:50:1">that didn't run on this wasn't a good system</subtitle>
+<subtitle id="0:50:4"> okay which is the usual way he defined</subtitle>
+<subtitle id="0:50:7"> the problem out of existence and</subtitle>
+<subtitle id="0:50:10"> so as a result Barros has never entered the</subtitle>
+<subtitle id="0:50:13"> mainstream of research never ever</subtitle>
+<subtitle id="0:50:16">and the current borrows machines don't do much better on Lisp than</subtitle>
+<subtitle id="0:50:19"> the old ones did and I</subtitle>
+<subtitle id="0:50:22"> found that this is sort of to my heart because I adapted this architecture</subtitle>
+<subtitle id="0:50:25"> on the first machine I ever designed around</subtitle>
+<subtitle id="0:50:28"> 1967 or so tried to do a desktop</subtitle>
+<subtitle id="0:50:31"> machine that directly executed a higher-level language</subtitle>
+<subtitle id="0:50:34"> of the euler type but with multi</subtitle>
+<subtitle id="0:50:37"> processes as being the basic idea that it turns out</subtitle>
+<subtitle id="0:50:40"> it doesn't work the reason it</subtitle>
+<subtitle id="0:50:43"> doesn't work is basically</subtitle>
+<subtitle id="0:50:46"> cost performance</subtitle>
+<subtitle id="0:50:52">what</subtitle>
+<subtitle id="0:50:56"> do I mean by that well this</subtitle>
+<subtitle id="0:50:59"></subtitle>
+<subtitle id="0:51:1">to balance what this does for you with how</subtitle>
+<subtitle id="0:51:4"> much machinery actually have to put in there with</subtitle>
+<subtitle id="0:51:7"> how many times you're actually using it with</subtitle>
+<subtitle id="0:51:10"> how many times you're going to change your mind and what the</subtitle>
+<subtitle id="0:51:13"> data structures are going to be like and</subtitle>
+<subtitle id="0:51:16"> notice you can you can make any kind of a</subtitle>
+<subtitle id="0:51:19"> data structure you want here with a programmable system</subtitle>
+<subtitle id="0:51:22">is it just gets cumbersome because this isn't a good way</subtitle>
+<subtitle id="0:51:25"> of extending things so when we finally</subtitle>
+<subtitle id="0:51:28"> set out to do small touch we had a model in mind</subtitle>
+<subtitle id="0:51:31">and small talk actually if you squint at it</subtitle>
+<subtitle id="0:51:34"> you discover that this thing</subtitle>
+<subtitle id="0:51:37"> in small talk is what we call the instant state</subtitle>
+<subtitle id="0:51:40"> and it's usually much smaller and</subtitle>
+<subtitle id="0:51:43"> these stack frames and</subtitle>
+<subtitle id="0:51:46"> most of the small talks are actually separate objects called activation</subtitle>
+<subtitle id="0:51:49"> records which are allocated separately rather than</subtitle>
+<subtitle id="0:51:52"> on a single stack and if you do that</subtitle>
+<subtitle id="0:51:55"> then you wind up having an object oriented architecture</subtitle>
+<subtitle id="0:51:58">okay</subtitle>
+<subtitle id="0:52:1"> that was that was partly led to by reflecting on how Simula might</subtitle>
+<subtitle id="0:52:4"> be executed on this on this machine</subtitle>
+<subtitle id="0:52:7"> but the thing that you have to take care of is</subtitle>
+<subtitle id="0:52:13">this basic assumption about what storage is</subtitle>
+<subtitle id="0:52:16"> going to be the real question is how much</subtitle>
+<subtitle id="0:52:19"> can you afford to pay for</subtitle>
+<subtitle id="0:52:22"> machinery on data structures most of</subtitle>
+<subtitle id="0:52:25">don't know what they're going to be when you start out and</subtitle>
+<subtitle id="0:52:28">at Parc was instead of building any machinery on</subtitle>
+<subtitle id="0:52:31"> this thing we tried to make the Machine run enough faster than</subtitle>
+<subtitle id="0:52:34">main memory so that we could change our minds frequently</subtitle>
+<subtitle id="0:52:37"> in the microcode as we went along and</subtitle>
+<subtitle id="0:52:40"> we finally staff settled</subtitle>
+<subtitle id="0:52:43">on a few standard formats larger than the number that's be 5,000</subtitle>
+<subtitle id="0:52:46"> had that would do about 95% of all the</subtitle>
+<subtitle id="0:52:49">structures that you could construct in small</subtitle>
+<subtitle id="0:52:52"> talk this particular direct</subtitle>
+<subtitle id="0:52:55"> has anybody seen any of the bugs I know</subtitle>
+<subtitle id="0:52:58"> Steve Steve Saunders knows all these but</subtitle>
+<subtitle id="0:53:1">notice one of the things that happens when you do a process</subtitle>
+<subtitle id="0:53:4"> which is pretty unfortunate</subtitle>
+<subtitle id="0:53:7"> is anybody see</subtitle>
+<subtitle id="0:53:10">in the stack that you don't want to have in the stack when</subtitle>
+<subtitle id="0:53:13"> you do a process switch</subtitle>
+<subtitle id="0:53:16">and we can have integers in here that's okay</subtitle>
+<subtitle id="0:53:19"> doesn't matter what else can be in here</subtitle>
+<subtitle id="0:53:22"> yeah we can have some addresses of data and</subtitle>
+<subtitle id="0:53:25">addresses that they are absolute addresses</subtitle>
+<subtitle id="0:53:28"> okay and that means that</subtitle>
+<subtitle id="0:53:31"> you can have an one</subtitle>
+<subtitle id="0:53:34"> of these array descriptors or a procedure descriptor in</subtitle>
+<subtitle id="0:53:37"> here that's pointing to something in</subtitle>
+<subtitle id="0:53:40">storage and a frozen process that you're not going to use for</subtitle>
+<subtitle id="0:53:43">might like to do is to clear out core and</subtitle>
+<subtitle id="0:53:46"> let the new process run for a while and</subtitle>
+<subtitle id="0:53:49"> the problem is if you do that then the chances of these things</subtitle>
+<subtitle id="0:53:52">to these guys when you come back and is going to be zero so</subtitle>
+<subtitle id="0:53:55"> that led to some immense first</subtitle>
+<subtitle id="0:53:58"> set of immense clue juries which</subtitle>
+<subtitle id="0:54:1"> persists actually to it to this day they're on the</subtitle>
+<subtitle id="0:54:4"> 6700 has this horrible</subtitle>
+<subtitle id="0:54:7"> instruction I forgot what it's called but its</subtitle>
+<subtitle id="0:54:10"> purpose is to chase down the stack and find these guys</subtitle>
+<subtitle id="0:54:13"> and make them turn them from absolute guys</subtitle>
+<subtitle id="0:54:16">the relative guys will then get triggered back</subtitle>
+<subtitle id="0:54:19"></subtitle>
+<subtitle id="0:54:22"> it does it does this when when it something</subtitle>
+<subtitle id="0:54:25"> is going to be moved that belongs to this guy yeah</subtitle>
+<subtitle id="0:54:28"> barf terrible</subtitle>
+<subtitle id="0:54:31"> that one we can't pin on Barton</subtitle>
+<subtitle id="0:54:34">he was long gone by the time they put that one in there</subtitle>
+<subtitle id="0:54:37"> but it brings up the notion here that the mapping</subtitle>
+<subtitle id="0:54:40"> scheme which worked so well on this fairly primitive machine</subtitle>
+<subtitle id="0:54:43"> doesn't extend I think</subtitle>
+<subtitle id="0:54:46"> the one that yeah</subtitle>
+<subtitle id="0:54:52">would check to see that</subtitle>
+<subtitle id="0:54:55"> no reason okay the</subtitle>
+<subtitle id="0:54:58"> storage manager made sure that that happened</subtitle>
+<subtitle id="0:55:1"> but one of the one of the problems with it is that</subtitle>
+<subtitle id="0:55:4"> in most of the early successful system they actually used</subtitle>
+<subtitle id="0:55:7"> this structure as the map also in</subtitle>
+<subtitle id="0:55:10">other words the operating system would look through this thing</subtitle>
+<subtitle id="0:55:13"> and this would be besides the program reference table</subtitle>
+<subtitle id="0:55:16">for the program it was also the storage mapping structure</subtitle>
+<subtitle id="0:55:19"> of the whole system which is trying</subtitle>
+<subtitle id="0:55:22"> to make do a little bit too much double duty</subtitle>
+<subtitle id="0:55:25"> you see what I mean because you know you</subtitle>
+<subtitle id="0:55:28"> have integers there's there are too many side</subtitle>
+<subtitle id="0:55:31">that can happen and make it go on so the weakest thing on</subtitle>
+<subtitle id="0:55:34"> this machine they realized by the time we</subtitle>
+<subtitle id="0:55:37">this stuff at Parc was that the storage mechanism wasn't</subtitle>
+<subtitle id="0:55:40">sat down and thought about it we realized that we in</subtitle>
+<subtitle id="0:55:43">actually know almost nothing about allocating</subtitle>
+<subtitle id="0:55:46"> storage it was</subtitle>
+<subtitle id="0:55:49">problem in the B 5,000 it's just be simply that</subtitle>
+<subtitle id="0:55:52">getting caught and we're always spending the most time trying</subtitle>
+<subtitle id="0:55:55"> to figure out how to allocate storage how to</subtitle>
+<subtitle id="0:55:58"> how to use it and</subtitle>
+<subtitle id="0:56:1"> in small talk the scheme</subtitle>
+<subtitle id="0:56:4"> that we had was to have much shorter</subtitle>
+<subtitle id="0:56:7">addresses and the addresses weren't based addresses at all but</subtitle>
+<subtitle id="0:56:10"> actually names of objects</subtitle>
+<subtitle id="0:56:13">okay so the instead of pointing to anything in core these</subtitle>
+<subtitle id="0:56:16"> things denoted the entire object and the object was found by</subtitle>
+<subtitle id="0:56:19"> looking up in a step separate storage table that</subtitle>
+<subtitle id="0:56:22"> would tell you where the thing was it's more</subtitle>
+<subtitle id="0:56:25">it's a cleaner solution to the thing and it actually worked</subtitle>
+<subtitle id="0:56:28"> small talks schemed was the first</subtitle>
+<subtitle id="0:56:31">segmenting scheme that actually worked thanks to Ted</subtitle>
+<subtitle id="0:56:34"> Kaler and Dan Ingalls they actually figured out how to do it</subtitle>
+<subtitle id="0:56:37">what you have to do in order to make one of these schemes work</subtitle>
+<subtitle id="0:56:40"> is amazing why</subtitle>
+<subtitle id="0:56:43">should anybody go to that trouble well if</subtitle>
+<subtitle id="0:56:46"> you are swapping objects</subtitle>
+<subtitle id="0:56:49">thank you always are interested in knowing is what does</subtitle>
+<subtitle id="0:56:52"> this thing called</subtitle>
+<subtitle id="0:56:55"> working set working</subtitle>
+<subtitle id="0:56:58"> set in most operating systems is the</subtitle>
+<subtitle id="0:57:1">that you have to have in so that you won't swap more</subtitle>
+<subtitle id="0:57:4"> than every like 10 milliseconds or something</subtitle>
+<subtitle id="0:57:7"> like that in other words you want to have enough context</subtitle>
+<subtitle id="0:57:10"> in storage so that you're not swapping on every other reference</subtitle>
+<subtitle id="0:57:13"> and paging</subtitle>
+<subtitle id="0:57:16"> is terribly inefficient because the matter how</subtitle>
+<subtitle id="0:57:19">allocator is it's always allocating the wrong objects</subtitle>
+<subtitle id="0:57:22"> on pages and the</subtitle>
+<subtitle id="0:57:25">discovered when we did this in small talk was that</subtitle>
+<subtitle id="0:57:28"> the packing efficiency of having objects</subtitle>
+<subtitle id="0:57:31"> packed in the core by a compacting allocator was</subtitle>
+<subtitle id="0:57:34"> a factor of 15 over what pages give</subtitle>
+<subtitle id="0:57:37"> you okay that is</subtitle>
+<subtitle id="0:57:40">tremendous it's like having 15 times as much core</subtitle>
+<subtitle id="0:57:43"> unfortunately the overhead for</subtitle>
+<subtitle id="0:57:46"> getting objects is much worse right</subtitle>
+<subtitle id="0:57:49"> you have many more objects and</subtitle>
+<subtitle id="0:57:52">several thousand objects and stories instead of a you know a</subtitle>
+<subtitle id="0:57:55"> small number of pages you have to go through much</subtitle>
+<subtitle id="0:57:58"> worse mapping scheme it's not just a table lookup anymore</subtitle>
+<subtitle id="0:58:1"> you have to do hashing my name's</subtitle>
+<subtitle id="0:58:4"> you have to fetch small objects off digital</subtitle>
+<subtitle id="0:58:7"> disks which is not good when you're writing things out you have</subtitle>
+<subtitle id="0:58:10">which is worse and</subtitle>
+<subtitle id="0:58:13"> that was what</subtitle>
+<subtitle id="0:58:16"> caused this scheme to fail and the Flex machine but</subtitle>
+<subtitle id="0:58:19"> then as I say Keller and Engels that</subtitle>
+<subtitle id="0:58:22">people pitching in from the sidelines came up</subtitle>
+<subtitle id="0:58:25"> with a composite scheme that solved all of those problems</subtitle>
+<subtitle id="0:58:28"> using partly a technique</subtitle>
+<subtitle id="0:58:31"> of realizing that the last thing you ever wanted to have</subtitle>
+<subtitle id="0:58:34"> in storage was written on objects</subtitle>
+<subtitle id="0:58:37"> okay and so whether you whether the system wanted to</subtitle>
+<subtitle id="0:58:40">r not it was constantly jumping through every couple of seconds it would jump</subtitle>
+<subtitle id="0:58:43">through and write out every object that had been written on whether</subtitle>
+<subtitle id="0:58:46"> it needed to or not and so only I</subtitle>
+<subtitle id="0:58:49"> think something like 4% of the occasions</subtitle>
+<subtitle id="0:58:52">bring something in did you ever have to write anything out to make</subtitle>
+<subtitle id="0:58:55"> room it was always clean stuff in court</subtitle>
+<subtitle id="0:58:58"> that turned out to be the key that was adapted</subtitle>
+<subtitle id="0:59:1"> from the great old algorithm on the SDS 940</subtitle>
+<subtitle id="0:59:4"> the Butler Lampson thought out but this time for</subtitle>
+<subtitle id="0:59:7"> objects rather than pages so the result of it is</subtitle>
+<subtitle id="0:59:10"> that the page the swapping efficiency of</subtitle>
+<subtitle id="0:59:13"> Smalltalk 76 worked out to be a factor</subtitle>
+<subtitle id="0:59:16"> of 9 over paging in</subtitle>
+<subtitle id="0:59:19"> fact the in that particular system never ran in</subtitle>
+<subtitle id="0:59:22"> more than 80 K bytes ok every</subtitle>
+<subtitle id="0:59:25"> demonstration we ever did in small effects 76 only swapped</subtitle>
+<subtitle id="0:59:28"> an 80 K bytes something that is quite</subtitle>
+<subtitle id="0:59:31">and part actually just after we discovered at work we</subtitle>
+<subtitle id="0:59:34"> actually decided to keep it at that size because that was a size</subtitle>
+<subtitle id="0:59:37"> it was going to be possible in commercial machines</subtitle>
+<subtitle id="0:59:40"> very very shortly the equivalent</subtitle>
+<subtitle id="0:59:43"> performance to a system like list was equal to about</subtitle>
+<subtitle id="0:59:46"></subtitle>
+<subtitle id="0:59:49"> almost 10 times that amount of storage it</subtitle>
+<subtitle id="0:59:52"> took a kinder list on the darada you</subtitle>
+<subtitle id="0:59:55"> have to have something like 350 k words</subtitle>
+<subtitle id="0:59:58"> 16-bit words in order to get the same swapping</subtitle>
+<subtitle id="1:0:1">inefficiency and difference they have almost an order</subtitle>
+<subtitle id="1:0:4"> of magnitude which was remarkable okay</subtitle>
+<subtitle id="1:0:7"> so that is that</subtitle>
+<subtitle id="1:0:10"> is the basis for thinking about these</subtitle>
+<subtitle id="1:0:13"> systems now let's talk about a little bit about the wrist</subtitle>
+<subtitle id="1:0:16"> chip</subtitle>
+<subtitle id="1:0:19"> very interesting what they tried to do</subtitle>
+<subtitle id="1:0:22"> wrist chip was designed</subtitle>
+<subtitle id="1:0:25"> an innocence or at least a partial innocence</subtitle>
+<subtitle id="1:0:28"> of the be 5000 which is probably just as well first</subtitle>
+<subtitle id="1:0:31">hing after learning something like this is to forget it you</subtitle>
+<subtitle id="1:0:34"> know it's sort of a useful fashion you</subtitle>
+<subtitle id="1:0:37"> don't want to remember anything directly just want to survive</subtitle>
+<subtitle id="1:0:40"> the air but this yeah you wanted to seep through</subtitle>
+<subtitle id="1:0:43"> your consciousness when you're designing but you don't want</subtitle>
+<subtitle id="1:0:46"> to try and imitate it</subtitle>
+<subtitle id="1:0:49"></subtitle>
+<subtitle id="1:0:52"></subtitle>
+<subtitle id="1:0:55"></subtitle>
+<subtitle id="1:0:58"></subtitle>
+<subtitle id="1:1:1"></subtitle>
+<subtitle id="1:1:4"> one of the things to realize is that most</subtitle>
+<subtitle id="1:1:7"> of the early machines were reduced instruction set</subtitle>
+<subtitle id="1:1:10"> computers there's only the IBM</subtitle>
+<subtitle id="1:1:13"> and Remington Rand corporation</subtitle>
+<subtitle id="1:1:16"> and control data had this thing where they sold</subtitle>
+<subtitle id="1:1:19"> computers on the night and</subtitle>
+<subtitle id="1:1:22"> that led to a whole bunch of what we used to call it drop</subtitle>
+<subtitle id="1:1:25"> screwdriver instructions debugging</subtitle>
+<subtitle id="1:1:28"> the machine and screwdriver drops inside and shorts</subtitle>
+<subtitle id="1:1:31"> something out the machine does something you</subtitle>
+<subtitle id="1:1:34">it a feature rather than a bug and write it into the 500</subtitle>
+<subtitle id="1:1:37"> or so instructions</subtitle>
+<subtitle id="1:1:40"> this is what literally what they used to do a</subtitle>
+<subtitle id="1:1:46">long time almost none of them can be</subtitle>
+<subtitle id="1:1:49">compiled - and most of them can't be understood by machine code</subtitle>
+<subtitle id="1:1:52"> either you know they just sit there with</subtitle>
+<subtitle id="1:1:55">cubic feet of hardware to try and execute them</subtitle>
+<subtitle id="1:1:58"> machines like the PDP one and</subtitle>
+<subtitle id="1:2:1"> other delightful things that sprang out of the world</subtitle>
+<subtitle id="1:2:4"> when computer he had these very very</subtitle>
+<subtitle id="1:2:7"> simple way about going to do things and people noticed that they</subtitle>
+<subtitle id="1:2:10"> were pretty efficient even though they hardly did</subtitle>
+<subtitle id="1:2:13">instruction the reason of course for that is that</subtitle>
+<subtitle id="1:2:19">yeah if didn't take any time the machine was incredibly</subtitle>
+<subtitle id="1:2:22"> efficient it didn't have to hardly do anything machines</subtitle>
+<subtitle id="1:2:25"> are really sort of like ticking clocks</subtitle>
+<subtitle id="1:2:34">o from in the sixties</subtitle>
+<subtitle id="1:2:43">what is the entropy of the program</subtitle>
+<subtitle id="1:2:55">so in Paterson and se</subtitle>
+<subtitle id="1:2:58"> caen wanted</subtitle>
+<subtitle id="1:3:1">student project they wanted to do a processor they</subtitle>
+<subtitle id="1:3:4"> had a chance to look at this thing called the OM</subtitle>
+<subtitle id="1:3:7"> processor at Cal Tech which was a</subtitle>
+<subtitle id="1:3:10"> attempt to do an extremely clean computer science</subtitle>
+<subtitle id="1:3:13"> e type processor by Ivan</subtitle>
+<subtitle id="1:3:16"> Sutherland and Carver Mead turned out that was an utter failure</subtitle>
+<subtitle id="1:3:19"> it really was one of these</subtitle>
+<subtitle id="1:3:22">things where they got so enamored in dealing in the</subtitle>
+<subtitle id="1:3:25">what the machine was supposed to do they put it I mean</subtitle>
+<subtitle id="1:3:28">you know all the things that you read about in the books that are good</subtitle>
+<subtitle id="1:3:31"> they tried to do in this thing and it turned out to</subtitle>
+<subtitle id="1:3:34"> be a flop because the chip got very very large</subtitle>
+<subtitle id="1:3:37"> still only a 16-bit processor</subtitle>
+<subtitle id="1:3:40"> just didn't do very much so</subtitle>
+<subtitle id="1:3:43"> basically what</subtitle>
+<subtitle id="1:3:46"> what they did was to take a bunch of</subtitle>
+<subtitle id="1:3:49"> C code and pascal code and</subtitle>
+<subtitle id="1:3:52"> use a variety of ways of</subtitle>
+<subtitle id="1:3:55"> analyzing it's a thing called a gibson</subtitle>
+<subtitle id="1:3:58"> mix analyzer which is a dynamic way of</subtitle>
+<subtitle id="1:4:1"> analyzing what percentage of instruction is getting executed</subtitle>
+<subtitle id="1:4:4"> they look at the code statically</subtitle>
+<subtitle id="1:4:7">they came</subtitle>
+<subtitle id="1:4:10"> up with I think everybody has the the document</subtitle>
+<subtitle id="1:4:13"> they came up with a set of</subtitle>
+<subtitle id="1:4:16"> percentages of what things got executed when and what you</subtitle>
+<subtitle id="1:4:19"> had to do and they decided they had only optimized</subtitle>
+<subtitle id="1:4:22"> two things one</subtitle>
+<subtitle id="1:4:25"> was to try and have the</subtitle>
+<subtitle id="1:4:28"> instructions that executed 90% of the time executed</subtitle>
+<subtitle id="1:4:31"> one cycle and the other one was to</subtitle>
+<subtitle id="1:4:34"> try to reduce subroutine overhead</subtitle>
+<subtitle id="1:4:37"> okay and that is what they</subtitle>
+<subtitle id="1:4:40"> that is what they did</subtitle>
+<subtitle id="1:4:43"> and so they came up with this mead Conway</subtitle>
+<subtitle id="1:4:46"> design which is</subtitle>
+<subtitle id="1:4:49">traightforward in architecture as you could want</subtitle>
+<subtitle id="1:4:52">and</subtitle>
+<subtitle id="1:4:55"> several interesting things about the architecture I'm going to need some help here</subtitle>
+<subtitle id="1:4:58"> sigh I actually didn't get a chance to prepare for this</subtitle>
+<subtitle id="1:5:1"> because I I gave up my copy of that document which I haven't read for</subtitle>
+<subtitle id="1:5:4"> like six months but</subtitle>
+<subtitle id="1:5:7"> so call out</subtitle>
+<subtitle id="1:5:10"> when I start going astray</subtitle>
+<subtitle id="1:5:13">because of the simplicity and</subtitle>
+<subtitle id="1:5:16"> regularity on this thing they got an incredible</subtitle>
+<subtitle id="1:5:19"> ratio of controls day to</subtitle>
+<subtitle id="1:5:22"> act action state</subtitle>
+<subtitle id="1:5:28">you know what it is but</subtitle>
+<subtitle id="1:5:31"> I think this is like 25% it's like 75%</subtitle>
+<subtitle id="1:5:34">maybe it's</subtitle>
+<subtitle id="1:5:37"> 30 70 that's about almost opposite</subtitle>
+<subtitle id="1:5:40"> from what it is in most chips</subtitle>
+<subtitle id="1:5:43"> most chips at least half of the stuff</subtitle>
+<subtitle id="1:5:46">that's on that ship being in control gates one kind</subtitle>
+<subtitle id="1:5:49"> of another so control is very very simple here almost</subtitle>
+<subtitle id="1:5:52"> all of the silicon area on this thing is used for doing real</subtitle>
+<subtitle id="1:5:55"> things and because of that on a forty thousand transistor</subtitle>
+<subtitle id="1:5:58"> chip they could build a full</subtitle>
+<subtitle id="1:6:1"> 32-bit machine that's</subtitle>
+<subtitle id="1:6:4"> what they did so this is 32 bits wide</subtitle>
+<subtitle id="1:6:7">and survive</subtitle>
+<subtitle id="1:6:10"> it really into two parts</subtitle>
+<subtitle id="1:6:13">and the</subtitle>
+<subtitle id="1:6:16"> uninteresting part is sort of this part here</subtitle>
+<subtitle id="1:6:19"> and that is where</subtitle>
+<subtitle id="1:6:22"> things are actually done there</subtitle>
+<subtitle id="1:6:25"> are bunches of latches and ALU</subtitle>
+<subtitle id="1:6:31">shifters shifters first I</subtitle>
+<subtitle id="1:6:34">Wi-Fi recall and</subtitle>
+<subtitle id="1:6:37"> some buffers and so</subtitle>
+<subtitle id="1:6:40"> forth that's where stuff actually gets done</subtitle>
+<subtitle id="1:6:43"> on that ship then this part of</subtitle>
+<subtitle id="1:6:46"> the chip has I think 132</subtitle>
+<subtitle id="1:6:49"> registers and if I remember the number correctly these</subtitle>
+<subtitle id="1:6:52"> registers are mapped registered registers</subtitle>
+<subtitle id="1:6:55">words they're not registers you can get to directly</subtitle>
+<subtitle id="1:6:58"> but their registers that are used implicitly</subtitle>
+<subtitle id="1:7:1"> by the code in the in the machine and the mapping</subtitle>
+<subtitle id="1:7:4"> is kind of clever let's see if I can remember it</subtitle>
+<subtitle id="1:7:7">he register</subtitle>
+<subtitle id="1:7:10"> space for each process is 32</subtitle>
+<subtitle id="1:7:16">so you can get to 32 registers</subtitle>
+<subtitle id="1:7:19"> if I if I'm correct I believe nine</subtitle>
+<subtitle id="1:7:22"> nine of these are</subtitle>
+<subtitle id="1:7:28">and the</subtitle>
+<subtitle id="1:7:31"> other 24 are local to</subtitle>
+<subtitle id="1:7:34"> each subroutine</subtitle>
+<subtitle id="1:7:37"> then somebody thought of a real clever idea this</subtitle>
+<subtitle id="1:7:40"> is an incredibly clever</subtitle>
+<subtitle id="1:7:43">yeah they had two problems they hadn't saw one problem</subtitle>
+<subtitle id="1:7:46"> is how do you pass parameters back for instance</subtitle>
+<subtitle id="1:7:49">parameters are passed in the top of the stack just</subtitle>
+<subtitle id="1:7:52"> as opera and the be 5000</subtitle>
+<subtitle id="1:7:55"> and the other problem the problem</subtitle>
+<subtitle id="1:7:58"> is how can I map these guys</subtitle>
+<subtitle id="1:8:1"> in here in a very rapid way so I</subtitle>
+<subtitle id="1:8:4"> don't have to futz around I want to have 0 over again somebody</subtitle>
+<subtitle id="1:8:7"> got to what we should do is think</subtitle>
+<subtitle id="1:8:10"> of these registers as</subtitle>
+<subtitle id="1:8:13"> being overlaid like this</subtitle>
+<subtitle id="1:8:16"> so</subtitle>
+<subtitle id="1:8:19">I guess they grow from the bottom to the top so let's do it that way</subtitle>
+<subtitle id="1:8:22"> here's 24</subtitle>
+<subtitle id="1:8:25"> what we do at 60</subtitle>
+<subtitle id="1:8:28"> we're 16</subtitle>
+<subtitle id="1:8:31"> cuts off we overlap the next set of 24</subtitle>
+<subtitle id="1:8:37">okay</subtitle>
+<subtitle id="1:8:40"> result result of that is that these</subtitle>
+<subtitle id="1:8:43"> two guys share six registers those</subtitle>
+<subtitle id="1:8:46">registers are what it used for passing parameters forward</subtitle>
+<subtitle id="1:8:49"> and back these are if you will the in/out</subtitle>
+<subtitle id="1:8:52"> variables of the Pascal type</subtitle>
+<subtitle id="1:8:55"> thing that they're doing and thus on it</subtitle>
+<subtitle id="1:8:58"> goes now what that means is that the</subtitle>
+<subtitle id="1:9:1"> start address is of each register block that you care about</subtitle>
+<subtitle id="1:9:4"> is on a boundary</subtitle>
+<subtitle id="1:9:7"> that can be gotten to you by straight logic</subtitle>
+<subtitle id="1:9:10"> okay in other words they only in</subtitle>
+<subtitle id="1:9:13"> order to get one of these offsets they only have to or a</subtitle>
+<subtitle id="1:9:16"> number in to what ever</subtitle>
+<subtitle id="1:9:19">they don't have to do any actual additions</subtitle>
+<subtitle id="1:9:22"> just or whatever if you want</subtitle>
+<subtitle id="1:9:25"> to get variable five and this guy</subtitle>
+<subtitle id="1:9:28">here variable</subtitle>
+<subtitle id="1:9:31"> 5 this guy you're just oaring a zero 101</subtitle>
+<subtitle id="1:9:34"> into whatever</subtitle>
+<subtitle id="1:9:37"> one this this thing is in this array</subtitle>
+<subtitle id="1:9:40"> so there's no add here</subtitle>
+<subtitle id="1:9:43"> to calculate any of these things just slam the things together</subtitle>
+<subtitle id="1:9:46"> and whichever one is active goes</subtitle>
+<subtitle id="1:9:49"> up and down how many let's see how</subtitle>
+<subtitle id="1:9:52"> many of these is what is this 10 frames</subtitle>
+<subtitle id="1:9:55"> or something 10 frames 12 frames</subtitle>
+<subtitle id="1:9:58"> everybody know 16 so it's probably</subtitle>
+<subtitle id="1:10:1"> 9 frames or something like that so you could store</subtitle>
+<subtitle id="1:10:4"> nine frames and of course in a language like</subtitle>
+<subtitle id="1:10:7"> Pascal which is almost never used recursively</subtitle>
+<subtitle id="1:10:10"> this is a perfectly reasonable</subtitle>
+<subtitle id="1:10:13"> depth there's</subtitle>
+<subtitle id="1:10:16"> statistics showed that most processes that were</subtitle>
+<subtitle id="1:10:19"> written and passed down especially in C never</subtitle>
+<subtitle id="1:10:22"> went to more than a depth like this so it means that the thing</subtitle>
+<subtitle id="1:10:25"> never touches storage for all of its temporaries so</subtitle>
+<subtitle id="1:10:28"> it just runs like a bat out of hell</subtitle>
+<subtitle id="1:10:37">right this</subtitle>
+<subtitle id="1:10:40"> this particular this particular scheme is not nearly</subtitle>
+<subtitle id="1:10:43"> as good for less for instance</subtitle>
+<subtitle id="1:10:46"> for several reasons we'll look at it's not very good for</subtitle>
+<subtitle id="1:10:49"> small target because as we noted the small has</subtitle>
+<subtitle id="1:10:52"> both an object state and an activation state there's</subtitle>
+<subtitle id="1:10:55"> no place in here for the object state it</subtitle>
+<subtitle id="1:10:58"> has to stay outside so if you want to use this chip for</subtitle>
+<subtitle id="1:11:1"> doing something like small talk then you have to</subtitle>
+<subtitle id="1:11:4"> do something to it the</subtitle>
+<subtitle id="1:11:7"> other drawback on this is that the code on</subtitle>
+<subtitle id="1:11:10"> this thing what he thought was is</subtitle>
+<subtitle id="1:11:13"> I want the object code to be like micro code so</subtitle>
+<subtitle id="1:11:16">the code is humongous every instruction is 32 bits</subtitle>
+<subtitle id="1:11:19"> long whether you want it to be or not that's ridiculous okay</subtitle>
+<subtitle id="1:11:22">that is what the does that is what the design of this chip</subtitle>
+<subtitle id="1:11:25"> is so if you're willing to put up with 32 bit code</subtitle>
+<subtitle id="1:11:28"> on every squad this thing</subtitle>
+<subtitle id="1:11:31"> will run each instruction that</subtitle>
+<subtitle id="1:11:34"> it has in one cycle through</subtitle>
+<subtitle id="1:11:37"> the thing so there's no appreciable overhead on any of the</subtitle>
+<subtitle id="1:11:40"> calculations</subtitle>
+<subtitle id="1:11:43"> that take place in here that use this thing the cycle</subtitle>
+<subtitle id="1:11:46"> on this thing could be I think the chips that they're making now their first</subtitle>
+<subtitle id="1:11:49"> ones are are executed 200</subtitle>
+<subtitle id="1:11:52"> nanoseconds of crack and the design</subtitle>
+<subtitle id="1:11:55">this thing was to execute instructions at 100 nanosecond</subtitle>
+<subtitle id="1:11:58">crawling their way up to that now it's quite easy if you see</subtitle>
+<subtitle id="1:12:1"> there's nothing but the thing is doing look at a 68000</subtitle>
+<subtitle id="1:12:4">which is less than twice the size of this and it's</subtitle>
+<subtitle id="1:12:7"> a nightmare this thing is just laid out like Manhattan</subtitle>
+<subtitle id="1:12:10"> Island and it's very very simple</subtitle>
+<subtitle id="1:12:13"> the control is very simple so</subtitle>
+<subtitle id="1:12:16"> now</subtitle>
+<subtitle id="1:12:19"> you look at this thing you have</subtitle>
+<subtitle id="1:12:22">thinking thoughts because a hundred nanoseconds an instruction time</subtitle>
+<subtitle id="1:12:25"> is not that bad especially if you know ahead of time that most</subtitle>
+<subtitle id="1:12:28"> of those instructions are really working for you you've got something</subtitle>
+<subtitle id="1:12:31"> that you're worth it's really worthwhile thinking about building</subtitle>
+<subtitle id="1:12:34"> we know</subtitle>
+<subtitle id="1:12:37"> or at least we pay lip service to the idea that we want</subtitle>
+<subtitle id="1:12:40">higher-level languages here but very high level</subtitle>
+<subtitle id="1:12:43"> languages so the machine that simply execute</subtitle>
+<subtitle id="1:12:46"> spaz gal and see very rapidly it's</subtitle>
+<subtitle id="1:12:49"> not nearly as interesting and Atari research</subtitle>
+<subtitle id="1:12:52"> as it is in HDD turns out</subtitle>
+<subtitle id="1:12:55"> Apple is very interested in this machine they have been courting Patterson</subtitle>
+<subtitle id="1:12:58"> for some time because</subtitle>
+<subtitle id="1:13:1"> this is their language is</subtitle>
+<subtitle id="1:13:4"> a Lisa is</subtitle>
+<subtitle id="1:13:7"> a language that is</subtitle>
+<subtitle id="1:13:10"> basically Pascal with classes okay</subtitle>
+<subtitle id="1:13:13"> so those some of the things that small talk</subtitle>
+<subtitle id="1:13:19">so what can you do to this check</subtitle>
+<subtitle id="1:13:22">I just I think what</subtitle>
+<subtitle id="1:13:25"> I'm gonna do is just give you a couple of hints and into</subtitle>
+<subtitle id="1:13:28"> the next one one of these that we do on this thing will</subtitle>
+<subtitle id="1:13:31"> go through the schema more detail one</subtitle>
+<subtitle id="1:13:34"> of the things that we can do</subtitle>
+<subtitle id="1:13:37"> make it a little bigger</subtitle>
+<subtitle id="1:13:40">what we sure would like</subtitle>
+<subtitle id="1:13:43"> to feed in here our bike coats</subtitle>
+<subtitle id="1:13:46"> these things like those</subtitle>
+<subtitle id="1:13:49">code syllables one of the most ridiculous things</subtitle>
+<subtitle id="1:13:52"> in the world if you have a reduced instruction set</subtitle>
+<subtitle id="1:13:55">is to have the instructions be 32 bits long</subtitle>
+<subtitle id="1:13:58"> why can't we make use of the fact that we're</subtitle>
+<subtitle id="1:14:1"> actually doing a higher-level language unless we know where</subtitle>
+<subtitle id="1:14:4">is going to be it's really all relative addressing so</subtitle>
+<subtitle id="1:14:7"> we'd like to we'd like to use that but</subtitle>
+<subtitle id="1:14:10"> to keep the control simple at some place</subtitle>
+<subtitle id="1:14:13"> we have to have a PLA that will translate one of these</subtitle>
+<subtitle id="1:14:16"> guys to the wider paths necessary to control everything so</subtitle>
+<subtitle id="1:14:19"> one of the simplest things that we can do here</subtitle>
+<subtitle id="1:14:25">is to</subtitle>
+<subtitle id="1:14:28"> think of this area as being an instruction cache</subtitle>
+<subtitle id="1:14:31"> now in all the all</subtitle>
+<subtitle id="1:14:34"> of the studies on caching it's only a few facts have</subtitle>
+<subtitle id="1:14:37"> remained one of the caching works where paging doesn't because</subtitle>
+<subtitle id="1:14:40">ratios between the two memory speeds are different</subtitle>
+<subtitle id="1:14:43"> okay that's basically what it comes</subtitle>
+<subtitle id="1:14:46"> to catching has very small objects</subtitle>
+<subtitle id="1:14:49">and the ratios are usually no worse than a factor of 10</subtitle>
+<subtitle id="1:14:52"> so it works paging has very large objects</subtitle>
+<subtitle id="1:14:55"> usually in the ratios or factors of thousand or a hundred so</subtitle>
+<subtitle id="1:14:58"> it doesn't work the other thing that's</subtitle>
+<subtitle id="1:15:1"> known about caching is that code behaves much better</subtitle>
+<subtitle id="1:15:4"> than data does like</subtitle>
+<subtitle id="1:15:7"> a reasonable set up machine code</subtitle>
+<subtitle id="1:15:10"> has the</subtitle>
+<subtitle id="1:15:13">a very important feature that you</subtitle>
+<subtitle id="1:15:16">override it in the cache you never have to store it back</subtitle>
+<subtitle id="1:15:19"> out so the cache is just sucking stuff in</subtitle>
+<subtitle id="1:15:22"> then the question is what is the cache look like is</subtitle>
+<subtitle id="1:15:25"> it a full of sociation is it a overlapping</subtitle>
+<subtitle id="1:15:28"> code segment</subtitle>
+<subtitle id="1:15:31"> thing that held has to do with how complex</subtitle>
+<subtitle id="1:15:34"> the Association paths for interpreting</subtitle>
+<subtitle id="1:15:37"> addresses are that went down this way this control</subtitle>
+<subtitle id="1:15:40"> side here right up here would</subtitle>
+<subtitle id="1:15:43"> be a barrel shifter</subtitle>
+<subtitle id="1:15:46"> actually limited barrel shifter</subtitle>
+<subtitle id="1:15:52">that is taking</subtitle>
+<subtitle id="1:15:55"> these syllables and feeding</subtitle>
+<subtitle id="1:15:58"> them can think of these things is really proud of the</subtitle>
+<subtitle id="1:16:1"> variable size maybe 8 16 and 32 besides</subtitle>
+<subtitle id="1:16:4"> things what</subtitle>
+<subtitle id="1:16:7">it's doing is looking at the leading order bits of whatever's there</subtitle>
+<subtitle id="1:16:10">making a decision as to how much it's going to map down</subtitle>
+<subtitle id="1:16:13"> through the PLA that's going to cause control to</subtitle>
+<subtitle id="1:16:22">determine standard sizes</subtitle>
+<subtitle id="1:16:25"> true enough</subtitle>
+<subtitle id="1:16:31">yeah we should mention besides</subtitle>
+<subtitle id="1:16:34"> being a general man about</subtitle>
+<subtitle id="1:16:37"> town and a good fellow Steve Saunders thesis</subtitle>
+<subtitle id="1:16:40"> was on minimization of code size through</subtitle>
+<subtitle id="1:16:43">various kinds of compiling techniques and by</subtitle>
+<subtitle id="1:16:46"> going as he says by going to a variable</subtitle>
+<subtitle id="1:16:49"> length by taking the language that you got and going a couple</subtitle>
+<subtitle id="1:16:52"> of steps further than the risk people you can build a compiler</subtitle>
+<subtitle id="1:16:55"> that will generate optimal size code which</subtitle>
+<subtitle id="1:16:58"> can be peeled out just as easily as</subtitle>
+<subtitle id="1:17:1"> variable size of a few things definitely</subtitle>
+<subtitle id="1:17:4"> true providing that</subtitle>
+<subtitle id="1:17:7"> the largest size is no larger than this</subtitle>
+<subtitle id="1:17:10"> otherwise everything else is really quite easy</subtitle>
+<subtitle id="1:17:13"> okay the two more things that you have to do to</subtitle>
+<subtitle id="1:17:16"> make small talk or a language like</subtitle>
+<subtitle id="1:17:19"> it work on this chip there has to be</subtitle>
+<subtitle id="1:17:22"> a place where instance state is put I'm</subtitle>
+<subtitle id="1:17:25"> going to talk about that more next time let's just think that</subtitle>
+<subtitle id="1:17:28"> let's put their turns out in a</subtitle>
+<subtitle id="1:17:31"> language like small talk there's almost no depth of stack</subtitle>
+<subtitle id="1:17:34"> I think you can sort of because</subtitle>
+<subtitle id="1:17:37">control is always passing sideways to objects you're</subtitle>
+<subtitle id="1:17:40"> rarely going deep you're going sideways all</subtitle>
+<subtitle id="1:17:43"> the time and so the typical stack</subtitle>
+<subtitle id="1:17:46"> depth in the small talks is less than five</subtitle>
+<subtitle id="1:17:49"> so you need to have a cache for</subtitle>
+<subtitle id="1:17:52"> instance state here</subtitle>
+<subtitle id="1:17:55">we can talk about what that looked like later</subtitle>
+<subtitle id="1:17:58"> on then the final thing that we have to have to make</subtitle>
+<subtitle id="1:18:1"> a scheme like this work for small talk or Lisp is</subtitle>
+<subtitle id="1:18:4"> we have to let arithmetic run quickly</subtitle>
+<subtitle id="1:18:7"> or another way of</subtitle>
+<subtitle id="1:18:10"> putting it there is a subset of these byte codes that</subtitle>
+<subtitle id="1:18:13"> have to fulfill two purposes one</subtitle>
+<subtitle id="1:18:16"> is they have to refer to</subtitle>
+<subtitle id="1:18:19"> operands that are protected like in the B</subtitle>
+<subtitle id="1:18:22"> 5000 okay these guys better</subtitle>
+<subtitle id="1:18:25"> not know they're going after the integer or all is</subtitle>
+<subtitle id="1:18:28"> lost so that</subtitle>
+<subtitle id="1:18:31">hey're picking up it has to be something that was protected by</subtitle>
+<subtitle id="1:18:34"> one of those flag bits somehow and</subtitle>
+<subtitle id="1:18:37">cause an interrupt of what I picked it up as an address to</subtitle>
+<subtitle id="1:18:40"> something more interesting in an integer okay</subtitle>
+<subtitle id="1:18:43"> that procedure in Lisp is called unboxing</subtitle>
+<subtitle id="1:18:46">typical Lisp we're</subtitle>
+<subtitle id="1:18:49"> small talk address space so what a small</subtitle>
+<subtitle id="1:18:52"> talk is laid out in small talk 76</subtitle>
+<subtitle id="1:18:55"> 16 bits</subtitle>
+<subtitle id="1:18:58">pointers</subtitle>
+<subtitle id="1:19:1"> so that gives</subtitle>
+<subtitle id="1:19:4"> you a range of 65,000 things you can refer to</subtitle>
+<subtitle id="1:19:10">each</subtitle>
+<subtitle id="1:19:13"> thing knows how long it is and the storage</subtitle>
+<subtitle id="1:19:16"> manager knows where they are okay so these things</subtitle>
+<subtitle id="1:19:19"> are actually names the average object</subtitle>
+<subtitle id="1:19:22"> size in Smalltalk 76 was about</subtitle>
+<subtitle id="1:19:25"> 20 bytes so this</subtitle>
+<subtitle id="1:19:28"> gives you 20 bytes</subtitle>
+<subtitle id="1:19:31"> is about four and a half bits so</subtitle>
+<subtitle id="1:19:34"> this gives you about a 20 and 1/2 bit address</subtitle>
+<subtitle id="1:19:37"> space okay</subtitle>
+<subtitle id="1:19:40"> equivalent objects does everybody understand</subtitle>
+<subtitle id="1:19:43"> I'm sure in</subtitle>
+<subtitle id="1:19:46">other words so we we could refer to about a million words</subtitle>
+<subtitle id="1:19:49"> using only 16</subtitle>
+<subtitle id="1:19:52"> bits for a pointer size</subtitle>
+<subtitle id="1:19:55">turns out you'd like to refer</subtitle>
+<subtitle id="1:19:58"> to more than a million words</subtitle>
+<subtitle id="1:20:1">ixteen is maybe a</subtitle>
+<subtitle id="1:20:4"> power of two but boy that's all it is</subtitle>
+<subtitle id="1:20:7"> everything else is wrong 24</subtitle>
+<subtitle id="1:20:10"> is much better turns out but</subtitle>
+<subtitle id="1:20:13"> then in order to there's</subtitle>
+<subtitle id="1:20:16"> certain small things that you'd like to have implicitly encoded</subtitle>
+<subtitle id="1:20:19"> empty addresses in particularly</subtitle>
+<subtitle id="1:20:22"> encoded I forget what the way wound up</subtitle>
+<subtitle id="1:20:25"> but at one point it was like - mm the integers between</subtitle>
+<subtitle id="1:20:28"> - mm + mm</subtitle>
+<subtitle id="1:20:31"> were encoded into a section</subtitle>
+<subtitle id="1:20:34"> of that that is they never existed as explicit objects and storage</subtitle>
+<subtitle id="1:20:37"> assistant</subtitle>
+<subtitle id="1:20:40"> and resse is in this range that these things are actually integers</subtitle>
+<subtitle id="1:20:43">that it should unbox these are called boxed integers</subtitle>
+<subtitle id="1:20:46"> there's a box around them</subtitle>
+<subtitle id="1:20:49">other images were actually encoded as real objects</subtitle>
+<subtitle id="1:20:52"> part</subtitle>
+<subtitle id="1:20:55"> smaller okay</subtitle>
+<subtitle id="1:21:4">small arms in this</subtitle>
+<subtitle id="1:21:10">okay and the</subtitle>
+<subtitle id="1:21:13">so whenever these are encountered</subtitle>
+<subtitle id="1:21:16"> they have to be translated into something</subtitle>
+<subtitle id="1:21:19"> that's a real integer that can be go through the</subtitle>
+<subtitle id="1:21:22"> operation that translation has to be done at the last moment 3600</subtitle>
+<subtitle id="1:21:25">has a fair amount of circuitry to do that</subtitle>
+<subtitle id="1:21:28"> one thing we could do on this</subtitle>
+<subtitle id="1:21:31"> system what's supposed</subtitle>
+<subtitle id="1:21:34"> to be moseying the thing up to 32 bits wide</subtitle>
+<subtitle id="1:21:37"> like this machine is now</subtitle>
+<subtitle id="1:21:40"> I don't think we feel too bad</subtitle>
+<subtitle id="1:21:43"> about having a flag bit</subtitle>
+<subtitle id="1:21:46"> the fine bit can be very simple in</subtitle>
+<subtitle id="1:21:49"> fact I think in the scheme that I came up with</subtitle>
+<subtitle id="1:21:52"> I put the flag bit forward there</subtitle>
+<subtitle id="1:21:55"> and let it be zero if it</subtitle>
+<subtitle id="1:21:58">okay</subtitle>
+<subtitle id="1:22:1"> and if it was if it wasn't one then the thing</subtitle>
+<subtitle id="1:22:4">else in the other words we give up half the address space</subtitle>
+<subtitle id="1:22:7"> for numbers it's like what to be 5,000</subtitle>
+<subtitle id="1:22:10"> does and then I think we can see</subtitle>
+<subtitle id="1:22:13"> that if</subtitle>
+<subtitle id="1:22:16"> we decide to have a particularly simple encoding between direct</subtitle>
+<subtitle id="1:22:19"> operands and addresses</subtitle>
+<subtitle id="1:22:22"> and by the way I</subtitle>
+<subtitle id="1:22:25"> think you all realize that when I say one bit I mean</subtitle>
+<subtitle id="1:22:31">but one bit is enough for doing all</subtitle>
+<subtitle id="1:22:34">operating system things we want to do and essentially they're</subtitle>
+<subtitle id="1:22:37"> what we're what we need to do is to have some of this</subtitle>
+<subtitle id="1:22:40"> control state let the action</subtitle>
+<subtitle id="1:22:43"> go ahead because</subtitle>
+<subtitle id="1:22:46"> after the ALU there's this latch here</subtitle>
+<subtitle id="1:22:52">that has to be in the right state in order for the</subtitle>
+<subtitle id="1:22:55"> operation to mean anything okay and so</subtitle>
+<subtitle id="1:22:58"> one way of handling this problem of how can we write an</subtitle>
+<subtitle id="1:23:1">system in a really high-level language is</subtitle>
+<subtitle id="1:23:4"> just say every time we do a primitive operator like</subtitle>
+<subtitle id="1:23:7"> plus we realize that the plus may have lots</subtitle>
+<subtitle id="1:23:10"> of different meanings the small cog for instance that are probably</subtitle>
+<subtitle id="1:23:13"> 25 different meanings for plus 25 different routines scattered</subtitle>
+<subtitle id="1:23:16"> through the microcode and small talk code for plus 150</subtitle>
+<subtitle id="1:23:19"> meanings are print but</subtitle>
+<subtitle id="1:23:22"> there's one plus that better run as fast as the machine</subtitle>
+<subtitle id="1:23:25"> can run it and that is the one that adds two integers</subtitle>
+<subtitle id="1:23:28"> together okay the way to do that on</subtitle>
+<subtitle id="1:23:31"> this machine is to just let</subtitle>
+<subtitle id="1:23:34"> the right here you</subtitle>
+<subtitle id="1:23:37"> get to get a chance to look at both flag bits just</subtitle>
+<subtitle id="1:23:40"> let the operation perceive and</subtitle>
+<subtitle id="1:23:43"> then the decision</subtitle>
+<subtitle id="1:23:46"> whether to recycle is back on the C bus or the BB</subtitle>
+<subtitle id="1:23:49"> bus like this machine has it has to</subtitle>
+<subtitle id="1:23:52">state of those two bits are if they're both zeros then</subtitle>
+<subtitle id="1:23:55"> you got the right answer they're not both zeros you're going to have to</subtitle>
+<subtitle id="1:23:58"> do something more in which case the way you to do that is</subtitle>
+<subtitle id="1:24:1">interrupt but then looks at these things more closely</subtitle>
+<subtitle id="1:24:4"> basically ideas you have the generation generality</subtitle>
+<subtitle id="1:24:7"> you're willing to pay for but if what</subtitle>
+<subtitle id="1:24:10">not general then you wanted to have no appreciable</subtitle>
+<subtitle id="1:24:13"> overhead whatsoever you do</subtitle>
+<subtitle id="1:24:16"> that you now have a machine that will run if this thing runs in 100 nanoseconds</subtitle>
+<subtitle id="1:24:19"> doing what we doing what we said</subtitle>
+<subtitle id="1:24:22"> it will run it'll still run a higher-level language and run all</subtitle>
+<subtitle id="1:24:25">things that have to work quickly to do an operating system at</subtitle>
+<subtitle id="1:24:28"> that very same speed you've got</subtitle>
+<subtitle id="1:24:31"> a very nice little chip we'll talk about in more detail next</subtitle>
+<subtitle id="1:24:34"> eve probably has some comments</subtitle>
+<subtitle id="1:24:37"> yes you</subtitle>
+<subtitle id="1:24:40"> might mention something about the kinds of encoding</subtitle>
+<subtitle id="1:24:43"> efficiencies that you get when you actually look at</subtitle>
+<subtitle id="1:25:7">syndrome</subtitle>
+<subtitle id="1:25:10">pop-pop-pop-pop</subtitle>
+<subtitle id="1:25:13"> them do an operation with all the</subtitle>
+<subtitle id="1:25:16"> attendant shuffling bits around if you</subtitle>
+<subtitle id="1:25:19"> tell tell the operation what the compiler</subtitle>
+<subtitle id="1:25:22"> knows about it namely whether its operands</subtitle>
+<subtitle id="1:25:25">we're</subtitle>
+<subtitle id="1:25:28"> computed basically have to been pushed</subtitle>
+<subtitle id="1:25:31"> on the stack or whether they're direct</subtitle>
+<subtitle id="1:25:34"> in which case all you feed it is an address and it just gets it</subtitle>
+<subtitle id="1:25:37">you</subtitle>
+<subtitle id="1:25:40"> can save a lot of Pushpa</subtitle>
+<subtitle id="1:25:43">that combined with</subtitle>
+<subtitle id="1:25:46"> variable</subtitle>
+<subtitle id="1:25:49"> size fields dynamically variable size fields</subtitle>
+<subtitle id="1:25:52"> four addresses the only</subtitle>
+<subtitle id="1:25:55"> happening locally</subtitle>
+<subtitle id="1:25:58"> known names besides the locality varies</subtitle>
+<subtitle id="1:26:4">just to do those things straightforwardly</subtitle>
+<subtitle id="1:26:16">roll that together with the overlapping</subtitle>
+<subtitle id="1:26:22">in fact that's where the small named</subtitle>
+<subtitle id="1:26:28">what kind of packing efficiencies did</subtitle>
+<subtitle id="1:26:31"> you get in here thesis over listen</subtitle>
+<subtitle id="1:26:34"> bliss 11</subtitle>
+<subtitle id="1:26:37"> was taken as justice unity</subtitle>
+<subtitle id="1:26:40"> ctype language right yeah</subtitle>
+<subtitle id="1:26:49">thousand</subtitle>
+<subtitle id="1:26:55">benchmark immunity</subtitle>
+<subtitle id="1:27:10">my thesis stuff without any</subtitle>
+<subtitle id="1:27:13"> optimization that was the set point just</subtitle>
+<subtitle id="1:27:16"> just not customizing</subtitle>
+<subtitle id="1:27:19">straightforward nation on this variable</subtitle>
+<subtitle id="1:27:37">and that's that many fewer benches form</subtitle>
+<subtitle id="1:27:40"> with that much smaller phone sessions</subtitle>
+<subtitle id="1:27:46">that's</subtitle>
+<subtitle id="1:27:49"> why I say 30% like this the reason</subtitle>
+<subtitle id="1:27:52"> this is a very nice for Atari this</subtitle>
+<subtitle id="1:27:55"> is a very nice area and</subtitle>
+<subtitle id="1:27:58"> generally speaking there are other things you'd rather optimize</subtitle>
+<subtitle id="1:28:1"> first like the graphics situation but</subtitle>
+<subtitle id="1:28:4"> once you sort</subtitle>
+<subtitle id="1:28:7">you can do there this is the next interesting thing which</subtitle>
+<subtitle id="1:28:10"> is how can you run say</subtitle>
+<subtitle id="1:28:13"> artificial intelligence programs of some scope on</subtitle>
+<subtitle id="1:28:16"> a consumer level machine without going</subtitle>
+<subtitle id="1:28:22">six year you know the double cycle</subtitle>
+<subtitle id="1:28:25"> to get enough memory on the things</subtitle>
+<subtitle id="1:28:28"> this is one way of doing it small</subtitle>
+<subtitle id="1:28:31">talk was predicated on the idea that there would be some</subtitle>
+<subtitle id="1:28:34"> sort of solid state swapping device like a bubble memory</subtitle>
+<subtitle id="1:28:37"> that would match</subtitle>
+<subtitle id="1:28:40"> up so it turns out a bubble memory is a perfect</subtitle>
+<subtitle id="1:28:43">device for the particular algorithm that we developed a</subtitle>
+<subtitle id="1:28:46"> small talk 76 because it's not too fast</subtitle>
+<subtitle id="1:28:49"> it turns out it works better</subtitle>
+<subtitle id="1:28:52"> when the on a crummy disc it does huh yeah</subtitle>
+<subtitle id="1:28:55"> what you have is not as good as you'd</subtitle>
+<subtitle id="1:28:58">be in a particular way we went about doing things where</subtitle>
+<subtitle id="1:29:1"> it's much better and you</subtitle>
+<subtitle id="1:29:4"> get a system that can do real live no IRA is PI</subtitle>
+<subtitle id="1:29:7"> system which is an enormous enormous</subtitle>
+<subtitle id="1:29:10"> system done in a small time he uses everything in them that the dam</subtitle>
+<subtitle id="1:29:13">system had there's huge millions of bytes of code swapped</subtitle>
+<subtitle id="1:29:16"> in 80k bytes and it ran quite</subtitle>
+<subtitle id="1:29:19"> acceptable e running byte</subtitle>
+<subtitle id="1:29:22"> codes at the rate of about 300,000 per</subtitle>
+<subtitle id="1:29:28">okay this thing can run what we call byte codes which are those fast ones</subtitle>
+<subtitle id="1:29:31"> at the rate of 10 million per</subtitle>
+<subtitle id="1:29:37">speaking of aortic recep another piece of work</subtitle>
+<subtitle id="1:29:43">diversity</subtitle>
+<subtitle id="1:29:49">this kind of a mechanism which is in fact a general</subtitle>
+<subtitle id="1:29:52"> simple processor the only simple system</subtitle>
+<subtitle id="1:29:55"> that one should wire into it is the exceptionally simple</subtitle>
+<subtitle id="1:29:58"> one of small integer array</subtitle>
+<subtitle id="1:30:1"> there are other simple powerful</subtitle>
+<subtitle id="1:30:4"> subsystems in general simple systems</subtitle>
+<subtitle id="1:30:7">there are more primitives</subtitle>
+<subtitle id="1:30:10"> out there that ought to run faster we have yeah</subtitle>
+<subtitle id="1:30:13"> absolutely I'd like to I'd like to</subtitle>
+<subtitle id="1:30:16">some of those some</subtitle>
+<subtitle id="1:30:19"> of the stuff that underlies set</subtitle>
+<subtitle id="1:30:22"> set theory</subtitle>
+<subtitle id="1:30:28">really be useful yeah well as a</subtitle>
+<subtitle id="1:30:31">would have the same kind of disadvantage than 55-thousand he had that</subtitle>
+<subtitle id="1:30:34">programmer would realize that he needed it</subtitle>
+<subtitle id="1:30:37">but</subtitle>
+<subtitle id="1:30:40"> I think there are a few</subtitle>
+<subtitle id="1:30:43">simple systems</subtitle>
+<subtitle id="1:30:46"> on a different style than small</subtitle>
+<subtitle id="1:30:49"> integers that would turn out to be the right ones</subtitle>
+<subtitle id="1:30:52"> or a lot of what we do but</subtitle>
+<subtitle id="1:30:55"> I think that you know the this</subtitle>
+<subtitle id="1:30:58">whole coprocessor thing it's not done very well right now</subtitle>
+<subtitle id="1:31:1"> I don't</subtitle>
+<subtitle id="1:31:4"> I don't think that's right I think</subtitle>
+<subtitle id="1:31:7"> it should be you know you ought</subtitle>
+<subtitle id="1:31:10"> to be a mother s you</subtitle>
+<subtitle id="1:31:13">that there are that</subtitle>
+<subtitle id="1:31:16"> there are coherent small</subtitle>
+<subtitle id="1:31:19"> simple systems will provide useful basis for things</subtitle>
+<subtitle id="1:31:22"> address arithmetic is really where all the action</subtitle>
+<subtitle id="1:31:25"> is going on and all the stuff small pogrom</subtitle>
+<subtitle id="1:31:28"> is okay but there are a few other things like</subtitle>
+<subtitle id="1:31:31"> hashing functions okay those</subtitle>
+<subtitle id="1:31:34"> only become address or it would take through the contortions</subtitle>
+<subtitle id="1:31:40">or not why not pick one that's that's Universalist</subtitle>
+<subtitle id="1:31:43"> and build it in reverse so that hashing</subtitle>
+<subtitle id="1:31:46"> is a cheap thing just like indexing</subtitle>
+<subtitle id="1:31:49"> okay think of the power ahead gets you also</subtitle>
+<subtitle id="1:31:52"> reverse rotations for lost</subtitle>
+<subtitle id="1:31:55"> transforms and teas and stuff we</subtitle>
+<subtitle id="1:31:58"> know my list of what I came to Atari I first</subtitle>
+<subtitle id="1:32:1"> started thinking about designing a processor</subtitle>
+<subtitle id="1:32:4"> then I gradually dawned on me that a processor</subtitle>
+<subtitle id="1:32:7"> is actually very low on the totem pole priorities</subtitle>
+<subtitle id="1:32:10"> priorities I came up with us</subtitle>
+<subtitle id="1:32:13"> at the number one in the number two priorities</subtitle>
+<subtitle id="1:32:16"> have to do with sort of frame buffer</subtitle>
+<subtitle id="1:32:19"> and graphics</subtitle>
+<subtitle id="1:32:22"> chip a deadly embrace</subtitle>
+<subtitle id="1:32:25"> between those two because they</subtitle>
+<subtitle id="1:32:28"> trade off against each other so much number three is doing</subtitle>
+<subtitle id="1:32:31"> storage management</subtitle>
+<subtitle id="1:32:34">ell</subtitle>
+<subtitle id="1:32:37"> you one thing we trade trade this chip and</subtitle>
+<subtitle id="1:32:40"> no storage manager for a 286</subtitle>
+<subtitle id="1:32:43">the storage manager chip any day of the week</subtitle>
+<subtitle id="1:32:46"> and then finally down here is something</subtitle>
+<subtitle id="1:32:49"> like this is a reasonable CPU that</subtitle>
+<subtitle id="1:32:52"> will actually do something for you one of these</subtitle>
+<subtitle id="1:32:55"> interesting things you can get</subtitle>
+<subtitle id="1:32:58">efficiency here and then give up a factor of 200</subtitle>
+<subtitle id="1:33:1"> once you start swapping if you haven't worked</subtitle>
+<subtitle id="1:33:4"> out a thing so it's it's a question of where</subtitle>
+<subtitle id="1:33:7">getting probably these things is that there's so much easier to understand</subtitle>
+<subtitle id="1:33:10"> than these things that's</subtitle>
+<subtitle id="1:33:13"> why no hardly anybody works on these it's nobody</subtitle>
+<subtitle id="1:33:16">said nobody really understand you build one of these things and</subtitle>
+<subtitle id="1:33:19"> you don't build it programmable you're dead</subtitle>