LOOPS (Lisp object-oriented programming systems) is written in Interlisp for the Interlisp-D environment, was a Xerox product and is from around 1981.
CLOS (Common Lisp Object System) is a general OOP standard extension for Common Lisp. A specification was proposed in 1987/88. CLOS was included in the Common Lisp standard and widely implemented by various implementations.
Both were a "system" -> meaning that it is available and programmable also at runtime.
LOOPS is an actual piece of software with a GUI, which integrates into the Interlisp-D development environment.
LOOPS was based on message sending, classes, methods, interactive changes to the object system.
CLOS does not use message sending, but calling generic functions with multi-methods and multiple dispatch.
LOOPS supports Access-oriented Programming with Active Values. Demons can act based on access to objects. CLOS has no direct support for that. Maybe partial (-> :before & :around &:after methods in CLOS).
LOOPS includes a rule-system. CLOS systems have that as extensions. It's not a part of CLOS itself.
LOOPS includes graphical & menu tools to browse and edit objects. CLOS systems have some of that as extensions, depending on the implementation.
LOOPS was a programming system for knowledge-based systems, like Expert Systems. CLOS was not designed for that, but such programming systems were also developed for Common Lisp, some using CLOS. Example: KnowledgeWorks from LispWorks.
LOOPS was later rewritten as CommonLOOPS for Common Lisp. The software "Portable Common LOOPS" (PCL) then was further developed into a portable (and widely ported) and complete prototype implementation of CLOS + MOP.
Thanks. I'm mostly interested in the OO features. I assumed that LOOPS was essentially an OO extension of Interlisp (and thus a precursor of CLOS) due to the title. Does it really do "message sending", or is it rather like Smalltalk, which does "normal" method dispatch and call, but where the term "message sending" is use for this?
My intuition on the phrase "message sending" is that it should be distinguished by immutable values. If I send you a message by writing it on a piece of paper, I don't expect that if you write on that note it will change any information I have on me. The message is passed by value, not by reference. I should be able to copy the message, send it over a network or store it to external memory, and have everything still work the same.
CLOS and Lisp inherently involve passing objects by reference. If they allow mutation operations, the receiver of a value can mutate it and that's visible to the caller.
These physical analogies also make me think that for it to be message sending then it must be asynchronous, because if I send you a letter then I'm not forcefully frozen from the instant I drop it into the postbox until I hear back.
Just like Smalltalk, which has no concept of immutable types, other than only providing accessor messages, which is an active decision by the class implementer.
Well, as I understand it, it achieves that by making the message passing extremely fine grained. So, in a sense all the messages are immutable, but only by creating a hairball of objects and messages.
Maybe I should be thinking about what sending references to objects in messages means.
Meanwhile I have had a chance to skim the book and I have reason to believe that OO in LOOPS is solved very similarly to how it is in ST-76 and 80, i.e. virtual method dispatch via selector and calling a compiled method. A selector is simply the method signature, even if some people in the Smalltalk community refer to it as a "message". In contrast, there was actually something like message passing in Smalltalk-72, albeit synchronous.
The book unfortunately doesn't mention CLOS, nor does it give any hints about the differences. But the focus of the book is obviously on Lisp Object-Oriented Programming, not on Expert Systems. A comparison with CLOS is therefore apparent.
CommonLoops was proposed by Xerox to be the OOP system of Common Lisp in the standardization process. It was then decided to design a new system called Common Lisp Object System (CLOS), starting with a merge of the features of New Flavors (MIT/Symbolics) and CommonLoops (Xerox). Xerox implemented CLOS by modifying its CommonLoops implementation, during the standardization process. Thus Portable CommonLoops (PCL) was eventually the prototype CLOS + MOP implementation.
CLOS (Common Lisp Object System) is a general OOP standard extension for Common Lisp. A specification was proposed in 1987/88. CLOS was included in the Common Lisp standard and widely implemented by various implementations.
Both were a "system" -> meaning that it is available and programmable also at runtime.
LOOPS is an actual piece of software with a GUI, which integrates into the Interlisp-D development environment.
LOOPS was based on message sending, classes, methods, interactive changes to the object system.
CLOS does not use message sending, but calling generic functions with multi-methods and multiple dispatch.
LOOPS supports Access-oriented Programming with Active Values. Demons can act based on access to objects. CLOS has no direct support for that. Maybe partial (-> :before & :around &:after methods in CLOS).
LOOPS includes a rule-system. CLOS systems have that as extensions. It's not a part of CLOS itself.
LOOPS includes graphical & menu tools to browse and edit objects. CLOS systems have some of that as extensions, depending on the implementation.
LOOPS was a programming system for knowledge-based systems, like Expert Systems. CLOS was not designed for that, but such programming systems were also developed for Common Lisp, some using CLOS. Example: KnowledgeWorks from LispWorks.
LOOPS was later rewritten as CommonLOOPS for Common Lisp. The software "Portable Common LOOPS" (PCL) then was further developed into a portable (and widely ported) and complete prototype implementation of CLOS + MOP.