--- layout: ../Site.layout.js --- # My `eepitch-send`, actions and the situation calculus Here I am going to explain my discoveries of why [eev](https://anggtwu.net/#eev) [eepitch](https://anggtwu.net/eepitch.html), and my common lisp useage,`e-e-v` and `eepitch-send` (defined here) are so revolutionary, and why in hindsight this was wellknown by Erik Sandewall to be important and fundamental. We also look at what actions are, and the user's (programmer's) relationship to actions. Actions are best related to changing situations and the situation calculus. By the way, this is the basis for my upcoming emacsconf 2025 talk/Q&A (see their [call for talks](https://emacsconf.org/2025/)). ## eev eepitch emacs and my common lisp `eepitch-send` Let us recall that *eev-mode* helpfully eclipses other emacs useage with a small number of effective idiomatic controls. Viz *actions* the key one is *eepitch*: when your cursor is near some code you want to happen in a document you are reading or writing, you press the *F8* button on your keyboard. Then, unpiloted by you, emacs pops up a buffer on one side of your emacs window - the current eepitch target buffer, types the code you pressed *F8* at into it, and then sends the typed code to the buffer as well, all while leaving you and your cursor on the other part of the screen in the document you were reading or writing yourself. Eepitch pitches *red-star-lines* to the environment itself (emacs lisp) and other lines to whatever `eepitch-buffer-name` is ('red star' is typed in emacs eev as `C-q C-o`). By way of illustration ```  (setq inferior-lisp-program "ecl") ; press F8 ^ red star line gets pitched to emacs ; don't press F8 on this line  (slime) ; press F8 ^ red star line gets pitched to emacs ; don't press F8 on this line  (setq eepitch-buffer-name "*slime-repl ECL*") ; press F8 ^ red star line gets pitched to emacs (what my buffer was named) ; don't press F8 on this line (get-decoded-time) ; press F8 ^ Seen happening on the other half of this buffer ; don't press F8 on this line / ; press F8 ^ Seen happening on the other half of this buffer. ; don't press F8 on this line ``` If you weren't playing along here's what is on the other half of my screen as I write this right now: ``` ; SLIME 2.29.1 CL-USER> (get-decoded-time) 37 18 12 12 7 2025 5 NIL -12 CL-USER> / (37 18 12 12 7 2025 5 NIL -12) CL-USER> ``` Note that [ANSI CL's `/ // /// * ** *** + ++ +++` are exceptionally powerful](https://www.lispworks.com/documentation/HyperSpec/Body/25_aa.htm) with this useage (lists of last multiple returned values, recent first return values, recent commands). Eepitch makes it very clear that the user is interactively choosing and pitching intended actions to other inhabitants of their interactive programming environment (their emacs environment) in the midst of other reading/writing/browsing/whatever engagements. ### My `eepitch-send` and eev emacs as part of kernelspace [Sandewall sets about to remand this useage of actions and down into the kernel](https://codeberg.org/tfw/pawn-75/src/branch/main/unsrt/caisor-2005-014.pdf) (viz [the bibliography here](/complex/Sandewall-caisor-bibliography/)). I guess it has been said before that emacs is actually the operating system. Then as a user I should not be sitting inside kernelspace pitching commands upwards, but in userland (i.e. in a running program) pitching commands downwards into the my kernelspace (emacs eev), which provides the low level machinery for them (uniformly, for everyone, and with syncronicity implicitly managed). Let us create emacs-lisp `eepitch-send` and [common lisp swank](https://slime.common-lisp.dev/doc/html/Lisp_002dside.html#Lisp_002dside) `e-e-s` for lisp images to pitch down into the emacs abyss via swank. (Common lisp and its antecedents have had functionalities that Microsoft's "LSP" is a copy of some of in various forms for almost a century - anyway, it's common for a lisp image to serve a swank server and for multiple swank servers to be [slime-connected](https://slime.common-lisp.dev/doc/html/) to a shared [emacs server](https://www.gnu.org/software/emacs/manual/html_node/emacs/Emacs-Server.html) as we are about to see). I composed `eepitch-send` and `e-e-s` [here](/complex/eepitch-send/) I'm actually going to use [ielm-mode](https://irreal.org/blog/?p=11275) for emacs lisp here. ielm is sort of like a slime for emacs lisp. ```  (ielm)  (setq eepitch-buffer-name "*ielm*") (defun eepitch-send (buffername line) (setq eepitch-buffer-name buffername) (setq line (eepitch-preprocess-line line)) (eepitch-prepare) (eepitch-line line)) and back over to common lisp  (setq eepitch-buffer-name "*slime-repl ECL*") (require "asdf") (defun e-e-s (buffername expr) "'external-eepitch-send' buffername string (emacs buffer name string) line string (as eepitch) " (require "asdf") (uiop:launch-program (let ((*print-pretty* nil)) (format nil "emacsclient --eval '(eepitch-send ~s \\"~s\\")'" buffername expr))))  (server-start) ``` We use [Barlow's `uiop`](https://asdf.common-lisp.dev/uiop.html) posix-compatibility and start emacs' own server to send our pitches into it from outside in a posix way provided by emacs' emacsclient. So the `e-e-s` in the common lisp image asyncronously asks emacs `emacsclient` to call `eepitch-send` a lisp expression using emacs lisp. We can see this funny circular useage: ```  (setq eepitch-buffer-name "*slime-repl ECL*") (e-e-s "*slime-repl ECL*" '(1+ 1)) ``` On the other half of my screen, I saw: ``` E-E-S CL-USER> (e-e-s "*slime-repl ECL*" '(1+ 1)) # CL-USER> (1+ 1) 2 CL-USER> ``` # The situation calculus In situation calculus, a situation *s0* (ess-zero) connects to situation *s1* via an *action*. An action whose precondition is met's postcondition is a change to the value of a *fluent*, and leaves us in a different situation. What a situation is is not further defined. We can see that the users (us) are not in general doing the action ourself: Our proximal contribution was indicating our choice of an action to be sent into kernelspace, as we have defined it. # Conclusion Hopefully I showed that emacs eev eepitch is coincident to Sandewall's goal to reimagine actions and environments (eepitches and the emacs environment here) as the kernelspace and not the userland because they are not endemically high level, and moving them to a low level provides a uniform meaning to actions, action being the sitcalc concept. # Fin. See everyone [on the Mastodon](https://gamerplus.org/@screwlisp/114838153881404348) to talk about it (and at [Emacsconf 2025](https://sachachua.com/blog/2025/06/2025-06-30-emacs-news/) to hear about it!). By the way, I am interviewing [LambdaCalculus](https://masto.hackers.town/@lambdacalculus) next week on [the lispy gopher climate](https://communitymedia.video/c/screwtape_channel/videos) where we will get a preview of his [HOPE](https://hope.net/) and [PhreakNIC](https://phreaknic.info/) presentations. I think the arc of lisp history this article is part of, closely tied to righteous dissatisfaction with how unixlike userland and kernelspace got divvied up for high tech (such as lisp community) useages, is *even more* important now than when Sandewall wrote > we propose to change the overall software architecture (operating systems, programming languages, etc etc) in order to eliminate the considerable redundancy of concepts and constructs that contemporary software exhibits in 2005. ASIDE: By the way, Sandewall explicitly sees these changes as moving towards Interlisp D Machines. Though of course we can experience Interlisp Medley directly both natively and [in a javascript virtual machine right now, can't we](https://online.interlisp.org/).