Alan Kay's IFERS address at the American Film Institute

so either like essays which we have one

printed out is the proposal that I've

been asked to write for in his death this summer in fact the reason I'm here

is that the global got funded against all odds you'll see why if you read it

and so we're prospecting around for

smart interesting people who might want

to help us do this project the large project two million dollars a year for

five years in the staff vault at two

million they only fund the fund million

billion so we're really going to do it and as I go through this thing you'll

see that this proposal is somewhat far-fetched way it happened is that we

talked about this and my research groups off and on for decades always something

else to do and about a year ago or so

two things happened one was that Peter

Freeman was starting to fund the genie reinvention of the internet and I got

asked to be on one of them committees to

talk about it and remember sitting there thinking jeez the internet actually was

probably the best thing that my research community did in the seventies and we're

going to reinvent should be programmed and so I started

thinking a little harder about that and realized that it would be awfully

difficult to reinvent program pieces they're sort of been embedded in pretty

much the same paradigms for pretty much

as long as I didn't compute it pushes the ball with axes takes simular as

first appearing at 64 65 or so then the

stuff that were doing today it would not only be all too familiar except for the networking a lot

of the best people in the 60s would think what most people are doing today

in any case is extremely recognizable

and so let's you've been embedded in something for that many decades it

actually sets up a sense of normality we

have the sense of what's normal business

doing it so long it's actually hard to think really arrogant thoughts so the

other thing that happened is that one of the researchers and our Research

Institute India mardik who has been

interested in sort of now kind of

distant topic bootstrapping for nothing

for the last bunch of years actually started showing some real progress on

his latest system about a year ago and as you as I move it into what this

proposal is all about which is basically to take a very large computer experience

of the entire thing one of the things

that everybody here is very familiar with you can use off up a lot of those

lines of codes and thought and so you have to have some strategy to deal with

the issues at the bottom you can use them

thousand to ten thousand more life I

dude this can't do extend to other hunters

and so I guess the other introductory

meeting mark here is that my first

prepared this particular top and came a version of it I realized that my usual

approach which is usually critical that

is a lot of things that I think most people do is because they ain't

something somebody else has done and I

realized that informed criticism has been completely been done in my web

because the web has produced so much uninformed uninformed criticism this

kind of aggression sloth good circulation bad criticism is giving

good criticism out of circulation just can't criticize and so I've changed my

tune and tried to shift over to asking questions

now this talk will be successful if I can get you to read that paper and get

some of you to contact me so I had to

rewrite the story but I think it's a good story about our profession full of

comforters without it closed but of

course in the original story the kid declared that the employee had no

clothes

and it's interesting that my neighbors who are not computer scientists just

have questions like this if they ask all of the time and

try and think of something reasonable to tell why does it hit one

why is new restroom my wife just got a huge top-of-the-line palpable be tested

everything and the van slower than the mum that she hadn't discovered that's

because there's even though the this drive on it is larger she got the

largest one and there still wasn't enough room for all the passion the

system was doing to make it appear as though in fact the system is

unbelievably an efficient enormous amounts of disk space just to get five

course that's true after an update why

do I have to reboot my machine that's a really good question because you think

that things would be more lately down

yeah I'm confusing League authoring and

Microsoft Word which was originally done back in 1974 but for some reason I can't

do it in my blog my my wiki hey which

came much after and in fact I can't even really do much authoring in this most

useful browser thing even though

HyperCard was already 8 or 9 years old

why didn't it just into the browser

instead

yeah I think everybody here knows the answers

to those questions I hope you do you don't talk to me later I have my own

versions of these questions so pretty

much any of the computers we have today as pretty much what the total computing

and storage capacity of the entire internet was around 1986 or so Sandra's

been trying to figure out exactly and but the internet already had zillions of

knows it was already growing and working quite well in the mid 80s it was very

simple then it's very simple now but what happened what's inside when I look

inside the PC or Mac I don't see anything that's like I didn't see any

scalable architecture then they are to expect to see thousands of virtual machines but in fact talking to my

friends at Microsoft they said rarely does Windows XP ever had 120 processors

because the Internet has been able to

scale by 12 orders of magnitude but it

must be a reason as a systems person I'm really interested and I'm interested in

how the system software on these computers hasn't scale past it

especially since you can throw away the operating system essentially just get

bid

and etc etc

as I did a little calculation you're

having a lot of books I have a

collection of encyclopedia Britannica's and my favorite is the 14th edition the

classic one as each volume is about a

thousand pages long it's about ammunition and to stack those up you can

sort of read for yourself eleven thousand volumes of thousand things you

see so many pages of so many lines of text actually if you start counting

lines of code in just the operating

system and windows application so far to get to a quite a few lines of code it's

probably more than this after some

comparison is completely unfair so I put samples there down here is this system

I'm using to give this presentation which also is its own operating system

that was its

Xerox PARC and everything being done

here is being done by the system sockets

and everything yeah it's about two hundred thirty thousand yeah so just to

prove that

[Laughter]

so it's actually if everything is

dynamic and live no mode which is my identity it's kind of it's one of the

things that we've done over the years speak is only about ten years old it's

just this small company because we feared Java wasn't going to really be

compatible across machines stand the

test that wasn't ever produced

or the way we used to do it is to make an actual model of the virtual machine

translator to translate so this system

I'm not going to Virtual Assistants old obsolete system solutions - 1970

but the system does run bit identically on doesn't and if you're going to be on

the internet kind of have to run identically because

otherwise you know so thinking about the

functionality here we did a little test

and indicated that pretty much all of the time we're only there's 100,000

lines of it and we started wondering about well how small could you make it

if you didn't do it in 1970 small talk like what if you actually tried to do

some higher-level and various handlers

got us down thinking well the interest in machine coaching for twenty thousand

lines and of course we never intended that we're going to do this because who

would fund us nobody today and it might

even be hard to get market

yeah 60s but without 20 thousand lines of

