Hi Frank--
> Please show me a live object in a Browser. Please. No, not a textual
> representation of a computation. Oh, that's right, you are STILL
> writing source code prior to compiling. Fail.
Browsers and debuggers are examples of inspectors, tailored to
specialized tasks (e.g., writing methods and manipulating contexts). At
a given moment, each inspector provides a interface for communicating
with some live object. In the case of a "system browser", that live
object is some class. For me, the ability to evaluate impromptu
expressions in which "self" is bound to that class is what makes the
browser "live". It justifies the claim that this live class is "in" the
browser (although I think it makes more sense to think of the class as
being "on" the browser, like a person with whom you're chatting is "on"
the phone, or Skype, or TV).
This communication ability is indispensable, and is what makes
livecoding special for me. It manifests itself in many other ways in all
the other inspectors we have. We can have useful and enlightening
conversations with contexts, methods, collections, etc. etc.
> And guess how the Lispers store their source code? In text files, in
> git.
I have a hard time imagining anyone who has used an interactive
Lisp machine not finding this overwhelmingly sad. :)
> I have seen zero reason in my, er, 13 years of Smalltalk, why we
> shouldn't enter source code in a proper text editor, with source
> properly stored in files on a disk.
Well, I only need one reason, and it's this: object-aware tools,
composed of objects, do a better job of enabling development. The
"proper" stuff above just cracks me up! :) "More widespread" or
somesuch I can see, but "proper" is a gratuitous expression of personal
bias.
> ...source code is not a live object, it is text.
Surely text need not be a live object, but it can be. If source
code and other texts are live objects, they can take on useful behavior,
collaborating with other objects in the pursuit of their own munging.
> And text should be munged by [external] text tools, and stored in
> text files, and kept in a text-friendly source control system.
Sure, you could do that. Why is that the only possibility? Also,
why can't object memories present themselves as filesystems, and then
interact with all those crusty old external text tools? (E.g.,
interaction via WebDAV[1])
When you take an individual file out of the filesystem which
provides its context, you then rely on conventions between people as to
how to interpret those files. You're relying on the behavior of those
people. I think it's an improvement to endow the artifacts themselves
with as much of that behavior as possible.
> What else do you think bootstrapping is all about? It's taking some
> tiny system, and making a recipe to lift that bootstrap, and that
> recipe is not a living object, it is a specification, and it's written
> in text.
Or it could be a specification expressed in a very small number of
objects. Were you this crotchety when they got the metacircular
evaluator section of your Lisp class, too? :)
> ...I nearly cry when I see the community reject things because of
> some strange ideology with the result that we end up lost in the dark.
I have a very bright torch; what wrongs need righting? :)
-C
[1] http://tinyurl.com/7j26wk6
--
Craig Latta
www.netjam.org/resume
+31 6 2757 7177
+ 1 415 287 3547 (no SMS)
