Alto System Project: Dan Ingalls demonstrates Smalltalk

today we're doing video demonstration of small talk a system running on the Xerox Alto so Dan could you maybe tell us what exactly was small talk okay well there's um there have been a whole bunch of different small talk implementations the first was called Smalltalk 72 and it was used for educational purposes it began with some ideas that Alan Kay had and he worked together with Al Goldberg and and we actually organized a number of classes at Xerox PARC to see what it would be like for kids to use this kind of a programming environment and a lot of the principles came from some of the work of Seymour pepper but we this specific language we had was the idea was to do everything as sending messages which was a revolutionary idea in those days and the Smalltalk 72 system was a very simple token interpreter and maybe we'll talk about that some other time but essentially the programs that were written all ran as separate tokens and whenever whenever a token was identified it got looked up and and then the subsequent actions depended on what was looked up there and with that model it was very flexible so it allowed people to define their own classes and how objects would respond to messages in in a very simple way and so that's how the early programs were written to how we taught kids but there were some problems involved with doing things that way which is that it ran very very slowly this these programs were programs that were parsing themselves as they ran which made them run you know 20 times slower than competing systems and another problem which was the real Achilles heel was that you couldn't actually tell what a program meant without sort of running it yourself because you'd see a token and and you didn't know how the rest of the sentence as it were parsed without going and and reading what the computer would have done and that that wasn't so bad because for the most part people wrote wrote programs that made sense but if you want to compile a program and make it run fast it the meaning has to be all unambiguous from the get-go and so Smalltalk 72 was not compiled able and so could never run really fast and and and that's some of the background for our talk today which is about Smalltalk 76 which was the first sort of modern small talk where the same kind of message patterns could be expressed in the program and but they could actually be compiled they were they were unambiguous so maybe that's one place to start is that is the syntax of Smalltalk 76 was unusual for programs at the time but basically there were three kinds of messages unary messages like string length and binary messages the kind of things you expect like arithmetic you know eight times B those are all the messages expressed with non alphanumeric characters and then key word messages and these are things like Oh set X set x and y so you've got two parameters there and in Smalltalk 76 the keywords have colons at the end of them and so this allowed multiple parameter calls to be expressed without needing a lot of parenthesis so that made it also nice and another thing I'll say just sort of in in the run-up to the work on small talk 76 was that in the context of this these programs were all running on the alto and the alto was an amazing machine for its time but it actually was very small so it had 64 16k excuse me 64 64 K 16-bit words of memory or 128 K and current parlance and half of that space was used up for the bitmap display so that made it an even smaller machine of 64 K and then to interpret the Smalltalk language it took about 32 K of code and so now we're down to about 30 K of space for the entire user's program and the small talk system that sort of supported it so so there wasn't an intermediate generation of small talk that never saw much use which was called Smalltalk 784 and it was very much like the small talk 72 language except that we built a virtual memory for it in that that memory was called use and it's written about in the byte magazine and the the important thing about it was that it it split up object pointers into essentially two parts one was sort of like the class of an object and the other was an index of of how many so we we allowed 512 classes and 128 instances of each of those and four things that you made lots and lots of like points or rectangles there might be several several so we call them pseudo classes that all were the same class but they allowed you to have more than 128 and then of course you've got also the problem of variable length objects and we split those into octave sizes so that's how that was handled this meant that at least in terms of addressing we could talk about something like sixty thousand objects in the alto we there was a small range used for integers just to be efficient the that then gave us a much larger address space than the than the physical Alto supported so what we had to do was to we could address the disk that covered the disks we used were about a megabyte and a half or two megabytes so it allows us to write programs that large but they had to be paged and organized into memory to do that with a conventional paging memory it wouldn't we would never have been able to do it in such a small space but by by using a hashed object table so you would take that object pointer look in a hash table and figure out the Associated location and memory of that particular object we could very compactly represent the working set and you'll see that when we're running sometimes it may shake a little bit and take a little while to get its working set established but then it ran very efficiently at that point so Smalltalk 76 is built on that and and the system itself is something like 150 K and and we build applications that were over by all that ran in this tiny sort of 30k of actual working space on the alto I want to talk a little bit about the sort of the semantics of Smalltalk 72 Smalltalk 72 was very simple but and it had classes and objects classes and instances in its semantic model but the way that classes were done classes themselves were not first class objects so the meta system wasn't as clean as it might be or as powerful and also the stack frames accumulated when one object called another called another those also were not first class objects and we learned a bit about that when we were doing small talk 74 and when we finally did small dark 76 we made sure that all of those sort of meta objects in the system were first class objects and we'll see some of that in in the examples here let's see I'm not sure do you want to ask another thing or two yeah could you talk a little bit about your particular role on on the project okay sure how you got to got to be on the project yep okay hmm okay so I originally came to Xerox PARC working with George white on speech recognition and my office was across the hall from that of alan kay and while i was interested in the work that I was doing with george white i kept being very much interested in the conversations that I heard Ellen having across the way so finally I walked across the hallway and said hey what are you doing and he talked to me about his interest in in doing a new language that would be easy for kids to use and we got started on it and I think Ted Caylor was also around at that time and Ellen Ellen had this plan for how to build a language in which all computation was done by sending messages which could be a much more general way of doing things and has lots of good properties associated with it if you build a system that way it can be much more modular as we know now you know it's the world of object-oriented programming essentially and and I was fascinated by this and just took to it and when when Alan sort of laid out the sketch of an interpreter for such a language I took it on as my responsibility to actually build one and the first one the first one I built was in basic of all things it was because I was having a child at home and wanted something that I could run at home and there was a basic time sharing available at home so the first Smalltalk interpreter actually ran in basic but we got the that allowed us to sort of debug the whole scheme and then at that time the Alto was being built at Xerox PARC and it was built to to run the same the same code set as the data general Nova many computers and so I got control of one of those and started porting the work that I had done into that and got small talk running in sort of emulation mode that was the beginning of Smalltalk 72 on the data general Nova and then when the first Altos were available we right away moved it over and had that running on the Altos and and the project evolved and we were as I said we did a number of classes with kids trying out Smalltalk 72 and then you know we were software geeks we wanted to do more and more and it seemed like this was actually a powerful system for doing things except it was too small and it was too slow and it didn't have a good meta system so we we worked away at those things and and there came there came a time I was wrestling with this notion of how can we how can we have something that's got as nice a message sending syntax as Smalltalk 72 but it's compiled able and and I I still remember there was a weekend I spent Pajaro dunes it was I think it was my birthday and and I came up with this way of doing a keyword syntax that would have that same feel but would be rigorously compiled able and together with that came similarly a design for an engine that could that could execute code compiled from that and I might I don't know it I don't know if this would be a good time to talk about that diagram so so I'd like to explain how the syntax of Smalltalk 76 can be compiled into compact structure as the architecture of the whole virtual machine then the dynamic structures needed to evaluate so what we're looking at here is a is a method in class rectangle which is the method that tests is a point within that rectangle and here's the source code for it it's contains a point and and the code says return the origin return the fact that the origin is less than the point given and the point is less than the corner and this less than operation is a graphical less than it means is to the above and to the left so this is the this is a small talk-- code that's being compiled and and so it is in a message dictionary in class rectangle so here's the class object its title is rectangle and it's part names these are the instance variables our corner and origin and it's got a pointer to its superclass which is in this case is class object from which it inherits other methods and it has appointed to the message dictionary and this is the dictionary that contains all of what's needed for the methods in the class so in this case the the name is contains with a colon the source code is what I just described contains point as the origin less than point and points less than corner and the compiled method now is a pointer down to this object and it's a compiled method and it has setup information in a header which has stuff like the number of arguments and things like that and also pointers to literals if there are any and then the actual byte codes for the virtual machine to execute these are like the instructions and and here it says corner point less than point origin less than and returned and just to say that corner in this particular case will be an instruction that is like you can see that corner is the first instance variable so this will be an instruction it's it'll be 8 bits and what it means is push on to the stack the the the first instance variable and this means push on to the stack the argument and this this means send the message less than so okay so it's it's not a procedure call it's a message send and so on and then and then here it do the same thing with this part and then this and operation is an operation between boolean x' and this last operation is a return so this operation here this end will have left a true or false on the stack and this will return it as the value ok so that's how all of this works and the dynamic structures then to make this happen there's when this method gets called it creates this object here which is we call it a context it's a it's a it's a real small talk object the that is essentially a stack frame as we know them conventionally and it has a pointer to the sender and a pointer to the current method obviously it needs that it's got a a PC a program counter which is a pointer into the current byte codes and then it has a temp frame and this is this is the place where the argument point will have been pushed and then it's got also the stack which is it's the computation stack and and here it's got a stack pointer it records the current position and it's got a class for the pointer for the method class and it's that's needed for if you're running an inherited method there will be a pointer to the class in which that method is found but it also needs to know the class that this one actually was in and then it's got a pointer to the current receiver which is self and here is the actual rectangle with its origin and its corner and those point in turn two points so that's the that's the whole architecture of Smalltalk 76 it's very simple and because of being simple it was possible to actually get most of this kernel operation to fit in micro code so that things would perform decently on the alto which was not a fast machine less than am it in many sense so the the tradition of all the Smalltalk systems had been that they are basically live coding so all the time you're working there the system is live and changeable you can of course change your programs but you can also change the system itself and everything that's that's sort of a part of the system running is accessible to change so here's some text on the alpha screen it's divided up into Windows this was a novel concept at the time we're all used to that now and wherever there is text you can you can make selections and you can bring up a menu and ask to do it that means to evaluate it and print the result you'll notice that the screen momentarily goes black that's because the it doesn't have to be done that way but we did it that way because the Alto ran somewhat faster about twice as fast when it was not displaying and that's because the Alto was this incredibly simple architecture in which actually putting the bits on the screen was a program that ran and so it competed with the rest of the processor so we've just evaluated three plus four and gotten seven that tests a huge amount of the system actually because it runs the whole compiler so that was the first thing that we always ran and then we would run this one here which is divide 355 as a floating-point number by 113 and in the result comes out very very close to pi and that was a way that we knew all the floating-point system ran and at that point it had tested about 90% of the system the I guess the one other sort of significant piece of system code in here was large integers so in order to run compactly Smalltalk 76 just had allowed for 4,000 small integers and then to do larger integers it made them up piece by piece from small integers so I'm going to print here 20 factorial which is a large number and so that there you can see the result so one of the things that's nice about this that is that although Smalltalk used small small integers we made sure that you could make large numbers with them because one of the first things that kids want to do who are working with numbers is make bigger ones and bigger ones and bigger ones of people so you can make them as big as you want in Smalltalk so so that's just sort of the simple things about getting started with with using the system wherever there's text you can select it and evaluate it and print the result the system itself it has this somewhat more sophisticated programming and interface this is a small talk code browser and it takes all of the parts of the system and breaks them down according to classes and the messages for each of those four instances of each of those classes and and there are a number of categories here including kernel classes things like classes object so I should say one of the things that we did in Smalltalk 76 that we had not done in the earlier small talks was to support inheritance this meant that you could have a class object and put methods in there that all objects would want to be able to support for instance how to print yourself so so you find code for that in class object and here's here's the code for classes and and code also for contexts contexts are essentially the same as as we know now as stack frames for a debugger and those were actually first class objects in Smalltalk 76 which meant that you could write the debugger in in regular Smalltalk code it didn't have to be an assembly code or anything special and that's the kind of thing that made it easy to do these kind of browsers let me take a simple example of some code let's look at numbers and look at something what's a good example here arithmetic so just to see how what code looks like in small talk here's a code called a method called max so if you want the maximum of two integers you would say a max B and a would be receiving the message max with the argument B and the way that the way to understand this code it says am i myself less than the argument if so returned the argument and then there's an implicit if not returned myself so that's how that code works what's what's notable about this is that this is in class number and all these other kinds of numbers floating point numbers integers large integers and so on fractions if you define them they all inherit this same method this allowed the system to be much smaller than a lot of other systems if you have a message oriented system then you can have that kind of inheritance because when this when this makes the test self am I myself less than the argument this less than operation is not it's not a procedure call it's a message send and so that message send would be meaningful for fractions for floating point numbers for integers and therefore this this exact same code can be inherited by those other classes so that that can make the system you know five times more compact in those kind of cases we can also take a look at how we managed to compile these this message send into actual byte codes let me here let me do this I'm going to print out what I'm selecting now says it's going to class number looking for the method whose name is Max and printing it as as bytes so there are there are the actual bike codes for this method and those include a couple of bytes of header information and about 10 bytes that correspond to these tokens so the first one says push a pointer to myself on the stack and then it'll say push a pointer to the argument on the stack and then send the message less than and so on and the way you would find out what these what these numbers actually are and how the thing works is you actually can go and look and see how the system works so we'll take a look in kernel classes we'll look at context and and here are a bunch of the operations that the virtual machine can do and let me go down here - this message called 'step so when you have a situation that where a computation is in progress each each cycle of the virtual machine involves taking the next step so it will it goes to look for the next bytecode the end which is the next instruction it looks at it looks at the method it's currently running advances the program counter PC plus one and then looks at that place to get the bytecode out and then it tests the bytecode and in this particular case it says is it less than octal 200 then it's a load instruction and and then and so on it goes through all the different ranges and these are the things that it will do for instance push a field to the instant instance onto the stack push a temporary onto the stack and so on so this method here is actually a complete simulation of this multi virtual machine which means that the debugger is capable of single stepping a program and and the interesting thing about this is that this is actually the first part of Smalltalk 76 that was ever written and it was actually written in the earlier version of small talk called Smalltalk 74 and I don't have that version to show you but when we were beginning to build the system we were able to put together little pieces of code and get more and more of it running in that way in the earlier host system and then we wrote the compiler that would compile this new language and got it to run and then eventually we wrote the machine code and micro code to make this all run live so I come back to you and sort of see what the next next thing you're curious about here so in addition to just these kind of simple arithmetic things that you could try out very easily just because the systems live like this little division that happens to produce a result that's very close to PI you could also do things that would that would do graphical effects on the screen so here's an expression that that sends the message new to class rectangle to create a new rectangle then sends the message from user to that rectangle which will ask me to indicate coordinates on the screen and then it sends this message comp which will reverse the bits on the screen exactly where I was so so I'll select that and do it and do this and so you can see it has reversed all the white and black there so being able to play around like this and just do stuff whatever you think of doing is really nice for invention because you play and so one of the things that that we wound up doing sort of by accident is by Korea is creating another rectangle that's kind of offset by this one and doing the same thing and what you see is that it actually this is a cheap way of putting a border around an area which is to complement it once and then and then translate it and complement it again so so the idea occurred to us to actually try that out one of the things that that we got back from some users of this system and others at Parc was that two non computer users it was scary to have this big black hole appear in the screen when you do a big selection so one of the things we wanted to try out was supposing we didn't do that but supposing we just drew a border around it so from what we learned here we thought maybe we could just change the way that selection worked and throughout the system and see how that felt so one of the things you can do in in this multi system is you can you can interrupt it in the process of doing a selection and you get this you get a debugger come up on the screen and you can you can then this just says that you stopped me in the middle of doing something in the paragraph editor which is useful for instance if if there was a problem but we can find out much more by reframing that and getting a sort of a fully capable debugger and this this uses the fact that stack frames and contexts all of that in Smalltalk 76 they all were actual objects so it was very easy to write a debugger that could go look at a suspended process in that minute in that manner so I've asked it to give me the full stack and here it's giving everything from out at the sort of at the user scheduler it's in a paned window which was a browse window and it was in a code pane doing in each time loop and then there it was checking for checking for the mouse button being down while it was doing selection so let's take a look at that so in this you can actually look at the source code that was operating at the time and here's some complicated code about how its you know checking all of that and let's see what that was calling that was calling this routine called select a point and it's going through and finding finding where the character is and now it calls this routine which is compliment from hair 1 to hair - it talks about hair being the the sort of the hair line between characters when you're selecting and here's here's actually a comment about this exactly what we were talking about which is the sort of the first partial selection on a line and then the complete lines in the middle and then there's a partial selection on the last line and you see there it's it goes through this code it's a little bit hard to see because I've got a small window on it but it's calling it's telling itself to do comp rect in on these various areas see the comp rekt the first partial line here's the block in the middle and the last block so if we could change the compact routine that would be useful and might tell us what we want so let me let me get another browser here and what what object is being sent these messages um so in this case it's a it's it's a paragraph editor yeah did we figure that out last time yeah which is a subclass of text image yeah so let's go find that but I think we found that code in text image didn't we Oh actually it's in the form path okay category yeah yeah there's text image and we'll look in selection yeah so here's the here's the routine comp rack that's being called at all the places in doing in doing selection we've got a complete blank there how can that be let me see if I have no understanding about this just a second it's very strange yeah it appears that it's not findable we'll see what it's doing so I just decompiled it and let me see if that has helped bring it to life at all for some reasons the source code didn't get preserved so we find comprar and this is a routine for which there happens to be no source code that may be but hopefully the changes we made but don't despair let's just try this small talk 76 can decompile its code so here you can see what it's doing is it's it's taking the incoming rectangle and let's just let's pretty it up a little and tell it to do that again and again it's making up a temporary rectangle which is the incoming rectangle intersected with the frame and the window and then it's telling it to comp which will turn it black and white and what we'd like to do is to take this let's do let's make a copy of that there and in addition to doing that rectangle let's do T to copy and translate it by and is it that character yeah what do you know that that makes a point and yeah so I've got it there so this will this will take the that same rectangle copy it and translate it offset it by one pixel in each direction and then compliment that okay so let's compile that and the last time we did this we accidentally use the wrong character yeah so when you're doing work on this on the system that you're actually using you have to either be very careful or be ready to to bail out in re now see right away I've changed that part of the system and it's now actually working and we can go back to the place that we were looking at well we can actually go back in let's go back to the debugger you can actually proceed from that point in the debugger and it will be finishing the selection that it was doing here sorry I get the wrong browser there this is the one that we were originally looking at the big selection in and you can see it's that way so that's nice and we could actually um now when we look at that it's yes it's better that it's not a big black area but it's kind of faint so it's a little bit hard to see the selection so we could having made that change you know we might want to just make it go by two pixels and compile that so it's nice here is you know we're in this in the system running it's easy to make changes just on the fly so there's no need to you know redo the whole system so there's the there's the selection now looking looking like a reasonable piece of user interface to try this at so okay let's we can find the the scroll by do you want to do that in two steps so first enable the live the live scrolling and then make the floating point change in a separate step yeah let me show ya let's go back to that was not simple let's see if we can so that was in scroll bar right I had it written down and it's in each slide it was in yeah okay and what did we have to change oh we had we had our cheat sheet sheet beside us at the time right Oh yeah what do you know okay we took the trouble to comment that good job okay so the the the system as we used it on the Altos was not super fast and you've noticed that already so it the actual time it takes to display to move text around is significant and so we did not try to do live updating that so this would take you to a certain part in the text but we didn't but we didn't display it until you let go of the mouse this made it a little bit faster for us to work with a slow computer as the computers got faster we could actually track that and so by the time that that I gave the demo to Steve Jobs we were running on a faster machine and it tracked well and I can show you so so this code was at that time doing live updating and I'll compile it that way so that was on a dorado yeah okay so now now when I when I drag this down you can see it's it's a little bit it's very slow to follow but at least it does follow and and when Steve saw that he saw this happening quickly but in this jerky line-by-line manner and he said you know I can't you make that just scroll smoothly and it took me a while to find the part of the system to change and I actually did that while they went away to lunch and but when when they came back I had a simple change for it and let's go to I believe that I forgotten again whether it's in its paragraph public messages scroll up so all of these routines came through the scroll up method and here it would scroll by the number of lines or by the by the amount of pixels divided by the line height but because these were fixed this was an integer then it simply did an integer result which truncated to the nearest line but it was easy to change once we had that tracking by changing that to a floating-point number you know make sure that that's what that says yeah let me find a big method Wow okay so now now as I drag this you can see it's doing its smooth scrolling it's it's jerky because it's slow but when Steve saw this it was just totally smooth so that was effective and I think I've showed that to you in a faster version of this system you so could you start by giving us a little bit of context of this version of small talk that you're going to show us okay yeah this is small talk 78 as we called it it's essentially a copy of small talk 76 that was ported to the note-taker which was a research project at Xerox PARC where we where we did a complete Smalltalk interpreter that ran on the 8086 microprocessor so this is the first microprocessor implementation a couple of things are different about it but mostly it's all the same code the the major change that was made in order to do this was that we had a pile of Alto nova code that was the virtual machine for small talk that had to be ported to the 8086 and and lots of it was involved in doing character display in doing scrolling operations and all sorts of other bit bit manipulation operations that could all be done with bit blit by that time we had developed a bit blit primitive so we implemented that on the 8086 and it allowed us to go from an interpreter size of about 32 K down to about 16 K leaving leaving most of the hard work to be done by that little bit blit kernel which we did port to the to the 8086 and that then actually became the basis for the future versions of small talk but what I'm going to show you here is a resurrection of the small talk 78 interpreter in JavaScript running in the lively kernel and and one of the things that's notable about it is that it's extraordinarily faster than the original was so you've seen the the time it takes to move from one browser window to another in regular small talk 76 on the alto here I click and it's as though the bits you know as though the bits were saved but these are being completely repainted and scrolling is is essentially instant in all these cases you know and the other thing is that one of the neat things about having a system which is all done in terms of objects unto themselves is that we did a completely different memory system so this uses a garbage collected memory system in JavaScript and and the system can actually be much larger than the original one it doesn't have any of the same limitations but other than that it's a faithful implementation of Smalltalk 76 and it's a wonderful one to browse around in just because everything's so responsive and so the next thing that we're going to see is this change that has been famously reported the work was part of the demos that you guys at Parc did for Apple and Steve Jobs all right can you talk a little bit more about how how that demo first came to be sure well yeah so Steve came with a team to see the Smalltalk system and what we showed him then was Smalltalk 76 but not running on the alto but running on a faster processor I'm pretty sure it was the Dorado so it had a lot of this same zippy responsiveness and during the time that I was giving the demo to Steve I made the change of how text selection could be changed from block out to outlining you know while he was watching and then he came back saying couldn't you do it I noticed that the scrolling goes junk junk junk junk by lines couldn't she do it in a smooth manner and that wasn't something that I could simply do while he was watching but he and Adele and a couple of other people went off to lunch and I I did it while they were away at lunch so when they came back from lunch I was able to show it to them and I'll show you I can show that in this system because you know I've taken the time to you know I know where to make the appropriate change we've got scrolling is done in a number of places here in in the text image class and and what happens is that the scrollbar sends a message called scroll up to the to the text image and it's it's in terms of the number of pixels and then that gets divided by line height and it goes to this message scroll by which is made to scroll by a certain number of lines but it turns out it's very simple if I simply convert that that incoming number of pixels to a floating-point number first then this division will be in floating-point and so the scroll by message will be let's see I think I should show you something scrolling just because you haven't seen it in this system without this change so there it is it's responsive because it's a you know this is the fast implementation but it's chunky so now if we do this as a as a floating-point computation it'll be it it will be sending a floating-point number there so I'll say let me compile that something else you'll notice here is that compiling happens in the twinkling of an eye as it should of course and so now if we go back here you see it's completely smooth and it's it's fortuitous that this is the scroll by code and all of this code simply works just by converting it to floating-point it's it was written in a nice general way so that didn't things could have worked out that it was not happy with floating-point numbers there but it seems to be so that's that's how the change looked to Steve and he was duly impressed so I might say a little bit about more about where this implementation went on having having made the conversion to do all the graphics using bit blit the kernel was much smaller and that then enabled peter deutsch to do a new virtual machine for the dorado at xerox that used that and then he also did another implementation for the 68000 which which continued on in that tradition it also became the basis of the that that gave us a fast development environment for doing serious system work and from that came these the whole conversion to Smalltalk ad and the release of Smalltalk ad as an see standard software product and then that that continued on for quite a while and it was essentially that same system that we picked up at Apple again and built the squeak system using that and squeak was the first squeak was the first and I think it's the only small talk that actually has its own virtual machine written in small talk which made it which made it really easy to maintain and develop the virtual machine the most I think the most impactful aspect of that was that when we put it out in I think 1996 we put it out as a package for the Macintosh but it had all of its source code with it and all of its ability to simulate its own virtual machine and I think it was within within one week Ian Pugh Marta had ported it to Unix and then a week or two later andreas Rob had done it for Windows so this ability to have a system that self-describing and self-supporting makes it incredibly portable and we also had done a lot of work there to make the it was a a bitmap display model that was all self defined so it didn't matter whether it was on UNIX or the max or Windows everything ran bit identically and and we continued to do other work on sqweek that's you know about but you could be partway through a debugging SEC session on Windows and save that and pick it up somewhere else on a Mac and continue the debugging was really nice and portable and compatible so talk about yeah talk about bit foot okay explain explain that to the audience yeah well so I think I mentioned that the the early small talk virtual machines used a lot of code to support character display and line drawing and and text scrolling and all of that and all of those could be done with a single primitive and we called it bit blit and on the alto we wrote that in micro code and then we've written it that's been an important part of the graphics kernel of all the small talk systems since then and what's nice about it is that all of the graphics has implemented are actually you can work on them they're just like other user programs you can change them and edit them and see how they work so here's in this example of in this version of small talk that we that ran on the note-taker we've got here a a turtle is a turtle geometry spiral and you can see the code says create a new turtle in this frame set its color and its width and it's inking and then for for I to 100 tell it to go this distance and turn 89 degrees so what does it so what this go primitive will draw a line how does that happen well let's look at the code for go and it says go to the current direction as radians plus plus the current location so that will make it go in a certain direction and this uses the go-to method and that's here and what does that do well it it sets its location puts the pen down and then does draw from old location to new location so let's look at draw from and in earlier small talks this would have been a primitive with a lot of assembly code for it but here it's actually more more user editable code that that tests for the the pen what kind of a pen it is and then and then sets up a bunch of increments and here is the actual brush and hem line drawing algorithm all in editable source code I'm not going to go and make a change in it but we can see it at work by running this little example okay so you can see that you get really useable line drawing speed all in user editable code and without without needing a lot of assembly code for that I mean this is probably just a couple of hundred bytes of Smalltalk code could you talk a little bit about how important the ability to code in micro code was for blip bit blit and other aspects of small talk sure Rd Alto yep so the the ability to write micro code on the alto really made it a much more powerful machine than other similar machines at the time the microcode actually ran at five times the speed of the memory cycle so we're we're a regular machine instruction on in Nova code might have taken a microsecond or two microseconds the hell how actually ran micro instructions at 200 nanoseconds which made it for that time a very fast machine and it's interesting the effect it had this was a an extremely scarce resource so most of the just the basic system of the Alto used that most of the available microcode so there were only about a hundred instructions available to do other work in so as a programmer that you were strongly motivated to find some small key piece of code that you could fit into micro code and then that part of your sister would run five times faster essentially and so so with the early small talk with a small talk 76 virtual machine that was the first one where we used microcode this allowed us to put the the kernel part of the bytecode interpreter into there so the part that would step the program counter pick up the next byte code instruction and doesn't look it up in the method table for the appropriate class that happened in micro code and that allowed Smalltalk 76 to be a performant and usable system for that time it actually allowed us to develop the the source code browsers that really shifted the whole way of people doing integrated development environments in the industry and then and then the next step we did was to this change in the graphics model by implementing bit blit in micro code it allowed us to do character character display line drawing and in text scrolling operations and and what we could do with characters was much more much more flexible than what had been there in the Alto we could do synthetic bold italic and and actually stylized fonts that you see and and all the kinds of handy things in the graphics interface it's the it was responsible for the birth of pop-up menus because it was easy to take a rectangle of the screen and save it somewhere and put another image there and then pop it back up right there's a story of you yet doing a demo of that at a dealer okay and and somebody said did I just see what I just did I think I just saw you tell that story sure yeah so this was we we gave if they were these weekly meeting meetings called dealer that were held by the computer science which is sort of a competing lab tars there and we always attended because we really liked the people in that lab and and we were the sort of small talk crazies but often it turned out that somebody would have an idea and we'd go back and get it running in an hour and small talk maybe not as fast but we tried out a lot of things and it was a nice creative back-and-forth anyway we we had gotten a little I had gotten bit blit working in Smalltalk 74 and and we presented it at one of these dealer meetings and and one of the things I showed was a pop up menu and and it's funny when I when I when I brought up the menu and did I think it was one of these things where where I said do it to execute something um Peter Deutsch turned around and he said wait a minute did you just do what I think you did and yeah and so that was the first time that we showed pop-up menus and and it was it was also a great example of tech technology transfer because the I think it was the very next day smokey Wallace from the from the product division showed up in my office and said I just heard about bit blit and I want to know all about it and then and they then went on to be the person to do that that work for the for that one of the Xerox product machines the the star or a different one so it was the precursor yeah yeah one of the D machines yeah you all right um well I thought one of the things we could look at here is the some of the work that was done with turtle geometry this goes on from similar puppets work pepper it's work which we did in Smalltalk 72 but we preserved that functionality in Smalltalk 76 and we've got a few examples of that here and a lot of these just draw scratches on the screen so here's because we were just doing experiments and we would clear the screen when we want to do to do a pretty version of this but this basically says create a turtle initialize it and then do a dragon curve of order eight well actually let me do I'll kill it to erase first so that the screen is white so you can see it let me yeah it's a good time to okay so let me just say this is creating a new turtle initializing it erasing the screen and then doing a dragon curve of order eight and the dragon curve is a flint shape it's it's got a really simple recursive definition you can see it here may refresh that now it's essentially the shape you get if you take a piece of paper and if you fold it to a right angle and then you fold that to a right angle you can see that's so that's now a dragon curve of order 2 you keep folding and you get that shape we've got a cancel that here are two here a couple of spirals which are done let me just make sure that we get and this will just draw them on the screen one of overlapping one way and the other overlapping the other and and all it's doing here is is drawing a spiral with not quite a right angle at the corners you'll see it as it goes so that's turning 89 degrees on each quarter and it has this nice recession and then that's drawing another one over it turning 91 degrees and let me go over here here's here's a mandala being done this is where you take a circle and do a bunch of points around it this is with 30 points around it and in a diameter 400 you connect every point and you've seen these it's something that a lot of people like to do at art fairs by putting a bunch of nails and doing different colored threads we did colored versions of this so the alto did not display color but we did have the ability to write the images onto a on to a printer description file and then that could be printed on our laser printers and we did have we did have a couple of colored laser printers so it made a really pretty picture but even in black and white it's kind of nice and let's see we've got the Hilbert's curve this I'm going to do a quick version of this we'll just do three a hilbert curve is essentially where you take a line segment and recursively break it into a sort of a cup shape see there's the cupcake shape and here the various ones there that's another space-filling curve and these are it's a fun to turn into tiles if you can fill it we didn't do filling operations on the alto screen but it you can actually make ceramic tiles out of it and cover your floor with pretty patterns okay that's most of what we have in the turtle except when Hanson and I were going through this we found we found a method that I had completely forgotten about and that's this one that says this will show a character string in a font driven by the turtle so let's see what we've got here turtle in it yeah so we'll try this one out this will probably just do it on the screen so it's saying to create a turtle initialize it with a pen width of three turned to 45 degrees and show the texturing hello there there it goes and what it's actually doing there's a primitive that Ted Caylor wrote which goes in and finds the font in memory and picks out the bits and then tells the turtle to do a dot which seems like a really hard way to do things but it allowed us to use the angles of the turtle and the scaling of it to make things bigger in different angles so we had a lot of fun with that let's have the screen clear when we start this actually I want it really clear okay here's a simple spiral routine which just tells the the turtle to repeatedly go a certain distance and turn a certain angle and this is turning just 89 degrees a little bit less than a right angle so instead of doing a square spiral it does one that precesses and let me clear the screen before we do this turtle into the erase so it's going to do one spiral and then it's going to go back to home back to the center and do another spiral rotating the opposite way you can see it's processes in that direction because of only turning 89 degrees and then it turns this second one uses 91 degrees so it processes the other way then they overlapped in this pretty fashion okay I think that covers the turtle geometry stuff that we were working with good quick question about the turtle geometry stuff is it the case that when you know we've talked before about small talk and the motivation for you know children to interact with and use the computer as a tool was the turtle graphics kind of the most prominent example prior to the small talk work about four kind of children using computers yeah so this was a real I think a breakthrough that Seymour Papert made which was to teach kids about geometry from a local frame of reference and you could explain it to them so easily by saying um they would take a command like go tin and so they'd take ten steps and then turn 90 and they'd turn 90 degrees so they could see that themselves physically so then programs built that way made sense to them and they could sort of answer Morpheus to understand what was happening and we just did an implementation in small talk and in the early small talks the syntax was so simple it was really easy for kids you know in you know in a one line program you could do something really fun and that got them motivated yeah so that's the something that Smalltalk added to that in addition to maybe well a different a more object-oriented sin text and logo had was that because of our system being object-oriented it was easy for us to have multiple turtles on the screen at once but coming back to what you said about is that the predominant way the kids worked with graphics in the early history of our small talk yes it was so when they wanted to draw a box they do the turtle routine for doing later on when we got bit blit working and could easily work with bit back graphics then our whole world started changing mortis and kind of image type processing yeah and I could show you the I found this thing that's a bit blit example that the Smalltalk 76 system here doesn't have much about bit blit because as we sort of got it run running and stabili people were working on it more in the area of programming and in development system kind of work and the bit blit work that I did was in the Smalltalk 78 fork which then came back to become small talk 80 but I think I can show you this let's see I need to do and things were sort of put in oh I see what's happening cancel this the system was just being changed all the time and various things were being tried out and things got put in different places so it may not make sense this class rectangle should be a graphic primitive but it's in this category called form path image and the rectangle class has has all sorts of stuff that's convenient just sort of for accessing to its parts you know what is its corner so this would return you the actual point there what are its corners then it creates a vector of four and then goes through and reads the various corners into an array and passes that back the thing that I found let's see yeah this routine rotate this is an interesting procedure so we had no way of rotating things on in a bitmap except laborious ly you could read across there and write them with a turtle but that would take forever or write them pixel by pixel but this is a recursive scheme that says well if you want to rotate a rectangle by 90 degrees you begin by taking splitting it into quadrants and moving each quadrant over to the next quadrant and then you do the same thing for each of those within it and and within it and within it and if you figure it out you'll see that it will rotate it it will rotate the actual bitmap so this is going to take a piece of the screen from 0 to 128 up there and you'll see it also creates the masks on the screen because we were just looking for bits that we could use but you'll see kind of how this works these are the masks you can see it's beginning to move them around and that's the final mask and there's the final rotated image I might be able to do that for a larger picture let's do this that would include more of this so it would make more sense to 56 and let me I'm gonna clear this screen here oops try that out so this is it looks like garbage here that's being formed but in the last instance every little thing gets fixed up the screen size is less than 512 so we've got stuff from the bottom that's I guess it works better at the original size that's probably why it was written that way I think he wrote about this in one of the articles in the small talk ad yeah I with small talk 80 yeah in the byte magazine they said I've got a whole article on bit blit and it shows this is one of the examples and I think I've violated some copyright some by rotating a picture of Mickey Mouse all right okay so next is the bitmap graphics yeah okay so let's take a look at that so in addition to windows on the screen we have these little things which we thought about is doors but at this point in the evolution of Smalltalk 76 we we came to want to have separate worlds for working on different projects and so what this does when I enter this thing that says demos it gives me a new copy of the screen a new copy of the scheduler with different windows on it and and so we can just go in there to do that what's nice about it in addition to a fresh screen to work with it also small talk 76 recorded all the changes you did and there was a change set associated with each of these worlds we call them projects so that if you worked on one project you could say to write out the changes for just that work so it was really like having separate separate worlds to work with so I think what we want to do here is you want to use the the default size yeah what I want to do is I want to get the image that we had yeah I think that's this one so that's there we go we had we got Alan to draw us a picture for small talk 76 and and he drew this one and and it's this just it's the only image that's sort of sitting in the system that it's he's easy to pick up and work with but the this was something a drawing program that anticipated macpaint by quite a few years I guess this was done right about 1976 and so this here we have a menu of tools that you can use these these are ways of programming the tools so you can set the color of paint you want the scale of gritting you want the the combination rule whether you want to store it or the bits how how big a pin you want to use and then these are tools down the side that that essentially have those features all built into them so this particular tool is saying I want a fine width and I want to use it in gray let's actually make it be black here and so that will let you and we've got on stamps that's so this is left over from something we did before so it should be just drawing here and it's got gridding turned on we'll turn that off okay and let's go to a slightly heavier line width so now it's just letting me scribble on the screen and and I could come to a different tool like this one and it's drawing in gray and and let's see and it's using specifically Orange so you'll see that the the gray will will go underneath that line there if you can see that whereas if we had done it in storing it would wait a minute yes storing is here then then when I paint with it it'll obliterate everything including the black lines we also have the ability to to blow things up this is a sort of a fat bits editor so if I wanted to edit that finger on the loot there whoops you can see that's a little bit blit hack being used to blow up that region of the screen I didn't do a very good job of getting the finger but you can see that if I wanted to turn the finger all black at the end I could do that and it's happening in real time up there in that image so we certainly in all this the work that we did we tried to keep things as live as possible so that's now we've now changed the image there see what other features to show I don't know teeth there any other features that you think I missed a show yesterday you showed the stamps and you showed I guess the different great options like yeah let's see if we can do so stamps so that I've just clicked on set let me do it here and so I'm selecting the area around that part of the pin as a thing which now should load that image into this little thing up here that says stamp and so now if I go let's do let's just see what it does and use so that's just painting like that but let's turn the gridding up to eight so now it's it's laying and laying down that image so you could make a I'm not going to take the time to do it make a little picture of a man and then you put men all over the screen or whatever okay yeah I think that I think that's it probably and there's there's no way to reverse or undo any of the changes we've made um this editor I don't think really had an undo feature but I think that you know it's been long long enough ago that I don't recall so it has actually changed that but I think that I don't honestly know about that what we can do is to open another copy let me so supposing I close this and reopen it we'll see if it changed it but we had a way of doing of does it say yeah so it has this file out operation so that would write a copy of it on the disk which you could then read in to to work on later and this print bits that would go to one of our printers and print the image and I don't see an undo so that's yeah okay anything else you think we should cover nerds - there - these I think that's it yeah I had a question about the image yeah Allen Kay's drawing but just about the symbolism of it you know it does look like a kind of a children's illustration so yeah I get that part but is there you know there's a pen and then it looks like there's a pen and a pencil in his quiver okay yeah and is there any anything else you can tell us about the symbolism of the elf was this part of the I think it was just a fanciful thought he okay yeah maybe a Tolkien craze of the middle 1970s yeah I think that's it's probably as related to that and in music was always a part of our enthusiasm so I think that this is sort of kind of all the tools of the Arts in the hand of the of the child a good way of thinking about it is there any significance than the mushroom I don't know no idea about that I think it just sort of created a fanciful scene we knew it yeah we know we're in a different world from that okay yeah I wish it's unfortunate I'm not a better artist to play with this but people did people did a bunch of neat pictures Bob flagel did especially a bunch when he got playing around with small talk okay so let's get back to I'm gonna close this just to save space and actually while we're at it we can find out if we've got a preserved variation of that and we'll just go to here yeah okay so it we have affected the one that's that's inside the image will go back up here so damn did ya was that we were just exiting the demo world and our demo project and coming back to to the / project okay yeah I maybe yeah sorry I should have explained that want me to do that yeah so you you have essentially these sub sub we're back so you may recall this is this was a sub project called demos that we came into and and all the projects essentially exist in a tree you could have a bunch of them and then when you want to go back to the overview you'd use this command and it was very simple it simply swapped the swap the change sets and swapped the the schedule this the array of windows on the screen and then it didn't even bother to repaint them so yeah you have to go and enter them to repaint them but you you so one of the things I mentioned was a the having the ability in squeak to do to work on the primitive behavior in a high level easy to debug source language one of the powers of that was that it was really easy to port also I I figured out how to do how we could do bleeding and doing rotations and scaling as a part of that same code which I never would have tackled that if it had to be some sort of C code or something like that but in Smalltalk I just played around with it and actually got most of this working when we were at an off-site meeting we did most of our good work at Poe side meetings anyway so in squeek we we did the implementation of bit blit for color and not just for color but for all the different color depths and all the different byte orderings for all the different machines so that it would continue to be really compatible from from one system to another and one of my favorite tests of that is this what we call this the the squeak squeak mandala and that's let me just execute this here so what this is showing basically it's it's when I move my mouse from left to right it's change it's rotating if there's a rotated copy lemon yeah if you look this you'll see that's a copy of the screen rotated but there's also been a change in the color map and as like as I come closer in here I'm coming closer to scale a scale of 1 and as I move the cursor let me yeah as I move the cursor left and right there's a rotation involved also so here if I go to the left it's a rotation to the left and here to the rotation to the right and then as I get closer and closer to the center you can see it gives you more and more copies because you're closer to a unity scaling and you can see this is all pretty performant and we were able to do that because although it was written as general small talk code we had a translation from small talk to see for the production interpreter so and this is it's especially fun when you get down to when you get down near unity scale you get all of these neat patterns and when you actually get down to unity scale you can see it's sort of it sort of takes a while to settle and then if you go beyond unity scale it gets truly crazy and we used to we also could synthesize music so we spent a lot of time just enjoying the diagrams and the music so so this is a pretty good test of what you could do with just a single operation like bit blit and you did this when you were at Apple it was at Apple Hill yeah we had a yearly off-site at Apple Hill where Alan collected people from from education and from technology and we had some great meetings there talking about you know the wonderful things that you could do with technology and education so this is after after you left at Xerox yes okay yep so approximately 80 80s when was it later than that it began that I think in the mid eighties you know I'm the wrong person to ask about some dates back then right yeah but you mentioned this sort of this the C implementation of small talk and that was done so okay so that was free so one of the when we did squeak we got it running we essentially took the old the Apple Smalltalk interpreter and and wrote and used it to implement the simulated version of small talk that was in the blue books that were published and that became a self-supporting system and and but the the next step in that was that John Maloney wrote H we we wrote it in a style that that did not do actual message sending he used our syntax but but it was it was something that could be translated to see so he wrote this translator to see we were getting squeak built all using running it in simulation mode and it just barely ran fast enough to be productive but but you know one day we got to see translator working well enough that it produced a file of C that was equivalent to the interpreter that we had been using that was all debuggable and at that point it became a a you know product competitive version of small talk so we never we never had to work and C we could do all of our work in small talk and it was sort of like there was this button you could push and and out would come a C program that would be a good efficient interpreter and that has continued pretty much to this day and people have done some serious other especially Elliott Miranda has done some amazingly performant interpreter designs that we're all of the work has has been in high levels source code so should we move on yeah let's do that fun stuff earlier you mentioned the importance of the integrated development environment and the browser and the debugger could you talk a little bit about about that yeah well so the development work that we did we just kept doing the next thing that we wanted to do and and we had we had Windows working and menus and and it was really yeah it was Larry Tesler work that he he came up or at least he was the first person in our group who did this notion of Windows with separate panes we had we had a code development system that was not browser oriented you you would actually see all the code of a given classes a long sort of galley and he came up with this paint browser notion and we at that time had the software to support it well and we as you saw with the debugger as well that was a good case for you because you could see both the code for for the class and the method you were running and the state of the temporary variables and instance variables all in one compact way so we used that internally and we would give demos on in the outside world and it's I think just about everybody who saw those realize that that's how they wanted to be working as well and it just it's a great example of tech transfer from from just seeing a demo to knowing that that's uh you know that's the natural way to work and can you talk a little bit about the creation of Windows themselves overlapping windows so we had Windows from pretty much the the very first in Smalltalk 72 I guess the very first implementation of you know when we first got it running it was sort of a what you call a repla window a window you could type text into and and have it executed and a separate display up above but Alan was working on that and he worked with it with Diana Mary to get that that bottom repla window replicated so that you could have several windows on the screen and and and then that got picked up and you know we just kept doing more and more with that with the kids so much we didn't do that because most of what we did with the kids were were graphic graphic applications but but Larry certainly picked it up and did a lot with the Gypsy text editor and and other text editors you so we were very lucky that several several small talk implementations that ran on the alto have been preserved although they're not especially easy to work with they're the ones that that I've have access to are preserved as essentially what you might call core dumps memory dumps of just the bits that were in the alto memory when it got saved so it's it's just a bunch of data and and Nova instructions but it occurred to me it ought to be possible to resurrect that if I simply wrote which I could figure out the format that the alto stored that and that was a known format his so-called SWAT format that we're all of memory could be out loaded that way and I did know that the that the alto used the Nova data general Nova code instruction format so I looked that up and started pawing around to find out where things were and and I wrote in and the lively kernel which is a live coding JavaScript development environment I started to write an interpreter for for Nova code and this is the point that I got to where this is a disassembly of Nova code instructions in the alto memory and down below here the contents of the accumulators in the simulated Alto I simulated Nova and so when I say restart you can see let's see where is it step let's go up just a little bit yeah so the place where it is when I say restart the place where it's currently started is right following this location called out load because that's the that's the last thing that executed that caused the memory to be stored on to disk okay so it makes sense that when it's loaded back in that's where it'll be and so here now you can step through the the actual machine instructions that way and you know it's doing all the jumps and tallying things with the yeah with the accumulators and then you can go into full run mode and now it just is showing how it's simulating but I can now go and look at what's happening on the screen by saying show the screen and then it goes to full speed emulation okay and so now this is that small talk version starting up and it has printed welcome to small talk of May thirtieth whatever year this was is probably nineteen seventy three or four and and it's this is the alto prompt meaning it's waiting for you to type something in and and I should be able to type in an expression three plus four and it prints it we always test it also with 350 5.0 over 113 which prints something very close to PI and that tested out called the floating point operations so by this time almost everything in the interpreter had been tested so then you could you could type other things in here such as for I to 400 do and smiley I'm smiley with the name of our turtle for that for the threat turtle geometry work smiley go I and turn not ninety degrees but a little bit less 89 there we go it's really pretty impressive what JavaScript can do in a browser with a level of emulation to emulate the Nova code to emulate this language so this is actually a version of small stock 72 that we're seeing yes yeah yep and this is one of those images that we can that we can find and work with are there any animations that we can show in this that the one that I was trying to pull out is when I first so when I first did small dark 76 Allen was disappointed because he felt like it kind of left the kids behind both because it had a somewhat more complicated syntax but also because we didn't have the animation system that we had in Smalltalk 72 and I said that's no problem you've got bit blit we can do an animation and so I had this really simple demo which ran three things around the screen one was a shape another was a doughnut and it used the bit blit masking shape so that if and all of these would then bounce off the screen so when the donut came in front of the other one you could see it through the hole but not there so that was demonstrating being able to do that and the last thing it had was a little a little square window and in that square window was displayed someplace on the screen so you'd see like a piece of a browser and it's bouncing around here but you could move that over here and when you got to where it was overlaid itself when they crossed you'd see this endless tunnel of repeated trip so they're really fun not fun demo but I could not I could not find that here and so I just last night got the the list of all the file names that are in all 121 disks but I haven't had a chance to go through that and it would right now we don't have an ability to file things to get things under this dis to file in but if I can if I can recover that and get it to work we can have a little Salus here is or any of is any of the work for obviously not the music output but the music composition stop available to show this image not really because that work was done in the earlier small talk and that was one of the things that sort of got left behind that we then picked up in spades when we got squeak running so that we're actually doing the doing the synthesis and and we had our own LexCorp MIDI scored display and stuff but no that was left behind for a while and part of the reason was that small talk 76 required most of the microcode space that we had available and in the the microcode was also being used to do the old animation system and the old music system so they couldn't coexist except on the Altos that we didn't then have that had a devil sized mic restore and I've thought of reviving that in one of our emulation so that we could do that but it's you know that's how history was and the newer systems have that built him I have maybe one concluding question and it might be too broad so if it is don't answer it but it but the question is it seems like this you know idea of an environment and a language that was all message based this sort of object-oriented paradigm also where it affords this kind of continual bootstrapping to evolve new systems really has captivated you and I was wondering if you could just you know and it seems like it's been sort of an intellectual journey for you for a long time and I would just be interested to hear for you if you can talk about like what has seized you about it - to be with it for so long and and develop at for for so long if you could speak to that yeah yeah well I think the the heart of it is computers are active things you know and there's just supremely active that's what they give you and and it's I guess my passion or the things that I've gotten excited about I mean they're other people's passions too but has been to serve that for other people and for my own creativity by by sort of grabbing on to the next thing that feels like leverage so when I talk about the history of all the small talks from 72 to 74 to 76 to 78 - to squeak they there's a theme there which is a system that's live and it's giving you leverage and each time more leverage or more speed or more something like that and and then with each sort of new step forward there are more things that can be done so so you can now we can do you know large systems now I can do big big address spaces now I can do garbage collection that we can do color now it can do animation you know all music simulation of the music simulation and squeak is really neat and so that's the thread there is of live coding I mean the thing that's nice about liveness is that it's just so motivating you know and I think you know when I look back in our time at Xerox PARC and I've mentioned this the system we worked with at least early on ran ten times slower than what the guys in the computers it's lab work we're doing but the turnaround time for change for us was typically a second or two after we had to come in character you know so so we were on it on it on it and and that's that's the fun thing is you know when you know what you want to do it's just you know you get there as fast as you can and and and the thing you're building is helping you do that so that's I like that and and it's not you know so I've been talking about it in terms of the the sequence of small talks but it isn't just small talk you know it's sort of any tool you get I mean I've had so much fun with other systems just doing doing what they can do I mean I remember having a lot of fun I got one of these first tiny tiny machines that could run VisiCalc or actually I think it ran some something a little bit more powerful than that and I and I spent a cross-country plane trip doing Pig Latin in it because you could and and it was live you know I could each thing I tried had it could do so so it isn't just small targets sort of any kind of live system that gives you leverage I loved APL that way and and you can see the you know the fact that we've sort of kept in fix arithmetic in Smalltalk is because of APL and in in Smalltalk is a nice actually system for modeling APL because it's got the sort of the polymorphism of the different layers of arrays and that's it's a fun program to write in small talk so it it is it it's almost in kind of if form of interact this liveliness is kind of like an interactivity with the system itself if you will yeah it's more than like interacting with the program or an app yep it's with the entire environment on the computer yeah it's feeling the strength of this new thing you know and I think there are musicians that are like that you hand a musician a new instrument and and things right away they'll be doing things Chris Jeffers was that way with the alto you know when we got the when we first got the music running on the alto we we didn't yet have the organ keyboard hooked up we hooked it up to the alto keyboard and which is which allows multiple key presses and he actually to be sort of like was this for a couple of minutes and then things started coming out and before the you know he was playing it so I think that's I don't know if it's what you say what an artist does but creative people when they get a hold of some play and they start making it into something thank you yeah nice question yeah I think you talked about this in one of your bite articles actually in the magazine over there on the table you talked about sort of the the instant response and the kind of creativity that that liveness allows and and that was sort of like a becomes a philosophy you know yeah yeah and I think and you know in terms of serving users that's what users want you know there's there's both the immediacy and then you want it to be in their terms as much as possible and that's how what some of these you know advances in the interface have afforded all right and it definitely makes software development more productive sure yep they're having to wait a day for your card punched your printouts to turn around yeah and it's it's it's a compounding of productivity because on the one hand you're getting it done sooner but on the other hand it's motivating so you're you keep going forward you and there I find comfort her and here it says reverse this area they are from black to white and let's do so something we could do is to is to actually put another method here so right now what it does is it simply complements the rectangle but we could also recomment a rectangle let's do this we could we could write our translate by @one let's see what I think what we're gonna do um what I want to do is I want to make a copy of this rectangle R that's offset and if I do that as well as complimenting the regular rectangle then it should make an outline around the selection okay so um let's try compiling this all right let's see where we are Oh says it's the point at which we stopped you know what I needed guys we may be hosed oh do we delete something no but we I think we just quit with an error in the system I mean we got a mmm let me see huh let me just give some thought to this it's the wrong character here or did you type the I typed a net sign instead of them a complaint oh right yeah you need to type control oh yes but the only thing is that we did this in the very heart of the system and there may not be a way out of here I'm gonna quit there's no way to revert to change now that's compiled no that's yeah that's right there's not we could start from another copy of this if we had another copy yeah well do you want is there anything to try to try now are you pretty sure that we need to do that yeah pretty sure we need to do that okay I'm gonna try quitting and resuming but I'm pretty sure if you're really fast you can stop it before it does this but it wrote a checkpoint I believe but I guess we'll know for next time have to just facts yeah yeah right yep it's faithfully preserved everything yes as the downside of making live changes yep it's actually kind of a great demonstration you

Channel: Computer History Museum

Views: 17,177

Rating: 4.9716311 out of 5

Keywords:

Id: uknEhXyZgsg

Length: 128min 2sec (7682 seconds)

Published: Tue Mar 12 2019

Reddit Comments

[u/madmulita]

I used Smalltalk/V in 1990, it was black magic, still is.

[u/GoranM]

Whenever I see videos by any of the XeroX PARC people, talking about (or even directly demonstrating) the benefits of their approach, I always wonder if performance was the only issue keeping such systems from achieving mainstream adoption, or if there are other, architectural issues that actually made it problematic.

Watching some presentations by Alan Kay, one would get the impression that Small Talk (and other such systems) failed to gain significant momentum largely because people in industry were too ignorant/disinterested to even know that something like Small Talk existed, and that's why people went on to make things like JavaScript.

My current view is that it was largely a matter of performance, which developers had to actually keep in mind, especially back then, but I would be interested in alternative theories.

[u/cloudspare]

In another reality...

[u/AsIAm]

The last segment was funny. :)