code be pretty nice because that's about a 400 page book employ one book is

different than an encyclopedia and

that's because our brains don't scale

the only way we can scale things is not by size but by abstraction everybody

there's nothing in this pocket

and then we thought well 20,000 Minds

code that would be really interesting what if you could also explain it you wind up with something about the size of

my book and this book is one of the

great books of all time we do not have an equivalent book really a shame one of

the reasons is that biologists are incredibly fortunate in the nature has

already presented them with living things and what they spend virtually all

of their time thinking about is how those things work all the different

other ways you can think living things so all I have to do is mail it get a

couple of geniuses to write five or six editions of this book and you get this

masterpiece this book doesn't even require you to know anything about

chemistry start meeting just open it up start media and it just takes you along

you know a lot about it's not a light so

we started thinking about that and I wrote a white paper as I usually do

just to try and think it through I never

finish these white papers but I hand them out to everybody and what amazing

thing happened is that the summer NSF called me up and asking about you trying

to trim that white paper proposal I still don't know exactly why this is dr.

King because there's a high probability of failure in fact the difficulty with

the viewers hands of the proposal is that you'll notice when you read it that

it actually has sections in there who say we don't know what the feeling on

this part and that used to be okay a long time ago because that's what

research determines been doing research and engineering engineering you're

supposed to get that jet engine working and not have the cleaning fall out of

the sky whereas research he kind of wanted to fall out of the sky and it's

uninteresting what so

then they surprised us by funding it and

this is part of our kind of Grand Challenges list that we think people

should be one of the most interesting things that I think of it again

everybody in this room this talk is so full of cliches I can't stand it but you

know there just hasn't been a Moore's law for software just incredible yes the

toughest culture progressively slowed up yeah probably get worse more maybe

inverse-square work so that's an

interesting one to think about what what would it mean to do something that's

around two orders of magnitude improvement targeting imagine whatever

interoperability I just can't believe whoops prison would be great if we have

and I've always been pissed off that the

vendors aimed personal computing sit at business where we have the least

inviting the least interested computer and users the most boring people and

horses but it's really bad because the people

who should be joining our field and should be having fun they don't see the

fun that we realize now that we've been

analyzing English language wrong suffix

thing actually is an negation operator

so fun being don't know why this stuff

is done in the first place and these

last two I won't bother explaining with the are they're really critical one of

the one of the things some of us old people decide to do is to take matters

into our own hands and try and make a

difference Anita Ponte and I and a bunch of other people decided to do this

undergoing a laptop and just like I do it on the grounds that all the laptops

are made in Taiwan anyway the world's

largest laptop manufacturers wanted this 43% of all the glasses world with all of

the Hewlett Packard's all of the Dells most of the Sony's and half of the

Macintosh

I also make this place Nicolas talked to

the CEO of quanta through the following

wonderful proposition which involved

showing this guy how many hits the

hundred dollar laptop is getting on Google how few hits this guy was getting

on Google and so the wonderful end of

the story was that not only this guy agree to build this actually put in a

substantial amount of funding including

enough funding to do give remarkable display on this machine so less than two

years since this project started and the first thousand factory built machines

just appeared last week I came within a couple of days of being able to give

this talk on this issue and in order to

do a real computer for the cost of a

little over hundred dollars one thing to have to solve displayed the CEO of One

Laptop Per child is extremely talented

lady scientist can used to work for Intel specialist displays and she was

she had the guts to actually design and really invent a new kind of flat screen

display as a product and completely Avenue critical path and this display

had takes 1/7 the power of a new display

just shows that 15 or 20 people who are

determined can do pretty much anything well I hope that Nichols gets the Nobel

Peace Prize for this because it is they will manifest this thing out of almost

nothing I'm going to get buyers for the machine funders for the project builders

for the thing and it's actually happening but of course the children's

computer is not the hardware this the

experience that's on it that is a different matter entirely

quickly let's go I'll leave that side so these are things

that affected me deeply when I was younger and essentially this

project is looking at the physicists

with envy and saying please

every time the physicists do something it starts out messy and then they wind

up inventing some mathematics and it

really fits into an iPhone and if this is what I feel you can actually notice

things about it that are hard to notice that it's 10 to 15 pages long like

certain asymmetries between the electric and magnetic field attracted Einsteins

attention that probably shouldn't have been here and this is my Bible when I

was a biologist and particularly like

this this is the constitution of the US

and think about it's the colonel some can think of as metaprogramming but it's

the colonel of an operating system that's been running with millions of not

terribly cooperative parts being with us for hundreds of years and hasn't broken

think about it Annetta ideas here I had to be small in

order for them to work those guys really

knew what they were doing and astoundingly everybody who worked on the

Constitution the United States ramp is actually educated here everything

possible yeah so I started in graduate

school ivan sutherland had already done sketch

pad which used the kind of a field idea so i'll get you in a little bit and the

big topic of conversation 40 years ago was the ARPANET which hadn't been done

yet and Lickliter this guy called it the intergalactic

network even in his reports to the

military and the reason to use that term is that he was convinced that networking

was bad in the 60s because people weren't thinking big enough they were always trying to solve little

problems particularly vendors like IBM

and the vendors were trying to build perfect little machines that were half

duplex rather than full duplex and so forth and when I started in graduate

school the publication's of Simula in

this country had just come out a few months earlier and it turned out all

three of these things were abstractly similar this had a thing that wasn't

called objects in it but that was the way the graphics system was organized

this had separate things that were supposed to cooperate in some form by

sending messages this was designed for huge oil refineries in Norwegian

shipbuilding and my background was I had a math major and a biology major and

these things just all looked very very

similar they look like a network of

computer like things just sending

messages around and didn't have the way that was hardware or software and I

thought boy we have a hundred trillion cells in our body and it only took 40

cell divisions in order to make us actually takes 50 but 10 of those cell

divisions are actually used up in debugging in destroying cells one of the

