The Remote Agent Experiment: Debugging Code from 60 Million Miles Away

> What part of the stuff from that link was written in Lisp? All of it. (Except for an IPC system which was written in C. See this video if you want to know the whole story.) > Would you answer them? I'll answer a few of them. > if Lisp is so wonderful compared to C, how come so many more safety-critical systems are written in C? Politics mainly. And inertia. And the sunk cost fallacy. > Is it because the entire profession is blind, and only you and a few enlightened ones realize how wonderful Lisp is? Yes. Pretty much. > Or is it because people that have done this for decades see more problems with Lisp than you are aware of? They, like you, think they see problems, but they, like you, are wrong. Tellingly, none of the people who think there are problems with Lisp actually know Lisp.

A more detailed (and accurate) account: this video Stuart got one significant factual detail wrong: the race condition was in Lisp code.

There's this (edit: 2012 Google Tech Talks) video: this video "The Remote Agent Experiment: Debugging Code from 60 Million Miles Away" by Ron Garret. IDK how similar it is to the 1998 talk by him you refer to. I guess he's around here by the nick "lisper".

Unless you write it in CL, in which case you get a debugger REPL, and you can debug it hundred of million of km away. this video

I'm reminded of Ron Garrett's writing/talks on remote debugging the Remote Agent for the New Millennium Deep Space 1 (DS1).[0], [1] [0]: The Remote Agent Experiment: Debugging Code from 60 Million Miles Away - this video [1]: NASA Programmer Remembers Debugging Lisp in Deep Space - link

This is what I was mainly known for: link link I think I'm most proud of this: link link though it didn't make nearly as much of a splash. I was also the tech lead on the New Millennium Deep Space One Remote Agent Executive, which sounds cool, but was really kind of a disaster. See: this video if you want the gory details.

It's actually not that hard to explain, yet without experiencing it firsthand, it is hard to see what this REPL fuzz is about. So, let's take a minimal, simple example: if True: print("Hello, Python!") and the equivalent code in Clojure: (when true (println "Hello, Clojure!")) In Clojure, you can send any expression fragment like a single symbol, list or even incomplete code and it will be evaluated according to its context. So, you can sent `true`, you can send `println` and you can even send `(when true println)` or `(when true (println))`, or even `(when true ,,,, (println))` (you can replace commas with line breaks if you want) and it will still be evaluated. In Python, you can send `True`, and you can send `print`, but you can't send `if True: print` (even with corrected indentation), because Reader would have hard time making sense of that. In Python, you need to adhere strictly to its syntax, and partial expressions that don't form a complete statement won't be evaluated meaningfully. In contrast, Clojure's REPL can work seamlessly with code fragments because the underlying representation of code is just data structures that are always valid within the REPL context. What makes it mind-blowingly cool is that you can send these expressions to a remote REPL without any transformation, serialization, or encoding, because it's not just code — it is data. In fact, some teams do just that. They'll keep an open socket on a running app, possibly performing somewhere in the clou