To be live or not to be live!

Nevin Pratt nevin at
Mon Apr 22 21:02:04 UTC 2002

Jecel Assumpcao Jr wrote:

>In contrast, the sources of a "living system" are only part of the 
>story, just as the human genome is a very incomplete description of a 
>person (as Jim pointed out). Such systems have lots of additional 
>information normally created by tools other than simple text editors.

I'd also like to point out that the very *concept* of "source code" is 
muddy for image-based development.  While it might be generally accepted 
that the contents of the method dictionaries constitutes "source code", 
that is only part of the story.  This becomes acutely evident when we 
occasionally fail to reconstitute the expected "program" while doing a 
simple-minded copy and insert of those method dictionary contents into a 
"virgin" image (IBM VisualAge is notorious for that with it's GUI 
classes, and all Smalltalks will byte you in this regard when it comes 
to pool dictionary usage, as well as a few other examples I have  
encountered in my career).

With image-based development, the act of development is reified as a 
conversation between man (or woman), and machine.  It is a process where 
the programmer has a conversation with an already-running program, to 
convince it to alter it's behavior a bit to adapt to the new 
requirements.  It's a conversation, nothing more.

Consider that even creating a subclass is done via sending a 
#subclass:... message to the superclass, therefore this is nothing but a 
portion of that conversation between programmer and machine.  The 
particular portion dealing with subclassing has even deliberately been 
chosen in a manner to look declarative, but it is not.  It's just a 
programmer sending messages to an already running program.  It's just 
part of a conversation.

Therefore, you could also make a case that a transcript of that 
conversation is just as valid of a candidate for "source code" as is the 
contents of the method dictionaries.  Indeed, perhaps even a stronger 
case could be made for that point of view.

But in any case, "source code" for Smalltalk doesn't mean the same thing 
as "source code" for declarative languages.  And when anybody tries to 
assert that it does, I used to handle it by challenging them to provide 
to me a definition of "source code" for Smalltalk, and then I would 
proceed to poke holes in their own definition by providing counter 
examples.  Of course, any more, I typically don't even bother doing 
that.  Nowadays, I typically just ignore them :-)


More information about the Squeak-dev mailing list