nicer things that Nature has has given us so this became kind of a mental image

for the systems and pretty much

everybody in the ARPA community also

felt the same way and there was also a computer done by this guy Barton that

was had the structure in it this

computer that be 5000 had 7 for my money had 7 out of the 10 best ideas ever done

in software put in the hardware of the machine designed in 1961 happened to be

by luck the third machine I ever had to learn and it's be quite recognizable to

people today because every byte encoded VM on the planet is a software version

of what this machine executed directly alright so this was the first computer

and almost the only computer where the designer of it said you know people are

going to write in higher-level languages so let us make a piece of hardware that

will optimize that instead of think

about what we have today we have everybody you're trying to write in higher-level languages and yet we have

to emulate the hardware environment they should be running in because the

computer chip vendors refuse to learn

anything about software so I think I'm just think about how out of whack this

is and the other book I carry around is

this because bottom half of page 13 had

the other part of the question so if objects are the way to organize things

how do you organize the methods and one

of the ways of thinking about it is to think about it in the self referential

way that McCarthy arrived at and of

course there are zillions of universal Turing machines before McCarthy did this the interesting thing about what

McCarthy did was it was the first time anybody had done a Turing machine that

had slope to it it was not just Universal but it was actually within

some short Hamming distance of whole

bunches of interesting computations and yet it was still small so that says

something interests I've always thought about this is the math Maxwell's

equations of programming right and of course what what we need now is the

relativistic equations for programming whatever that means so so the other

thing about the ARPA community was it had big ideas it wasn't just the group

of us we were a part of the ARCA community but we were by no means we

wound up getting the better books written about us but in fact the ARPA

community itself thirsted after this

notion of being able to provide people with a kind of an amplification of their

intellect an amplification of their intellectual reach both in time and

space in ideas and and so forth and so

this whole community cooperated and talked with each other very well and one

of the key parts of it was this early

workstation or first workstation called the Alto

which among besides having the the screen on it it was about fifty to a

hundred times faster than you could get on time sharing so all of a sudden when

you sat down to this machine you're sitting down to something there was a bit like a supercomputer and immediately

you found that there are a zillion things you could do without optimization

so you can go out and drink a pitcher of beer at lunch and do five or six

complete experiments before suppertime

because you have this machine and he didn't have to optimize you could just

throw the code away you write these short little snippets of code and since

most ideas are mediocre down to bad the

whole idea is to be able to have lots of ideas and get rid of most of them so

this is a perfect setup for that and

it's interesting to look at the specs

here so a clock speed today is x 75

bandwidth is x 150 11,000 larger main

memory disk is out of sight tenth the price but if you look at Moore's Law

it's 23 doublings since then so that is

a factor of eight million and you know

no matter how you twist and turn this you can't find eight million in there

something is not scaling and my favorite

guy to be critical is Butler so he has

the harshest thing I'm usually I've

usually been the harshest but I could only the benchmarks that we did show

about a factor of 600 has been lost and Butler has pretty good figures that show

a full factor of a thousand I think about that that's ten doublings right

and the doublings happen every year and a half all right so that means fifteen

years has been lost because of bad architecture

and so there's this myth that says don't

do special purpose hardware because Moore's law will always overtake the

special purpose hardware little shit that's not even close actually what's

happened is we've lost the factor of a thousand in efficiency because we can't

run a code the way we want to what it

needs to be run that's a really interesting figure to go go back and

look at so another thing we tried to do

at Parc so I'm not going to dwell on much here but we just noticed that the

thing that was most like the user interfaces of the 60s was a nuclear

power thing or maybe a nuclear submarine

thing where it takes 20 people to run the the application on it and in

personal computing you really can't have that you really need to have something

that's explorable undoable something and where the main thing you're trying to do

is not so much functionality but learnability basically taking the idea that if there

is going to be progress then you have to somehow build in learning into the thing

because no great idea that is put on a computer that is not learn about is a

great idea I ain't there so we saw this

as a huge switch and without trying to

be critical about today I would say today's user interface is even on the

parked models are way too much like this people actually take training courses

for them so

so one of the things we thought that would be neat if we did this project

since it would be so small it would be interesting to try and think of it also

as the museum on itself what would that mean so it wouldn't just be reflective

but it would actually be introspective so it actually not just be a model of

computation but it would actually have a model of itself and so that suggests

become a rather different kind of user interface yet to be designed so I think

architecture is the key here again I'm not saying anything people don't know

and I'll just put up three pictures here

most software today feels like this to me because once software gets beyond a

certain size you can only add around the edges right it grows by accretion you

can't really do much of anything else and over here we have something that

nobody in computing knows how to do what I call real engineering Empire State

Building was built by less than 3000 people in less than a year they had to

demolish the old Waldorf Astoria Hotel in order to do it the steel arrived from

Pittsburgh still 110 degrees hot and the

framing went up at the rate of two floors a day each floor the Empire State

Building had a narrow gauge railroad on it and it had three times as many elevators going up the side just to get

stuff up there then the mid then the building has today was one of the great

building jobs and anybody who has pretensions to be an engineer should get

any of the four or five marvelous books including a Foreman's notebook which has

been reproduced in facsimile that had little snapshots that this guy had taken

in the No Pike a typewriter talking

about what was going on so I claimed that nobody in computing knows how to

organize 3,000 people who do something really big and get it done in a year so

whatever software engineering is it isn't anything like modern engineering

software engineering is more like that

like architecture before they were arches I think the best practice is

rather more towards the pyramid you could call this a form of dynamic

object-oriented programming or pick your favorite architectural thing that just

isn't brick like and yeah you can build big structures that are the size of this

thing with one millionth the amount of materials but if you think about how

primitive the best stuff that's done today is its epaulet so my favorite don

quote here is beware of bugs in the

above code i've only proved the correct not tried it and so what we have is a

new kind of mathematics by old math is

tiny little theorems that have an infinite number of instances and what we

