10 ms·

> See what you think about what happens around 9:05 I saw two interesting things around 9:05. A 13 year old made an 'active essay' on the computer which contai

> See what you think about what happens around 9:05 I saw two interesting things around 9:05. A 13 year old made an 'active essay' on the computer which contains not just text but also a dynamic interactive environment so the reader can follow along and even try out new ideas. This type of media is not prevalent today - essays written by 13 year olds today would be in Google/Word docs and contain only static text and static pictures (i.e. digitized paper), but no interactivity. There are ways to do interactivity today, of course, but they are not easy and not the default. Is this what you are getting at? The other interesting thing is how two tools - the drawing tool and animation tool - are made to work together, even when they were not created with each other in mind. IIUC the image is not a file format here but an object, but don't both tools then need to work with the same image protocol? I suppose you can always have adapters to connect different image protocols, but it doesn't seem like the best option. Still thinking about how much (or how little) shared knowledge is needed to make this scale to all types of objects.

alankay1 9y ago
My reason for drawing your attention to this section of the talk is to show some of the ideas (now 40-50 year old) were about "dynamic media" - of course live computing should be part of the combined media experience on a personal computer -- and of course you should be able to do what are now called "mash ups", but to be able to combine useful things easily and at will (it's crazy that this e.g. isn't even provided for maps in a general way on smartphones, tablets and PCs). But the larger point here is that if one is dealing with dynamic objects as originally intended, the objects can help greatly and safely in coordinating them. This shouldn't be more difficult than what we do in combining ordinary materials in our physical world (it should be even simpler!). In the system used for the demo -- Smalltalk-78 -- every thing in the system is a dynamic object -- there are no "date structures". This means in part that each object, besides doing its main purpose, can also provide useful help in using it, can include general protocols for "mashing up", etc. We can do better today, but my whole point in the interview and in these comments is that once e.g. Engelbart showed us great ideas for personal computing, we should not adopt worse ideas (why would any reasonable people do this?), once dynamic media has been demonstrated in a comprehensive way, we should not go back to imitating static media in ways that preclude dynamic media (if you have dynamic media you can do static media but not vice versa!). Going back and doing Engelbart or Parc also makes no sense, because we have vastly more computing resources today than 50 years ago. We need to go forward -- and -to think things through- ! -- about what computers are, what we are, and how to use the best of both in powerful combinations. This was Licklider's dream from 1960, and some of it was built. The dream is still central to our thinking today because it was so large and good to be always beckoning us ahead.
- shalabhc 9y ago
  Thank you for taking the time to respond, and I'd really appreciate if you can clarify my follow up below too! > every thing in the system is a dynamic object -- there are no "date structures" I'm still programming in data structures :/. I've seen many of your talks over the years and it took me quite a while to realize what you mean by objects (I think) is not just the textual specification (i.e. 'source code' in today's world), but rather a live, run-able thing that can be probed, inspected and made to do its thing, all by sending messages to it. In the Unix world this would be more akin to a long running server process, but with a much better unified, discover-able IPC mechanism (i.e. 'messaging'). The only thing that needs to be standardized here is the messaging mechanism itself. Larger processes would be constructed by just hooking up existing objects. Automatic persistence would mean these objects don't need to extract and store 'just data' outside themselves, etc. This model blurs the distinction between what today we call 'programming' (writing large gobs of text), what we call 'operations' (configuring and deploying programs), and what we call 'using' (e.g. reviewing, organizing my photos). Instead, for every case, I would be doing the same kind of operation - i.e. inspecting and hooking up objects - but the objects I'm working with would be different, and the UI could be different. This makes programming more interactive ('let me see if this object can talk to that object by actually connecting them' vs. 'let me see if I can write a large blob of text that satisfies the compiler, by simulating the computer in my head'). The other thing I notice is you don't slice the computation the same way that is so common today. E.g. today I write source code (form #1 of computation), which runs through a compiler to produce an executable file (form #2 of the same computation), which is then executed and loaded in memory (form #3, because now it merges with the data from outside itself). Form #1 is checked in to source control, form #2 is bundled for distribution and form #3 is rather transient. Instead, you're slicing computation on a different axis and all forms of the same computation are kept together - i.e. the specification, executable and runtime forms are one and the same 'object'. The decomposition happens by breaking down along functional boundaries. This means modification of the specification can happen anywhere I encounter one of these live objects, right then and there. I don't have to trace the computation to its 'source'. So my main question is - am I on the right track here? > Going back and doing Engelbart or Parc also makes no sense I agree, but given the sad state of composition, even if we had some of those ideas today, it would seem like a step forward :) IMO, today we want to think of farms of computers as one large computer, and instead of programming in the small, we want to program all of them together.

