Alan Kay's IFERS address at the American Film Institute

From Viewpoints Intelligent Archive
Revision as of 23:45, 5 December 2017 by Ohshima (talk | contribs)
(diff) ← Older revision | Latest revision (diff) | Newer revision → (diff)
Jump to: navigation, search
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
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
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
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
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
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
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
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]