do in computing is things that are

finite but huge do to beyond the worst

nightmares of any mathematician and so we don't get to prove anything

interesting piece to my theoretical

friends but essentially proving

something as np-hard is not interesting because you can still build it build

anything you want so the real question is how can you build it and debug it and

this is what makes this talk difficult because I'm used to giving talks about

stuff that we've already done but here's an analogy that won't play the Tacoma

Narrows movie but I love this movie but everybody here has seen this movie any

number of times it's just the great movie it's wonderful that the person who

predicted that the bridge was going to go down had predicted it more than six

months ahead of time and had predicted more or less the

magnitude of the wind a wind that nobody thought would ever happen 95 to 100

miles an hour and so six months or so

later they were measuring a 95 mile an

hour wind in the Tacoma Narrows and so

they actually went to the camera store and as this is online you can go to the

website of the camera story that they got the movie cameras and he just set

the movie cameras up at the end of the bridge turn them on and just let the

whole thing happen that's so great but

so to me computer science is a science

that requires an artifact to be made so

this project is partly to make an artifact that is can be actually studied

now the problem is 100 million lines of code can't really be studied so you have

to make something that's actually study above but it has to be big enough to be

interesting so we decided to take

something that we understood and just try in like this chain of being up here

from tiny little building blocks to more and more complex architectures of things

so this is at least my favorite slide and sooner it's key in my lifetime

people were right around there this is Linus I was born when Linus Pauling did

his book on the chemical bond in 1940

and I was 13 when Watson and Crick did

DNA and we're now up to still thinking

there might be a miracle or two in intelligent behavior but all the ones

before hand have turned out to be architectures of things so

for this system we've got basically something that goes from the power

supply up to the end user and we really

have to do all of these things and we're

going to leave some of the logic gates alone but not all of them because the

not just the temptation but the things that can be accomplished by using field

programmable gate arrays is just too great all right the thing that made the

alto interesting at zero Xerox PARC was the microcode the micro code allowed you

to make an emulator for a desired virtual machine that would keep main

memory busy and that meant that no

custom-made hardware could run any faster the thing was memory bound period and

field programmable gate arrays actually allow some really interesting thoughts

and as you read in the proposal the

there about a dozen principles in there I believe every one of you knows every

single one of these maybe there's a couple that have escaped you but

basically there's nothing here that is

particularly remarkable and in in our

diagram here essentially this middle

area is the area that we actually don't

understand very well it also is the place where the most interesting ideas

in this system if they are going to appear are going to appear and we know

something about how to do this pretty well and we've done a lot of experimentation up towards the end user

sign I'm going to give you a couple of examples before we before we quit and

have some chance for some questions so

we did this system call eToys for

children and

while we were wanting to make it really simple and while we were doing it we

thought well let's we can toss a few

more things in there that the children

may or may not find but we can try out some of our pet theories so basically

one of the inspirations for etoys was

thinking about what would a hyper card on steroids be like what if it were just

had a really powerful simple object model and it was Universal and okay it's

a little car that a child might make and

makes it into it into a thing and I can

like I did before I can drag out some

tiles here from the viewer on the on the car and I'll just start the the car

going now we saw that there was a little

halo of stuff on that object and you

know here's another thing that's on a

photograph and so I could possibly drag

out something on it and here's another object which is the script but it's also

got one of these things so so maybe I

can write a script for it and I can come

over here perhaps and grab on to the

thing that's there like that and

actually this whole thing I'm in this world die I'm in here

I can look at it and so that one of the

ways of thinking about this system is

instead of having a class object in a zillion this subclass only has one kind

of object this is a universal object

idea and the objects have different costumes and to give you a kind of a

sense of this I'm going to suppress all

the graphics and this it helps you see

that all of these things are actually the same this idea goes back a long ways

because when we're doing the Alto at Xerox PARC one of the thoughts we had as

well to a naive user everything on the

alto is just a smart rectangle the windows are rectangles the characters

are rectangles and there's some sort of function and magic behind them and that

should allow you to make a different kind of object system than the one that similar thought about now of course I

have to remember where I did this so I can change this thing back here okay so

I'll just show you a few more examples but basic idea here what I'm trying to

convince you is that the media part of this system is just endlessly recursive

in fact one of the things that I forgot

to do here is to show you how this presentation was made this is an idea we

could never convince Apple of but at

Xerox PARC we had unlimited desktops and

the reason was that a desktop is a unit of work it's not a place where you go

and you do a project that persists over days what happened when this interface

went to Apple and then to Microsoft is that they forgot about the workflow

aspect so you have the silly thing of people building up windows and collapsing and building up windows but

what you really want is something that's over time so if you look carefully up

here you can see the presentation that you've seen so far and that is because I

can have any number of sorting zuv these desktops right these desktops are like

web pages I can hand them around except they're full blown media with objects

they run in a browser because squeek can be a plugin but I can also sort them so

if I want to come back to my miracle happen slide next I can put put it in

like that and say okay and I'm going to call it the entail November 27 talk I

can use these guys over and over again here and so if I go now to the next

slide it's not the one that I had but it's the one that I just put in there

see how simple this this is why PowerPoint is bad PowerPoint is a thing

that essentially neuters any powerful thing that you have done it's unpowered

you do this wonderful thing and then you have to copy it into this weak thing in

order to show it but you can't show any of the dynamics right whereas what you

really want to do is just work in the thing and some of them you're going to show on some of them you aren't going to show okay here's another idea and again

using the children's programming and

this is just a little salmon here following a brightness gradient you can

read the thing fish is always going forward by five the last scene thing is

greater than the brightness under the fish so I'm plotting what the fish is

doing over here if it's yes keep on going straight up no just just turn

randomly and so the wonderful thing is

that this fish will eventually wind its

way up there and every living thing has

this little algorithm built into it and

evolution has this algorithm built into it this is what evolution actually does

