LOOPS was one of the early frameworks for AI programming (-> for Knowledge-based Systems -> especially Expert Systems) in Lisp, which also made use of the new graphical user interface of the Interlisp-D Lisp Machine from Xerox. Interlisp-D was a combination of operating system and development environment, and was developed for the same computers, which also ran Smalltalk. Both were image-based and managed the source code in the development environment.

Remarkable is the fully interactive way of working in the REPL (Lisp's Read Eval Print Loop) and through the GUI, including live editing all classes/etc. via menus. LOOPS extended Interlisp with various ways to do object-oriented programming and a rule-system.

There is also a "friendly primer" for Xerox LOOPS, from mid 1980s. https://bitsavers.org/pdf/xerox/interlisp-d/198510_Koto/3102...

Note that LOOPS is an early OOP System, it's not a about iteration in a loop.

I was at a presentation on LOOPS in London given by Dan Bobrow and Mark Stefik, they were pitching it as an equivalent framework to KEE or ART as you describe. They had a good showcase application called Truckin' [1] that made good use of all the features of LOOPS.

[1] https://www.markstefik.com/?page_id=359

Yes!, that Truckin’ demo was awesome. I had a 1108 Xeorx Lisp Machine, and ran InterLisp-D on it the first 18 months I had it, then switched to running Common Lisp. Such a fantastic development environment!

Some more background https://larrymasinter.net/stefik-loops.pdf and https://www.markstefik.com/?page_id=334

I think LOOPS was limited by only being available on Interlisp-D related systems. Common LOOPS was supposed to be portable, but I remember it only in the context of the CLOS development as a stepping stone, but not as a product or environment like LOOPS.

I ran Common LOOPS in AKCL on a 386 PC. It was just an object system for programming, it didn't have a Frame System or Rule Engine as well like LOOPS.

My previous environment had been Franz Lisp on the Atari ST. My copy of the Franz sources was missing flavors so I wrote my own object system for it that looked a bit like New Flavors but with a frame system built in as well. My binding to GEM from Lisp made use of the object system as well and the repl was in a GEM window.

[just in case it saves anyone else some confusion: §s in the bitsavers scan are out of order]

Volume I of the Medley LOOPS series about the Lisp Object-Oriented Programming System, an Interlisp object extension. Volume II is coming in the late fall of 2024, Volume III in the fall of 2025.

Thanks for sharing. I didn't realize it was available, but the version is 1.2 and date is July 2024, so it must have been around for some time.

You're welcome. Although the manuscript was circulated internally for feedback over tha past few months, we published it to the Medley Interlisp Project website only a few days ago.

What are the major differences to CLOS?

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?

The answer would depend on what you think "message sending" is and why you think Smalltalk does not support "message sending".

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.

can't wait for ecmascript 12 to support part of that :p

The answer is mostly about CLOS and not about LOOPS.

Update: my remark was about an earlier posted content, which had an "AI" generated answer. That text has been removed.

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.

The only way to improve GenAI-slop comments is to delete them, please stop polluting HN.

EDIT: The comments I was referring to got sneakily edited. Another thing that is not nice to do.

Providing an answer would have been more helpful.

EDIT: still no helpful contribution, just nagging.

And what are the major differences between LOOPS and CommonLOOPS (besides Interlisp vs CL)?

That's discussed in this paper: CommonLoops: merging Lisp and object-oriented programming https://dl.acm.org/doi/pdf/10.1145/28697.28700

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.

Thanks, will have a look at it.

somebody asked what's the different between LOOPS and CLOS, but probably more time relevant question is what's the difference between LOOPS and Flavors. they list Flavors as an inspiration, but also various knowledge management systems, so there must be something additional going on there. maybe lispm knows.

OP is a very long book, I haven't had a chance to read it fully, but first thing I wanted to see is how they manage message sending, and it's as jank as it is in flavors. I thought considering how custom interlisp can be they'd do something special. nope, it's just send.

for those who don't know what I'm talking about, an old school smalltalk style object system lets one send arbitrary messages, without prior knowledge of what those messages might be, and treats the receiving object as a blackbox (conceptually anyway). this approach doesn't map well to s-exp, because first symbol in an s-expression drives the logic. in flavors (and in LOOPS) the symbol used is "SEND", so in order to actually send a message you write something like

  (send some-window :set-edge 10 10 40 40)

as you can imagine a very heavily object oriented code becomes littered with sends. LOOPS seems to make it a little bit less painful by making ← an equivalent of send, so above can be written as

  (← SomeWindow SetEdge 10 10 40 40)

this is obviously only a margin improvement.

clos solved this problem by drifting away from smalltalk's blackbox concept and making everything generic function oriented,

  (set-edge some-window 10 10 40 40)

And SEND is just a macro over FUNCALL.

    (DEFMACRO SEND (OBJECT OPERATION &REST ARGUMENTS)
      "Send a message to OBJECT, with operation OPERATION and ARGUMENTS."
      `(FUNCALL ,OBJECT ,OPERATION . ,ARGUMENTS))