alankay1 9y ago

My reason for drawing your attention to this section of the talk is to show some of the ideas (now 40-50 year old) were about "dynamic media" - of course live computing should be part of the combined media experience on a personal computer -- and of course you should be able to do what are now called "mash ups", but to be able to combine useful things easily and at will (it's crazy that this e.g. isn't even provided for maps in a general way on smartphones, tablets and PCs). But the larger point here is that if one is dealing with dynamic objects as originally intended, the objects can help greatly and safely in coordinating them. This shouldn't be more difficult than what we do in combining ordinary materials in our physical world (it should be even simpler!). In the system used for the demo -- Smalltalk-78 -- every thing in the system is a dynamic object -- there are no "date structures". This means in part that each object, besides doing its main purpose, can also provide useful help in using it, can include general protocols for "mashing up", etc. We can do better today, but my whole point in the interview and in these comments is that once e.g. Engelbart showed us great ideas for personal computing, we should not adopt worse ideas (why would any reasonable people do this?), once dynamic media has been demonstrated in a comprehensive way, we should not go back to imitating static media in ways that preclude dynamic media (if you have dynamic media you can do static media but not vice versa!). Going back and doing Engelbart or Parc also makes no sense, because we have vastly more computing resources today than 50 years ago. We need to go forward -- and -to think things through- ! -- about what computers are, what we are, and how to use the best of both in powerful combinations. This was Licklider's dream from 1960, and some of it was built. The dream is still central to our thinking today because it was so large and good to be always beckoning us ahead.

shalabhc 9y ago
Thank you for taking the time to respond, and I'd really appreciate if you can clarify my follow up below too! > every thing in the system is a dynamic object -- there are no "date structures" I'm still programming in data structures :/. I've seen many of your talks over the years and it took me quite a while to realize what you mean by objects (I think) is not just the textual specification (i.e. 'source code' in today's world), but rather a live, run-able thing that can be probed, inspected and made to do its thing, all by sending messages to it. In the Unix world this would be more akin to a long running server process, but with a much better unified, discover-able IPC mechanism (i.e. 'messaging'). The only thing that needs to be standardized here is the messaging mechanism itself. Larger processes would be constructed by just hooking up existing objects. Automatic persistence would mean these objects don't need to extract and store 'just data' outside themselves, etc. This model blurs the distinction between what today we call 'programming' (writing large gobs of text), what we call 'operations' (configuring and deploying programs), and what we call 'using' (e.g. reviewing, organizing my photos). Instead, for every case, I would be doing the same kind of operation - i.e. inspecting and hooking up objects - but the objects I'm working with would be different, and the UI could be different. This makes programming more interactive ('let me see if this object can talk to that object by actually connecting them' vs. 'let me see if I can write a large blob of text that satisfies the compiler, by simulating the computer in my head'). The other thing I notice is you don't slice the computation the same way that is so common today. E.g. today I write source code (form #1 of computation), which runs through a compiler to produce an executable file (form #2 of the same computation), which is then executed and loaded in memory (form #3, because now it merges with the data from outside itself). Form #1 is checked in to source control, form #2 is bundled for distribution and form #3 is rather transient. Instead, you're slicing computation on a different axis and all forms of the same computation are kept together - i.e. the specification, executable and runtime forms are one and the same 'object'. The decomposition happens by breaking down along functional boundaries. This means modification of the specification can happen anywhere I encounter one of these live objects, right then and there. I don't have to trace the computation to its 'source'. So my main question is - am I on the right track here? > Going back and doing Engelbart or Parc also makes no sense I agree, but given the sad state of composition, even if we had some of those ideas today, it would seem like a step forward :) IMO, today we want to think of farms of computers as one large computer, and instead of programming in the small, we want to program all of them together.