doesn't do anything more than this then

the fun thing is so having done such a simple little hill climbing thing then

if you have a particle system that is programmed the same way you can do

something much more interesting here but almost as easily so these are a bunch of

ants and this field that the ants are on

is actually 10,000 little patch

computers that are handling the defusing

of the pheromones and the evaporation of them right and so even on this little

laptop that I have we can do a million particles at 10 frames a second okay

from these tiny simple little programs I think most of you are aware that Tec is

an example of a system that is able to do a very very good job of solving

certain kinds of constraints for dealing with these and so this metaphor is

spoken about in this paper as particle field programming so just a zillion

things like sending messages in an object-oriented language is one of these

things you can think of this as a tuple space for Linda if you want right

there's just a zillion things where you want to be able to have an environment

and one of the differences between this

children's environment and say squeak or

Java is that the objects in here can all

see each other because they're in the same and they're actually situated we

don't use lists sharing so I'll talk uses list sharing but the e toy system

doesn't so everybody knows where they are ok so here's an example of particle

field programming so here's a little

here's a little text paragraph so I'm

just getting it to justify itself everybody has done

this program but maybe not this way this

is the entire text editor shown on the screen here and I'll reveal what's going

on here by letting these guys loose okay so each one of these is a little guy one

of those ants and so the formatting if I

tell them to just wander back you can see them following the leader if I tell

them the hot back then they they stop if

I tell them the snap back they snap back and now they do that thing in between

the frame time and this system the

process switching and the message passing have are the same speed all

right so it actually doesn't cost you to have two hundred thousand processes in

this system you can just use them and all of a sudden you wind up with these

extremely simple like this is all you need to do the formatting and this is

all you need to do to do the selection

so if I draw through each of these guys

is actually looking out to see where the thing is and the editing for doing it

so let's see this is a Japanese keyboard so I have to be careful here maybe this

one nope

that one okay

the well the spellcheck is usually done by having lots of examples right I don't

know of any algorithm that understands English intrinsically so I'm not sure

what your question is but sure you you mean the thing to check to see whether

you're at some interesting Hamming distance from the thing I don't know

because we haven't done it so I'm just taking Don Knuth escape route here but

it better be because the system in order

to fit into 20,000 lines all of this stuff has to be done in this kind of

Model T Co because the basic idea here is that you should be able to give you a

little example here is a simple animation program and the kids just made

different examples in both this two liner and the movies are essentially

animations so here's the movie for

dropping a ball in this gravity thing

and that is exactly the same code at the

end user level and this movie is the

so this movie has exactly the same two liner but there are things in between

now this thing is actually fetching the frames off the disc it's doing an MPEG

decoding of them and so forth but the master code for what the movie is and

what the user interface is exactly is

exactly the same and I won't okay and

I've already showed showed you this but this is kind of that answe thing done as

desktop publishing or maybe not

so the text runs around and

so now it has this is a harder task because it has to do the anti-aliasing

on the text okay now of course the kids

system wasn't actually made to do this

but now let's just take maybe one example from down here as maybe the last

actual example here's one that I already mentioned is that you should be able to

put replace any wiring system with an Ethernet and I believe you should be

able to replace the hundreds of difference of ways that messages are

sent to each other in operating systems by also something like that that is you

should be ever replaced an operating system with an Internet internally and

another thing that is kind of annoying

it goes all the way back to Tony Hoare and Dijkstra is the idea of using

semaphores and monitors and stuff like

that and the problem with those is that they cause various kinds of bottlenecks

and lock up and at the very same time when that stuff was being done the

Simula guys and john mccarthy separately we're doing a much better way of

thinking about the stuff and that is to run your computations in pseudo time

when you run in pseudo time there are no race conditions that are not detectable

because you're basically labeling every state and you're essentially only

advancing the pseudo time clock when you're not doing any computation I will

not go too much further but a very

interesting example of this as Dave Reid's thesis read is the guy who's the

slash in tcp/ip he was the guy who

suggested separating them and his thesis was about how to distribute computations

over the Internet right so the idea is there just so many

examples where you have to essentially clone an object that you want to remain

large indistinct so you essentially have the dynamic version of atomic transactions

on distributed databases except you've got objects danso reads thesis was one

of the first schemes that allows you to do that kind of coordination safely and

it actually works well enough so that you can do something that appeals

appears to be real-time to the end users

okay and I just refer you to that we have done two versions of this and if

you're interested you can go look at croquet on the on the Internet

so this is a essentially a model of

computation where time is actually part

of the model it's not something that happens to you from the outside it's

something that you were actually controlling okay so the this is Ian P

amardas work and I suggest having him

invited if you're interested in this stuff this is pretty neat I think if

this is good old-time computer science because it's something that was big in

the late 60s which was how can you do extensible languages from tiny kernels

and still have them run very well so we

can describe the system as a little golden box and the golden and this some

of the people in this room I'm sure have done things kind of like it so for

example one of these pages of the couple

hundred lines of code here looks kind of like a BNF and it has patterns that are

translatable and so 150 lines or so into

the golden box makes a JavaScript or

Python or Prolog or pretty much any of the languages today the JavaScript one

runs about 20 times as fast as the one in the browser that's because the golden

box generates machine code for a wide variety of forms not interpreters okay and so this

is a key part of this thing is you'd like to have something that has all of

these wonderful self reflective properties but is still able to compile

fast code and then the other trick that the golden box can do is a thousand

lines of code put into the golden box makes another golden box so in fact in a

week you can experiment with three or four programming languages change the

golden box and the next week you have a different golden box and you have a

different set of experiments we've been doing this starting in the starting in the summer

and as Mick Jagger it might say it's only math and science basically this is

something that many of the graduate students I've run into just have never

had the experience of bootstrapping from scratch because they're supposed to

learn Java they're supposed to learn all

event you know you think they were going to some sort of trade school rather than

learning how to do real computing

actually an interesting example of that

