Ron Garret

"Lisping at the JPL" is one of my favourite stories (all-time favourite, not just computery favourite). https://flownet.com/gat/jpl-lisp.html > Debugging a program running on a $100M piece of hardware that is 100 million miles away is an interesting experience. Having a read-eval-print loop running on the spacecraft proved invaluable in finding and fixing the problem. The story of the Remote Agent bug is an interesting one in and of itself.

Sure, changing the syntax is not something to be done lightly. It has to be done judiciously and with great care. But it can be a huge win in some cases. For example, take a look at: https://flownet.com/gat/lisp/djbec.lisp It implements elliptic curve cryptography in Common Lisp using an embedded infix syntax.

Excellent points. Unfortunately, those people that only treat programming as a way to pay the bills - with a six figure salary - which would be the vast majority of professional programmers working today, do not want to understand _why_ they are writing code. The commoditization of software engineering that companies like Google [1] enthusiastically support and promote is also directly responsible for the obliteration of the entire field. In a world where geniuses like Alan Kay are almost unheard of and Tim Berners-Lee ends up receiving the Turing award (next: Stroustrup/Rob Pike) there really isn't a lot of hope for languages like Common Lisp to proliferate. They're simply too meta and require a lot more from you than just settling for whatever makes one feel good about him/herself in an immediate-rewards sense. [1] http://www.flownet.com/gat/jpl-lisp.html

Don't forget this classic! http://www.flownet.com/gat/jpl-lisp.html

Made me think of Lisp at JPL, one of my favourite software-dev history stories. http://www.flownet.com/gat/jpl-lisp.html

Can you give a link that clearly describes "measurement-as-a-cascade-of-entanglements process" in some reliable source? Best, some QM textbook. Basically exactly the same as this http://www.flownet.com/ron/QM.pdf (5.3), but in a well-known textbook or some review paper in a journal with good reputation. I run from time-to-time into a discussion which just needs such pointer...

This is a classic: http://www.flownet.com/gat/jpl-lisp.html Also check his open code lisp section! I would like to add as somebody whose first language was lisp, car/cdr never represented a problem. It looks more balanced than first/rest. The thing that got me were emacs, SICP lectures and the whole idea of lisp writing lisp. I don't think changing syntax would help much because lisp attracts certain types of people (I believe).

