@chiffchaff @oxy @davidgerard This is eerily evocative of the current monoculture in modern networking: #eBGP , #Clos network (spine-and-leaf), aggregated top-of-rack switches. #STP everywhere. Mentioning #G8032 #ERPS rings gets you strange looks; that's just for security camera #PoE switches isn't it? /s And the utter dependency of #SRv6 #TILFA robustness on #ISIS state. From this I infer that the #GenAI obsession is retarding actual progress in telecoms and computer networking.

In going through some old papers, I ran across these very interesting documents from long ago that I can't seem to find public reference to. They seem to offer some important historical insight about the Dylan language. This is from back when Dylan was called Ralph as a working title. In those days, the still-being-designed Lisp-like language had not yet moved to an infix syntax, and it looked and acted more like Scheme with an object system similar in spirit to CLOS (the Common Lisp Object System).

My understanding is that there were some fairly deliberate choices made to NOT target the Lisp or Scheme community as users, which is part of why the move to infix. I think they wanted to appeal to a disaffected C++ crowd, but ultimately lost out to Java for that bid, and then having left the Lisp user base behind, ended up with a very small community as a result.

But I still think there could be things the Scheme community would want to glean from this snapshot of history.

I've included a scan of an email proposal I got from Dave Moon while he and I were at Symbolics, with his proposal for how to add conditions to the language. Note that Dylan did eventually go public and did have a condition system, so you could also just study that design directly. But what's useful here is to see how all that looked syntactically in a Scheme-like syntax. But, in that regard, I recommend starting by looking at the language itself.

[0] Ralph: A Dynamic Language with Efficient Application Delivery, by Andrew LM Shalit, July 25, 1991.
https://nhplace.com/kent/History/dylan/ralph-1991-07-25.pdf

[1] Ralph Conditions (part 1 of 2)
https://nhplace.com/kent/History/dylan/ralph-moon-conditions-proposal-v1.1-part-1-of-2-1991-08-14.pdf

[2] Ralph Conditions (part 2 of 2)
https://nhplace.com/kent/History/dylan/ralph-moon-conditions-proposal-v1.1-part-2-of-2-1991-08-14.pdf

cc @sigue @ramin_hal9001 @screwlisp

#DylanLang #RalphLang #ComputerHistory #Harlequin #Lisp #CommonLisp #ConditionSystem #ConditionHandling #ErrorSystem #Scheme #SchemeLang #CLOS #AppleHistory #KentsHistoryProject

@screwlisp

You can pick up the document 'Signalling and Handling Conditions' from this index page:

http://nhplace.com/kent/ZL/

It was longer than I thought it would be, but I think you'll find it interesting to see what the Zetalisp condition system (which inspired the Common Lisp condition system) looked like.

In spirit, it was much the same. The biggest differences are:

* The CL system has 'active' restarts, where the ZL system had a passive thing where you returned a value to the case context and hoped that it would do the thing you wanted. It felt quite a bit more error-prone (if you'll pardon the reuse of 'error' here, maybe I should say 'mistake-prone').

* The ZL condition system offers a lot of really low-level stuff that did not seem proper for CL.

* The set of operations offered in ZL was richer, but also a lot more complicated, I thought, and I worried people would not really see what it was trying to do.

* Obviously, the ZL system was based on Flavors, not CLOS, and made reference to a lot of LispM-specific packages.

* The document was published in January, 1983 and identifies itself as part of Symbolics Release 4.0.

There are other differences as well.

#Zetalisp #LispMachine #LispMachines #Symbolics #LispM
#ConditionHandling #ConditionSystem #ErrorSystem #ErrorHandling #CommonLisp #CL #Flavors #CLOS #History #ComputerHistory
#InternetArchive #Bitsavers

SBCL: the ultimate assembly code breadboard - Paul Khuong: some Lisp

Paul Khuong's personal blog. Some Lisp, some optimisation, mathematical or computer.

For my research into building better abstractions, I'm looking at #CommonLisp, and, in particular, #CLOS, the extremely flexible and powerful #OO system that is part of the language. It is probably as powerful as any OO language in existence, given that some of the internal mechanisms can be altered to better fit your problem space. According to the Art of the Metaobject Protocol, CLOS doesn't occupy a point the space of possible OO systems, but a region.

#lispyGopherClimate #valentinesDay Morning in Europe #peertube #live #programming #technology #podcast .

#archive https://toobnix.org/w/wzDqaQke9raTSTxVDHTemo

Oldschool versus newschool
#lisp #versus #CLOS in #commonLisp

(basically me monday morning quarterbacking myself from the Tuesday-night-in-the-americas hosted by Ramin)

I will at least try push-button running *this article* which factors into the long-delayed current log I am writing. https://screwlisp.small-web.org/software-individuals/sandewalls-sat-solver-implementation-example/ which feeds into the other topic.

https://github.com/atgreen/icl

improved CL repl

2nd contributors is claude.. ._.

#lisp #CL #CLOS #llm

GitHub - atgreen/icl: Interactive Common Lisp: an enhanced REPL

Interactive Common Lisp: an enhanced REPL. Contribute to atgreen/icl development by creating an account on GitHub.

GitHub

<">
I mean, typecase using type specifiers makes sense, it’s a type-based operation after all. But handler-bind feels like a class- (or whatever the hierarchy of conditions are, they are not standard-objects iirc) based operation. Yet it uses type specifiers, and that’s a fun turn of events.
</">

My intuition is different.
I see this part of what `handler-bind' does merely (or at least essentially) as a kind of type dispatch (except that the primitive types are only condition types).

(Whether condition types are standard-classes is implementation-dependent, so they may or may not be such.
What is important is that the hierarchy of the kinds of conditions is integrated with the hierarchy of classes (and types).)

<">
I wish generics also allowed type specifiers. Imagine the world we’d be living in…
</">

To some degree I think we already do.
I haven't done this, so off the top of my head, I think it's possible to base method dispatch on (much of) what compound type specifiers allow by sufficiently heavy use of the Meta-Object Protocol and suitable metaclasses.
It would likely be also necessary to wrap `defmethod' in macro calls, but that is par for the course.

Whether that would be a good idea is another matter.
The complexity of the implementation would have to be justified.
Then this might reduce the efficiency of method dispatch.
(We usually don't mind when the efficiency of handling exceptional situations is less than the efficiency of "regular" execution.)

#CLOS
#CommonLisp
#CommonLispObjectSystem
#GenericDispatch
#MetaObjectProtocol
#MOP

@aartaka

Cl-gopher is a Common Lisp library that implements the server and client sides of the Gopher protocol, as well as a sample text client. An easy to understand and well designed example of using CLOS.

https://github.com/knusbaum/cl-gopher

#gopher #CommonLisp #clos #lisp

GitHub - knusbaum/cl-gopher: Gopher library in Common Lisp

Gopher library in Common Lisp. Contribute to knusbaum/cl-gopher development by creating an account on GitHub.

GitHub