just show you so this is about three

hundred lines of code so we're going to

make a JavaScript from scratch and then give it a Tetris program

if it makes this little engine

you know why jack graduate students are a lot faster than I am but you get the

idea so that's like about 350 lines of

code to do that and part of the

experiments down here just to do lots of these to try and understand what the

what the best balance because we we actually can't spend a lot of time and a

lot of lines of code down at the sand and be successful in this project so the

next project in the golden box is to do tcp/ip because it might sound kind of

weird but if you think of tcp/ip it's kind of parsing and pattern matching problem if you were to look at it from

that like you can think of as kind of a pipeline process with non-determinism

in there in an interesting way and so we think it can be done in around 200 lines

of code and actually run fast enough to fulfill what tcp/ip has to do on the on

the network and that would be a very good test of some of these ideas okay so

so the approach here is to say that

there's there's really two things that have gotten smashed into one in

computing and actually there's a psychology that has arisen because of it

so my first machine in 1961 was an 8k by

1401 and in those days the number one

thing that a programmer had to be able to do was to cope and I would claim that

over those 46 years 45 years but that is

pretty much stayed constant that a large

part of what it means to be a programmer is to be able to cope with what's there because the kind of that's what they're

paying you for problem is that's not what they're paying graduate students for right graduate students need to say

no I'm not going to cope with this this is shit I'm gonna do this this and this

but in fact we hire people who have a huge background in programming and so

they're willing to show how much pain they can take

when you give them some system and they tend to just add on to that system

instead of saying this is shit that's a huge problem

so what one of the things that this is

one of the most important parts of the system is to completely separate out the meanings and the meanings are not going

to be expressed in terms of unit tests or just predicates the meanings have to

be expressed in terms of a runnable code sufficient enough to get the entire

system running but the meanings are going to be completely separated from

the optimizations completely so that any

set of optimizations can be turned off while the system is running it'll still

run so bottle tea here I grew up with

model tea on a farm in Massachusetts

reason they were still theirs you could not really destroy a Model T we would

have to grenade it or something because it was made out of cast iron and this

the farms all had little black smithy things and it only had about 350 main

parts and about a thousand screws and other things and basically a twelve or

thirteen year old could take it apart on the floor of a barn do something to it

and put it back together over a weekend and yet it was a completely real

automobile so it's just you know wish

people had that experience and the reason I put this dime here is to remind

me to say that the spark gap on the

Model T was set by the thickness of a dime and when they asked Henry Ford why

did he do that he says well people lose gauges but they usually have a dime on

them imagine any automobile today being

done that way like you have to put on a

radiation suit to open the hood of them so the so that the premise here is that

the actual meaning the meaningful semantics separated out from the

pregnant Erick's is actually tiny that's what my

intuition says there's hardly any content in these millions of lines of

code and that combined with extremely

binding right so so if you're working in

an early binding system you're doing something but you're gonna have a hard

time doing all the experiments that you need and you're going to have a hard time taking the important things you've

learned when you've gotten this far and being able to put them back in here so

this leads to sort of the first and only system syndrome and then people feed

that system rather than throwing it away and I think it's vital given that we

don't understand how to do computer science or software engineering to make

everything like bound okay just a couple

okay so now the other thing that's

exciting and it's happening right here at Berkeley and some of you may be familiar with Dave Patterson's ramp

project here anybody so Dave is a very

cool guy and Chuck Thacker here is an

even cooler guy in a way because he was responsible for all of the hardware

architectures that we have at Xerox PARC and we just make these machines about

every 18 months he would make a new machine for us and we had a little

manufacturing facility so about 2000 of these alphas were actually made by us in

the 70s so we could hand them out to

everybody and chuck is in the middle of taking the next field programmable gate

array technology and making an Alto for 2007 right in Alto being defined as 2

cubed feet of the fastest Hardware on the planet and it gives you two things

it gives you the ability to do a lot of things without having to optimize or it

gives you the chance to actually do a program as it would be done 10 years in

the future by then you would do some optimization

so both of those things obtained at Xerox PARC and the this machine was

Italy more responsible I think for our success than most of our good ideas the

fact that we had that thing it just completely changed the dynamic of what

we were willing to try and trying in

both directions we got a lot of insights

both ways so here's the sermon here is

to that we have to be conscious that our

nervous system is internalizing what's constant in our environment as normal

and as explorative scientists and designers we cannot tolerate that so the

number one thing is just to be aware of whatever you think is normal is probably

bad for you but just getting sensitized

to it because it's the basic attitude in science common sense dominated for

200,000 years 400 years ago people

started finding ways around what was wrong with human common sense and the

same thing is in computing today is that the common sense of most of the people

who are coping with all of the stuff that's out there today is completely

blinding them to what the actual possibilities are I think I'll just and

that these are a couple of statistics about this system done dynamically so

I'm just asking it how many what sizes

all the code in the system of this thing that I've shown you it's about 3.5

megabytes and how many methods are there

and about 60,000 which is huge and but

the average number of bytes per method is only 59 so that's not bad

they're tiny little things 230,000 lines

of code in the system and the total number of objects in here because this is a dynamic system I can actually ask

it to count all the objects in the system including all the integers in it

right now that's always an interesting number so just just a little less than 5

million dynamic objects in the system

going on with the same architecture going all the way down to where there isn't an operating system but where what

an operating system does so this is kind of a sloppy example that you can do

something interesting and a few hundred thousand lines of code that covers large

parts of what we think of as personal computing and I think we can go a factor

of 10 smaller and invite any of you who

are interested to contact me and we have

money for internships and faculty consulting etc etc and it's going to

take a fair number of people who were

interested in solving these difficult problems to make the results of this

project interesting thank you very much

[Applause]

any questions it is preposterous let's

get past that yes well that's sure one

person with a factor of ten more IQ than I have absolutely well we have a

graduate student it has a factor of five more IQ than I have so yeah two we just

