shebs@utah-cs.UUCP (Stanley Shebs) (08/31/84)
The fundamental theoretical work on OOLs has been done by Carl Hewitt and his students at MIT, under the guise of "actor systems". There's numerous papers scattered through the literature, starting with Hewitt's thesis in 1969 (which I've heard described as "brilliant but impenetrable"). Much of the work has concentrated on implementing various control structures as message-passing, and more recently on doing synchronization in multiprocessor systems. A closely related topic is that of data abstraction, since objects are a good way to implement the abstraction. So research on languages like CLU and Alphard is relevant, although those languages don't quite go to the "extreme" that Smalltalk does, in basing *everything* on objects. While we're on the subject of theory, I should point out that Smalltalk and Lisp are not at all similar, as has been suggested in several recent articles. Similarities of automatic storage allocation, debugging tools, and so forth are purely superficial - the fundamental semantics are quite different. Sussman (of Scheme fame) has pointed out that message-passing has a very natural expression in terms of dispatch tables containing the methods (which are just procedures), a technique which is easily implemented in Scheme (it would be somewhat more difficult in ordinary Lisp, but still useful, as witness the fact that nearly all "production" Lisps have OOL packages). Lisp is based on application of functions, while Smalltalk is based on message-passing. While we're on the subject of misperceptions, Smalltalk is not particularly suited to AI (neither is Lisp - more on that in a moment). Yes, there's a nice environment, and yes, programs can be represented as data (though with a little more difficulty than in Lisp), and certainly the inheritance is nice. However, building interesting AI programs in Smalltalk or Lisp is akin to writing compilers and operating systems in assembly. Just too crude and low-level. On the other hand, rule systems are good, Prolog is good (though *not* the ultimate answer), KL-TWO and RLL/Eurisko are good. We don't yet know how to make a true AI language yet, one which operates at the "knowledge level" as defined by Newell, and which is as far advanced over Lisp and Smalltalk as the latter are over assembly language. We barely know what such a language should be able to do, let alone how it should be built! stan shebs hplabs!utah-cs!shebs SHEBS@UTAH-CS
trow@uw-june (Jay Trow) (09/07/84)
Forwarded from Smalltalk80Interest^@Xerox: --------- From: deutsch@xerox.arpa Date: 1-Sep-84 18:25:54 PDT Subject: Re: OOLs in General There is great difference of opinion in the AI community about the relative value of procedure-, object-, logic-, and rule-oriented paradigms for writing AI systems. My reading is that each of these has proved to be valuable, and "the best" or "the most natural" for some subset of AI applications. (Then again, there is great difference of opinion about what is AI and what isn't, too.) Part of the reason that procedure- and logic-based programming are so popular is that it seems to be easier to simulate the other two paradigms in terms of them than vice versa, so if that's your starting point, you get to have the largest number of paradigms at your easy disposal. ---------