I love hearing about that sort of stuff too... Especially video games (GOOL and http://en.wikipedia.org/wiki/Game_Oriented_Assembly_Lisp and https://play.google.com/store/apps/details?id=com.friendlyvillagers.ba… and Mars rovers (http://www.flownet.com/gat/jpl-lisp.html) and other things that now are dominated by other languages. With Lisp, I'm always reminded of this quote: "Please don't assume Lisp is only useful for Animation and Graphics, AI, Bioinformatics, B2B and E-Commerce, Data Mining, EDA/Semiconductor applications, Expert Systems, Finance, Intelligent Agents, Knowledge Management, Mechanical CAD, Modeling and Simulation, Natural Language, Optimization, Research, Risk Analysis, Scheduling, Telecom, and Web Authoring just because these are the only things they happened to list." --Kent Pitman

Following the chain of articles to http://www.flownet.com/gat/jpl-lisp.html - Lisping at JPL and seeing that essentially lisp was abandoned because of an unreliable inter-process communications app written in C makes me wonder what SpaceX, Boeing etc are using.

So on an every decent sized project in one of those languages most of the code is boilerplate code you didn't even write but which wastes your time and brain cycles when you tinker with the code. Another interesting statistics that has been researched throughly is that productivity in LOC/hour is pretty much constant for programmers in all languages, which pretty much translates into higher productivity with more condensed languages. Check out these links for some real data: http://norvig.com/java-lisp.html http://wwwipd.ira.uka.de/~prechelt/Biblio/jccpprtTR.pdf http://www.flownet.com/gat/papers/lisp-java.pdf And this research was on a toy problem, not a real world project, on those the differences greatly intensify.

As someone who doesn't follow his blog, my summary is: "lots of people have 'weird' interests. I think Smalltalk is the best programming language. It's so good it can help save the world." Sure, there might be explanations elsewhere, just like there are evangelists for Lisp ... or Perl 6. And with similar arguments. Take http://flownet.com/gat/jpl-lisp.html from 2002 as an example: > I did try to introduce Lisp to Google. Having had some experience selling Lisp at JPL I got all my ducks in a row, had a cool demo going, showed it to all the other members of the ads team, and had them all convinced that this was a good idea. The only thing left was to get approval from the VP of engineering. The conversation went something like this: Me: I'd like to talk to you about something... Him: Let me guess - you want to use Smalltalk. Me: Er, no... Him: Lisp? Me: Right. Him: No way. That was 17 years ago! Any essay which doesn't take into account the "Lisp-weenie" stereotype (see http://wiki.c2.com/?SmugLispWeenie ) is preaching to the choir. I ended up putting this essay into the pile of other advocacy-for-language-X pieces I've read, with no interest in reading other blog postings. But I did anyway. https://medium.com/@richardeng/how-does-python-make-thinking-in-code-e… ("Pythonistas will also tell you that Python’s syntax reads like English"). 1) It's a strawman argument, as I'm a Pythonista and I don't say that, and 2) AppleScript is…

Interestingly to me, a lot of your points apply to my own favourite language, Lisp. Regarding a lack of private anything, it's possible to monkey-patch any Lisp package or class however one wants. And of course, one can get true privacy in JavaScript if one wants, by using closures — the same trick applies in Common Lisp. Lisp debugging is great: one can set up all sorts of condition handlers and restarts, and invoke them from the debugger. Lisp is a great blend of imperative, functional & object-oriented programming styles, enabling you to use the right tool for the problem at hand. Lisp is incredibly fast, faster than C & C++ in a few cases and almost always Fast Enough™. It's dynamic, but inner loops can be made very static for performance. There's even a standard way to trade off safety and performance, if that's what's important in a particular case. I don't know for certain, but I believe that Lisp was the language that invented hot-patching (well, I suppose one could always have done it from assembler …). It was even used to debug a problem on a NASA probe[0]: 'Debugging a program running on a $100M piece of hardware that is 100 million miles away is an interesting experience. Having a read-eval-print loop running on the spacecraft proved invaluable in finding and fixing the problem.' As with JavaScript, the Lisp debugger is part of the standard and is always available. This can be profoundly useful. And Quicklisp is a nice, modern way to pull down…

I love following article: http://www.flownet.com/ron/QM.pdf It basically shows that observation (measurement) and entanglement are the same things. Think about it: particles are not magically going out of superposition as we observe (measure) them. We (our atoms) become entangled with those particles, we become superposition. It's just propagation of entangled state. Why we don't perceive ourselves as in superposition? "It turns out that this result generalizes to any number of mutually entangled particles. If we ignore any one particle, the entropy diagram of the remaining particles looks like a system of N-1 particles in a classically correlated state with a non-zero entropy.". That means each atom of our bodies perceives other atoms entangled with it as they were not in any superposition (though as a whole, the system is still in superposition). We (atoms) are constantly entangled and in superposition with our environment, but we perceive it as classical state. In what state each atom "sees" every other? According to probability. That's why in double slit experiment we see only one of most probable outcomes, not a random one. Time could be rate of entanglement propagation. Entanglement propagates with speed of light (speed of particles), so we seem live in same timeline. But if something moves away from us with speed of light, the time for this object goes slower, but only relative to us. Until two particles interact with any way, they live in totally different…

I'm having a difficult time following his explanation. Here are a few of my stumbling points. Maybe you can help me out. 1) What does it mean that entangled particles are supercorrelated? How can S(A|B) = 2 or -1? 2) The formula for Von Neumann entropy is S = -Tr(p log(p)), where p is the density matrix. How do you take a log of a matrix? 3) Why does the interpretation rely on the density matrix? I've always thought of the density matrix as something that gives information about our ignorance rather than the system (this is why the density matrix mixes classical probabilities in alongside quantum amplitudes/probabilities - observer uncertainty is classical). Therefore, to me, any good interpretation of quantum mechanics ought to work without density matrices. Unfortunately his paper here (http://www.flownet.com/ron/QM.pdf) doens't seem to have significantly more information than his talk. Thanks for any help you can offer.

This document reinforces my opinion that most coding standard documents suck. I’ve seen a countless number of coding standards from different companies (some of the companies I even worked for) and they all sucked. No exception. Even though coding standards have some common sense advice and guidelines which is generally helpful for producing code of good quality, the amount of arbitrary irrational rules and beliefs that coding standards writers put into the standards and try to enforce through the standards actually end up hurting the quality of the code produced by developers trying to follow those rules. Case in point with examples from the NASA JPL coding standards for C: * no direct or indirect recursion What is it, FORTRAN-77? Some algorithms are way easier to implement recursively whereas the iterative algorithm can be much less straightforward and buggier. Think sorting: it’s easy to prove that the recursion is finite and that the implementation of the algorithm is correct. Do they use sorting in NASA or is it prohibited by this rule? * no dynamic memory after initialization FORTRAN-77 again! While dynamic memory management can be challenging in real-time systems and the generic malloc/free implementation is not acceptable, it doesn’t mean that statically pre-allocated fixed-size memory is better. It inevitably leads to brittle code ripe with excessive memory use, bugs like static buffer overruns, and sometimes even inability to use dynamic data structures…

One of the better sources for these differences and their magnitude is Peopleware. Instead of citing vague research "somewhere", they did their own primary research. More specifically they set up coding wars where different programmers at different companies assigned to the same task independently. They found 10x differences in time spent on the average coding war (which was typically a pretty small sample) with those finishing faster typically producing programs that worked better. So by any reasonable measure, at least 10x productivity. There is your 10x, right? Wrong. They found that the best predictor of programmer performance was the performance of another programmer at the same company. Furthermore they managed to correlate a lot of that performance factor to specific factors, such as having a phone that turned off, a private room, adequate desk space, and so on. There was still something like an unexplained factor of 3 left over, but they didn't know whether it was environment variables they had not looked at (eg training), individual ability (which might be correlated across institutions), etc. It is true that this research happened in the 80s, before the Internet was widespread. I would love to see it replicated again. (Note, I'm aware of the existence of many other poorly controlled studies, see http://www.flownet.com/gat/papers/lisp-java.pdf for an example, but what is critical in the Peopleware study is that they acquired information both about…

https://flownet.com/ron/papers/tla.pdf >In retrospect, in the story of the three-layer architecture there may be more to be learned about research methodology than about robot control architectures. For many years the field was bogged down in the assumption that planning was sufficient for generating intelligent behavior in situated agents. That it is not sufficient clearly does not justify the conclusion that planning is therefore unnecessary. A lot of effort has been spent defending both of these extreme positions. Some of this passion may be the result of a hidden conviction on the part of AI researchers that at the root of intelligence lies a single, simple, elegant mechanism. But if, as seems likely, there is no One True Architecture, and intelligence relies on a hodgepodge of techniques, then the three-layer architecture offers itself as a way to help organize the mess.

That'd be this one: https://flownet.com/gat/jpl-lisp.html Or possibly this one: https://corecursive.com/lisp-in-space-with-ron-garret/ I think he's written about it in a few other places, too, but I'm not sure where.

> I would even make a stronger claim: People decide to use popular technologies because it makes them happy, and this happens far more often in load-bearing situations than the Obscure Weekend Technologists do. Furthermore, popularity serves as a sort of immunity to further technical inquiry Spot on. Could not have articulated it better if I tried. I'll add a data point though: https://flownet.com/gat/jpl-lisp.html From description AND observed results, this is a case where a team was successful in a challenging situation with lisp and then failed to deliver, first with c++, then java - the indistry-standard languages of the day.

Looks different than Ciel, another Lisp from 2010 (https://pldb.io/concepts/ciel.html), by Ron Garret, rocket scientist (https://flownet.com/ron/).

> The Google chapter of "Lisping at JPL" (https://flownet.com/gat/jpl-lisp.html) may be what you are remembering. That's close, but I think it's reflection of the same policy, not the same article. The article I remember talked about more languages that just Lisp, Smalltalk, and Java. It was overall down on Java, but had positive things to say about some Java programmers.

The Google chapter of "Lisping at JPL" (https://flownet.com/gat/jpl-lisp.html) may be what you are remembering.

Time to again link to "The Rise and Fall of Lisp at the Jet Propulsion Lab" (2002) https://flownet.com/gat/jpl-lisp.html

This history is also discussed in an essay by Garrett[0]. And there's been a few previous HN posts about it[1]. (I'm not suggesting the parent post is a dupe, but people might be interested in the essay and related contents). [0] https://flownet.com/gat/jpl-lisp.html [1] https://hn.algolia.com/?dateRange=all&page=0&prefix=false&…

Said "software on satellite" story is from Ron Garret, for anyone interested. https://flownet.com/gat/jpl-lisp.html > During that time we were able to debug and fix a race condition that had not shown up during ground testing. (Debugging a program running on a $100M piece of hardware that is 100 million miles away is an interesting experience. Having a read-eval-print loop running on the spacecraft proved invaluable in finding and fixing the problem.

This is blogspam, the original is still hosted here by the author himself: https://flownet.com/gat/jpl-lisp.html

Here's another account of the same story: https://flownet.com/gat/jpl-lisp.html Ron Garret (https://news.ycombinator.com/user?id=lisper) is a frequent contributor on HN.

If you're interested in his stories regarding Google and AdWords (not AdSense), check out https://flownet.com/ron/xooglers.html

Thank you for sharing your stories. I have (re-)read "Lisping at JPL" [0] dozens of times! What are you up to nowadays? [0] https://flownet.com/gat/jpl-lisp.html

In longrunning/high-availability applications, this sort of thing is necessary in order to avoid restarting and losing uptime or state. E.G. per nasa: > The Remote Agent software, running on a custom port of Harlequin Common Lisp, flew aboard Deep Space 1 (DS1), the first mission of NASA's New Millennium program. Remote Agent controlled DS1 for two days in May of 1999. During that time we were able to debug and fix a race condition that had not shown up during ground testing. (Debugging a program running on a $100M piece of hardware that is 100 million miles away is an interesting experience. Having a read-eval-print loop running on the spacecraft proved invaluable in finding and fixing the problem (from https://flownet.com/gat/jpl-lisp.html)