really need one more graduate student badly yes

well it's not exact

basically the although google is I've

been talking to Peter Norvig over there off and on trying to get them interested

we don't need funding from them thank goodness but I've been trying to get

them interested in some of this higher level stuff most of the stuff that

they're doing over there is is trying to

make things make the executable smaller but I'm not aware of the of trying for

really high levels of expression but

maybe maybe you know something I I don't

but I go over there every once and every once in a while every couple of months

or so and talk talking about what they're doing it's interesting that if

you look at the you know the web programming that the the actual

programming languages are except for the

fact that they lack depth are rather you know similar to any dynamic language the

scripting language is like like JavaScript in and Python but what what

is lacking in their terribly is the

environment though in the browser it's the do M which is just really a

god-awful mess it doesn't have any power and the JavaScript which you can get to

is not strong enough to allow you to to supply your own primitives to that like

you should be able to override stuff that's in the Dom like if you don't like

the way their canvas those you should be able to take JavaScript running 50 times

faster and write a better canvas in

there but you can't because they just aren't the scripting languages are

thought of as add-ons on to some thing that was originally written in C++ or

some other kind of thing so the so the the architecture is actually wall

and it reminds me of like experiments and radioactive chemistry you know where

there's that dangerous stuff behind the lead wall and you're over here with the

Waldos pouring things whereas if you

look at if you take something that isn't reference to our own work in the past

but you take something that we looked on with some admiration the list machine

that the MIT AI lab did and then there's

a list machine company that was an example of a higher level architecture done from the bottom up to the top or

top down to the bottom so the hardware was there to run the programming

language efficiently and so that every single part of that system could be

criticized by some programmer and you could override it was something of your

own I mean even Simula habit Simula had this idea of virtual procedures and even

though it was a an early bound language a virtual procedure if you marked some

procedure in a superclass virtual and you subclass that and supplied a

procedure with that name it would actually also be called up in the

superclass so you could have a mediocre

sort program up in the superclass you could write a better sort program and

the whole system would use that better sort program not just your subclass

right and that's done dynamically in the small talks but basically all of those

things are saying that in the end you

need to be able to have your cake and eat it too you have to have perfect

safety and one of the ways of doing that

is to notice how difficult it is to really crash the internet right it's

only with some computer program that the internet can't really be crashed you can

slow it down but the only crashes that

ever happen are some bad piece of code and somebody else's operating system

deciding to execute some perfectly innocent message they were sent

and I said you think about the Internet is a secure messaging environment that

does not have in it the the ability to

crash itself that was deliberate by those guys so you but then you have this

possibility once you have that then you can actually safely override anything

with something better so I don't want to

criticize the way programming is done on

the the net but I'm I wish they would do it a different way basically it's like a

pop culture trying to reinvent Bach and

it's just hard to do it that way because

Bach was one of the time you know you better off reading about Bach and Newton

rather than trying to recapitulate with what they did I think that's the big problem there

other yes because in the end the

programmers succumb to the temptation of using the library and using this and

using the the other thing and it wasn't supposed to happen with squeak you know

I actually got blood oaths from some of

the systems people who we worked on with that thing but in the end when the shit

hit the fan they just wouldn't get rid of it because it was too useful and

that's why I gave that little funny little demo because I haven't actually run a demo from a command-line interface

since like the early seventies but yeah

we decide and that's why EMP Marta stuff is important just for morale and we just

decided that even though it's going to be inconvenient psychologically it's

going to be critical for us to believe that we don't have to make a big

scaffolding and small talk and then promise to ourselves that we're going to get rid of it later now we're absolutely

gonna build a from the raw bits andean stuff generates

machine code and that's the machine code we're gonna live with we go on there and

of course we have to you know right away we have to make some sort of interactive

development environment for because we

absolutely don't want to be pushing text files into the thing but as soon as we

do that we've actually started down the pathway of making commitments too early

my interactive development environments are actually a fair amount of work and

you need them early so once you've done that all of a sudden you've set the tone

of what what one part of the architecture is going to be and then try and get any programmer to give up that

thing so a lot of the logistics on this thing are basically laying the plans

that I draw our plans that for the first

year 2007 we basically are going to have five or six parallel strands of just

doing extra way experiments because we

think we understand that how the top end works in this thing that's the thing we

understand the most of the single object model at the sort of in the end user space and how you get everything out of

it and the getting the bottom to a place

where we can get into that yellow ellipse without having made too many

commitments already at the top is basically the trick on this project we

have to get ourselves into a place where where we can do serious throwaway

experiments with very high level constructs that are actually going to take a fair amount of work to do so it's

kind of and basically when people join the project I explained the deal here

this is not this is not just a technical project it's actually dealing with

psychological difficulties that we all have as computer scientists and

designers and you know thank goodness and NSF gave us an incredible gift here

because this is the first funding I've gotten since really since 1990

that didn't have a lot of side conditions on it they just really did

fund this thing and I found another million a year for five years to make

this the size project can be and there's just nobody waiting for us to get done

on this thing right so it's it's like the like Xerox PARC you know except we

don't have Butler Lampson down the hall to tell us why we're doing it all wrong

and I miss him terribly because no

Butler had an interesting way of being right in an the most important way you

can be even when we went against him the fact that he was critical in the

particular way he was helped us thinking about why we really didn't want to do it

that way all right because he's just incredibly sharp so yeah so it's an

interesting it's an interesting deal of

trying to find it you in fact I've been

talking to the UCLA computer science department where I'm on the faculty

there but they have this paper mill for both graduate students and professors

that is just outrageous outrageous

nobody can do any real work because they have to write so many papers and when I

went to graduate school you basically only have to do your PhD thesis and it was supposed to be good but they didn't

waste anybody's effort with little things along along the way because they

just divert focus so yeah so we're

getting actually a lot of cooperation the computer science department is cooperating we have one of the

professor's roped in there's an int one of the interesting ideas in this system

is typing is big today but of course you

don't what you need typing for is something completely different in a

system like this and most of the typing results are not at all interesting but

there's a thing that's like a super type which is to think of an object or a

method

being able to characterize what that object or method means in its environment in order to actually run and

so one of the things that's proposed in there is the idea that is they're

worrying about typing on variables we should be worrying about typing meaning and in fact any object we really care

about we should write a stub environment that allows the object to run just in

that environment stand a lot right and you can think of that as being a

simulation of its type Naseem inif you

don't know what it is logically and when

you take that object and put it in a dynamic environment then it may find

some of the things that needs in the environment but these stubs also supplied the defaults now the may or may

not be there all right so this is a late binding idea for trying to guarantee

that the like the meaningful stuff that

you've said over here stays meaningful over here which is kind of what typing

is a it's about it's just that it's not that interesting to have it be an

integer or a string and a variable that

justice then doesn't cut it as far as what you're really trying to deal with

but that is a really interesting theoretical problem and but it's also an

interesting practical one of how can you make it easy for the program so you should be able to use something like

type inference to try and start building this external model you should be able

to present it in a user interface to help the programmer but maybe instead of

just maybe there's a function out there but maybe you just give it some typical values to start off with so now it

starts looking like an AI program no like one of Doug Lynette's automated

mathematician programs are you risk oh that goes around gathering evidence

before it tries to make a picture of the function all right so that's one of the

dozen things in there that we think really needs to be the another one is

set of support so AI has this idea of

truth maintenance but no system I know of actually has

truth maintenance of a method same idea

right some systems programmer changes

some cysts something over here and all of a sudden your method which was

running perfectly well is not running so well any more even though it passed all

the unit tests over here all right that just can't be allowed to do it but

nobody knows how to deal with that problem but it's clearly part of what software engineering has to be able to

to deal with that's akin to being able

being able to have some sensitivity to the signal levels that are actually

being sent you in an IC there's a lot of

interesting I think only stop we find it this project very interesting and we

didn't expect to get funded and we just actually got our first infusion of money

a few days ago from them so I think it's

real yes yeah well ago the golden but I

I've tried a lot of different ways of

explain but basically what if you could

the golden box actually has two models

that are intertwined in each other and

the simplest way of thinking about it is you can go back to that one half page

Lisp in itself so you can't run that

right because there's no there's no energy coming yet so it's just

meta-circular and so to run it you have to actually sneak in some computation

somewhere and one of the things you can do there is a really good exercise to do

it is to try and figure out how you could use something very much like what

McCarthy wrote but instead of

because describing an interpreter what the thing does is to admit machine code

and some of the early Lisp compilers back in the 60s did just that because

they realized oh yeah this thing this thing is chucking it along there and the

main difference between compilation and interpretation is that when I'm

compiling I have to generate code that

will make that result that I would expect to get from the interpreter so if

you do that really careful you end up with this thing that is essentially a

compiler for things that are of the power of Lisp that are about the size of

that half page of code but they actually generate machine code that's just a

revelation because it's right there and

you turn the crank on it and it starts making new versions of itself right

because it's written in itself so so the golden box is you know 30 years of

sophistication on top of that for

methods and then kind of orthogonal e it has a meta model for what objects mean

and by the way that paper that system is

called Albert in here and there is a

paper online that you can read that tries to explain just what this thing

does so the so what does that slide man

is that the golden box is something it will take a description of some

correspondence of some form and assign

meanings to it and then it will compile code from that that's what the golden

box does and the size of the golden box

itself is only a thousand lines of code and it's in exactly the same form as

what you put in there to get JavaScript the JavaScript is only like 150 lines of

code golden box has many other things and it uses the pattern matcher for also

doing register allocation and stuff like that it's pretty sophisticated

but still small so it's basically a thousand lines that generates a complete

kernel that can generate other things out of it as a very 60s kind of thing

the first in all talk at Xerox PARC was done very much like that small tech 72

but the difference between then and now

is that this thing has just had a lot

more thought put into it then we what we do how to do back then and this guy Ian

P Amara got his PhD at Manchester is a

bit of a genius I think so the golden

box is actually philosophically interesting also but thought it's not a

secret I mean it's just there are papers being written about it but has this

interesting thing that be because the first because it doesn't take much to

specify a language you can do it kind of in an afternoon and do a bunch of

experiments you can do a couple of languages every couple of days and try

out various kinds of schemes on the thing and that usually tells you something about what the golden box is

or is not doing for you but then you can go and modify those thousand lines and

shove it through the golden box you get a new golden box and so you just you

know at some point you don't take such a draconian measure on the thing but for

experiments it's wonderful because it's actual actually think about we have the

the golden box itself up on the wall we print it out and put it off on the wall

so we can just look at it that's you know it's whatever 50 into a thousand is

like 20 pages of code or so so it's a

kind of play table kind of thing it has a garbage collector in it you know it

has a bunch of different things in there that allow it to make a little

environment that's just a better one than we did for small talk Stephanie -

that's similar the biggest program the

alto could handle when it was first done was twenty pages

of small talk and and we were doing you

know complete windowing systems and modeless editors and everything else on

the thing in part because it could only hold 20 pages of code so we had to think

about what the meaning of that those 20

pages could actually be the part of it

is just assess it it's like $100 laptop I'm gonna try and get some four blow

with UCLA and Berkeley if I can get them away from Nicolas but all of the ones

right now are slated for the third world but it is just a great machine to give

to a graduate student because it's about a factor of five to ten slower than

today's laptops and yet it's a factor of

20 or 30 times faster than the Alpha was

right it's 100 bucks and you know any computer person should be able to do

something on this machine and so and it

just changes the scale of what you're

going to try and do and basically I think for good computer people it just

immediately gets them thinking higher level thoughts because they know

instinctively that this thing that's this big is really this big if they

could just figure out what it is mathematically thank you very much thank

you [Applause]