See: Vehicles Overview, Fear, Aggression, Love

Making some cybernetic, organismic machine animal simulations using Quil and Clojurescript.

The most canonical Braitenberg vehicles. 2 sensors, 2 motors, ray sources in the environment and different wiring make different behaviour.

I will deploy this soon.

Life coding Emacs, Clojure, Meow, screencast, programming, cybernetics, code, animals, bio computing, braitenberg, vehicles, love, fear, aggression, explore, system theory, control theory, simulation, toy, fun, little animals

Probably way too lengthy. You can watch how I spent last Saturday :)

The fruits of Clojure I

Making a knowledge base database keyword extractor with open ai chat api.

https://www.youtube.com/watch?v=GcJgGy-dfvE

Primagen was recently checking out Uncle Bobs Clojure post, which did not mention the most important thing about Clojure. Interactive Programming is the big magic word my friends.

Related: Interactive Programming and Lisp overview.

#_(add-libs '{net.clojars.wkok/openai-clojure {:mvn/version "0.9.0"}})
(ns scratch
  (:require
   [clojure.java.io :as io]
   [clojure.set :as set]
   [clojure.string :as str]
   [clojure.java.shell :as shell]
   [wkok.openai-clojure.api :as api]))

(def api-key (memoize (fn []
                        (str/trim (:out (shell/sh "pass" "private"))))))

(defn make-chat-completion [messages]
  (api/create-chat-completion {:model "gpt-3.5-turbo-16k"  :messages messages}
                              {:api-key (api-key)}))

(defn resp->message [resp] (-> resp :choices peek :message :content))

(def extract-keywords!
  (memoize
   (fn [file]
     (-> (make-chat-completion
          [{:role "system"
            :content
            "Extract the most interesting, essential keywords from the text.\n\nYou output edn vector format.\n\nExample: [\"AGI\" \"Timeline\"]"}
           {:role "user" :content "Doc:"}
           {:role "user" :content (slurp file)}])
         resp->message
         read-string))))

(defn query [db key]
  (get db key))

(defn assert-keywords [db file extracted-words]
  (reduce (fn [res e] (update res e (fnil conj #{}) file)) db extracted-words))

(def the-db (let [db {}
                  kws (for
                          [file ["/home/benj/notes/20230126T094804--the-joy-of-clojure__clojure_code.org"
                                 "/home/benj/notes/20230707T090418--conversation-1__clojure.org"]]
                          {:file file :keywords (extract-keywords! file)})]
              (reduce (fn [db {:keys [file keywords]}] (assert-keywords db file keywords)) db kws)))

(comment
  (spit "the-knowledge-db.edn" (prn-str the-db))
  (read-string (slurp "the-knowledge-db.edn"))

  (->
   (assert-keywords {} "foo" #{:a :b})
   (assert-keywords "foo2" #{:a :c})
   (query :c)))

Keywords: Emacs, Lispy, emacs lisp, livecode, screencast, how to emacs, Clojure, REPL, showcase, openai api, chat gpt, programming, code editor

As answwer to this cider issue on github.

;; jack-in-cmd allows you full control over the command that starts the nrepl server process

(defun my-cider-jack-in-prompt-cmd (jack-in-cmd)
  (interactive "sJack in cmd: ")
  (cider-jack-in-clj
   (list :jack-in-cmd jack-in-cmd)))


;; I personally like to def a jack in function in elisp which I have somewhere,
;; for instance the readme of my project or dev.el

(defun ftlm-vehicles-make-nbb-nrepl-jack-in ()
  (interactive)
  (cider-jack-in-clj
   '(:jack-in-cmd "npx nbb nrepl-server"
                  :project-dir "/home/benj/repos/clojure/vehicles/")))

Keywords: Emacs, Lispy, emacs lisp, livecode, screencast, linux, rice, productivity, scripting, programming, Clojure, Cider, Clojurescript, Nbb, Babashka

A frequently asked question when using Lispy is how do I insert single brackets, quotes, parens?

The answer is quoted-insert, wich is bound to C-q by default.

It reads the next character and inserts it, bypassing your current keymap and such.

Keywords: Emacs, Lispy, emacs lisp, livecode, screencast, how to emacs, how to lispy, lispy tips, emacs tips

Real world show case repl into production. This is the kind of thing where Lisp delivers.

Keywords: Emacs, stumpw, arch, Clojure, Datomic Cloud, AWS, EC2, discord bot, REPL, production, fun with computers

• Start nrepl on your prod server in some way. s. https://nrepl.org/nrepl/usage/server.html

(let [server (nrepl/start-server
                :port 7000
                :bind "0.0.0.0"
                :middleware cider.nrepl/cider-middleware
                :handler cider.nrepl/cider-nrepl-handler)]
    (reset! nrepl-server server))

Now we want to make an ssh tunnel to this machine to port 7000 on the server machine

~/.ssh/config

Host support-bot-ec2
     HostName ec2-18-212-83-183.compute-1.amazonaws.com
     User ec2-user
     IdentityFile /home/benj/.ssh/ben-ec2-key-pair.pem
     LocalForward 7000 ec2-18-212-83-183.compute-1.amazonaws.com:7000

blazingly fast cider overlays and how I got them.

keywords: Emacs, performance, programming, fun, cider, clojure, eval, ovelays, fast, quick, zappy, blazingly fast

Bobscheme page.

Now I made a thumpnail, woar!

I also figured out that I can share -> embed on youtube. Then the iframe works (see above link).

Adding a google drive list feature to my Clojure, Scittle, Reagent, Reitit app.

Real life Clojure programming. REPL-driven development. Emacs, meow, lispy, Clojure, Clojurescript.

• Complete Flip Coin Website 1.5 hours
• More Scittle livecode
• Emacs bash-completion
• dired-guess-shell-command
• Lispy Eval Other Window in the context of some cider command
• https://www.youtube.com/@faster-than-light-memes/videos

• Show practical Lisp and Clojure programming, with Emacs
• Show Emacs

I want to get good at explaining and showcasing what it means to program Clojure. What is repl-driven development, how to do it and how it presents itself to the mind? (its look and feel).

For instance,

• evaluating little forms every 10 seconds.
• Tricks like inline defs
• Impressive stuff like live coding a whole app.

Currently, I still try out stuff and need to get over the initial awkwardness of making videos.

I realized I have a completely different communication style when I present vs. when I try to develop. One of the next things to try is to actually present in a video. And then slowly bringing in more live coding maybe.

• The Primagen
• System Crafters

Generally, you do not want to make keybindings to anonymous lambdas. Here is the primary reason that comes to mind:

(describe-keymap
 (let ((m (make-sparse-keymap)))
   (define-key m (kbd "f") (lambda () (interactive) 'hi))
   m))

I get help buffer with this content:

Key             Binding
f		[closure]

It is not really useful to just get the info [closure] here.

Alias your function:

(defalias 'foo-a (lambda () (interactive) 'hi))
 (describe-keymap
  (let ((m (make-sparse-keymap)))
    (define-key m (kbd "f") 'foo-a)
    (define-key m (kbd "b") (defalias 'foo-b (lambda () (interactive) 'hi2)))
   m))

Key             Binding
b		foo-b
f		foo-a

Foo-b works because defalias returns the symbol.

I end up just using defun inline. Examples:

(add-hook
 'sh-mode-hook
 (defun mm/add-bash-completion () ...))

(mememacs/leader-def
  "pP" (defun mm/project-switch-project-find-file ()
         (interactive) ...))

After writing this post, I went and fixed the remaining add-hook lambas In my config.

I was wondering about what is cool for a newcomer to coding. I love lisp and I think one of the real joys in programming is interactive programming. So if I find some way of communicating this magic, that would be great.

After my binaural beats adventure I feel like Scittle is an amazing tool so I want to try it on something bigger. So I had this idea of a Scittle website that prints its source code, then you update the code and get an immediate effect.

I wanted this to be my website so maybe a new team member can also go into the code and hack around.

1. print your source code
2. ability to update code
3. no code editor in the browser (input field…) I am thinking getting this approximately non-clunky would be hard. Especially balancing the parens. I decided to go with a drag and drop area where you slurp in a file into the browser.
4. This is not a Quine because it receives the source code as input

I do some StackOverflow-driven development for a drag-and-drop area.

I needed to figure out how ondragover Event and friends translate with hiccup. Luckily the legendary question answerer @p-himik helped me out in the #clojurescript slack channel. Turns out that when I add :on-drag-over in the attribute map it works.

(ns main
  (:require
   [reagent.core :as r]
   [reagent.dom :as rdom]))

(defonce state (r/atom {:code-text ""}))

(defn drop-area []
  [:div#drop-area
   {:style {:margin-top "1rem"
            :height "10rem"
            :width "10rem"
            :background "Aquamarine"}
    :on-drag-enter
    (fn [event]
      (set! (.. (js/document.getElementById "drop-area") -style -background) "cyan"))
    :on-drag-exit
    (fn [event]
      (set! (.. (js/document.getElementById "drop-area") -style -background) "Aquamarine"))
    :on-drag-over
    (fn [event]
      (doto
          event
          .stopPropagation
         .preventDefault)
      (set! (.. event -dataTransfer -dropEffect) "copy"))
    :on-drop (fn [event]
      (doto
          event
          .stopPropagation
          .preventDefault)
      (let [file (->  (.. event -dataTransfer -files) first)]
        (->
         (.text file)
         (.then
          (fn [t] (swap! state assoc :code-text t)))))
      (set! (.. (js/document.getElementById "drop-area") -style -background) "Aquamarine"))}
   [:div
    {:style {:margin "1rem"
             :padding-top "2.5rem"}}
    "drop a file here"]])

(defn code-snippet []
  [:div
   {:style {:background "gainsboro"}}
   (:code-text @state)])

(defn my-component []
  [:div
   [drop-area]
   [code-snippet]])

(rdom/render [my-component] (.getElementById js/document "app"))

(comment
  (swap! state assoc :code-text "foi110"))

With this, I have a drop area for a file.

Wonderful thing: Updating state redraws the UI for us.

Evaluating (swap! state assoc :code-text "foi110") makes reagent 's magic take effect.

I also want to show the default code on the first load. After some StackOverflow research, I determine fetch should work.

(->
 (js/fetch "main.cljs")
 (.then (fn [x] (.text x)))
 (.then (fn [x] (swap! state assoc :code-text x))))

At this point my website looks like this:

I want to do something where at least the white space is rendered.

After searching the web, I decide I need a <pre> tag to say it is preformatted. Also <code> sounds great.

(defn code-snippet []
  [:div
   {:style {:background "gainsboro"}}
   [:pre
    [:code
     (:code-text @state)]]])

Update the function, re-eval the rdom/render form. Boom I instantly look at my updated visuals. With cider, I can also call cider-eval-buffer, or cider-eval-file. I first had the background style inside the code tag, which did not have the look I wanted. I can hack on a piece of UI in isolation. Directly. Without any mental suspension time. It is great. It is how all coding should be.

Now for the magic of updating the website with whatever you upload. First, I ask Borkdude on slack how to evaluate a string. -> You use load-string.

(load-string
 (prn-str '(js/console.log "hello")))

Says hello in the console.

I update my file drop handler with the side effect of loading the text:

(fn [t]
 (load-string l)
 (swap! state assoc :code-text t))

(Yes there is a syntax error in this snippet).

I add this to the bottom of the file to see if my code is evaluated:

(js/console.log "hello2")

Now loading silently fails when I upload my file, but the text updates.

So I evaluate this in isolation:

(load-string (@state :code-text))

Ah, I get an analyzer error about l not being defined or something.

I update my handler like this:

(try
 (load-string t)
 (swap! state assoc :code-text t)
 (catch js/Error _ (js/alert "That code does not work.")))

following Stew Halloway's example of binary error feedback. Either there is an error, or there is no error. Error messages are just bloat anyway.

console says:

hello2

Another piece in place, another hit of dopamine, wonderful coding moments.

I update the fetch code like so:

(or
 (:code-text @state)
 (->
  (js/fetch "main.cljs")
  (.then (fn [x] (.text x)))
  (.then (fn [x] (swap! state assoc :code-text x)))))

I can do this because in Clojure everything is an expression and I can put expressions anywhere.

I want something on the eyes so I change the style of the drop area:

{:margin-top "1rem"
 :height "5rem"
 :width "5rem"
 :background "magenta"}

Drag and drop, and:

In emacs: list-colors-display, nice. And drag and drop with dragon.

This contraption of course pales in comparison to having a REPL running. But the idea is that it is might useful to somebody that doesn't even know what a REPL is. And if you are a beginner and now you wonder what that REPL thing is. Here I try to make a list of how to get a dev setup.

Here is an idea I had and did not put into the initial version: Make an undo button. So that the user can go back in the history of the website

An arguably more mature version of this is up on codepen.

A key difference is that my website prints its whole code. No machinery is hidden anywhere.

If I may say so I think this is cute.

Here it is:

https://github.com/benjamin-asdf/dotfiles/blob/master/mememacs/.emacs-mememacs.d/lisp/visual.el

Back then I knew of some subreddit full of magical mindscapes or something. I forgot.

I picked one I liked and started picking colors from there.

The principles of the mememacs-visuals theme are:

• Magic fruit in a dark forest.

I modify the x key repeat rate to the maximum.

Oh boi, once you have this you will not go back. See: A System Like Water.

A frequently asked question when using Lispy is how do I insert single brackets, quotes, and parens?

The answer is quoted-insert, which is bound to C-q by default.

It reads the next character and inserts it, bypassing your current keymap and such.

Repl-driven development is a philosophy and practice that focuses on using a REPL (Read-Eval-Print Loop) to interactively evaluate code snippets and see their results immediately.

The key is the whole language is always there and being able to make small experiments to the point where it meshes with your thinking.¹

A big part of the practice of Repl-driven development is something I am calling the Quick-Eval flow for this blog post.

1. Modify source code sexp
2. eval
3. Repeat

I want to optimize this practice. The speed of 1-2-3 can easily go below 5 seconds and everything is possible here.

1. By honing lispy² skills and juggling those sexps.
2. By smoothing out the edges of cider-eval.

This aspect of Repl-driven development, the Quick-Eval involves using the mind, the fingers, and the editor. It's like playing an instrument or learning a motor skill like juggling - it requires dedication and repetition to master the movements. But the beauty of this practice lies in the ability to customize the tool to fit your thought process, unlocking the limitless potential for effectiveness. Knowledge of the editor becomes a key to a world of endless detail, where you can continuously optimize speed, the expressivity of intent and precision. The goal then becomes programming at the speed of thought, making structural editing a superpower of the Clojure programming language. And with the power to shape Emacs into what you desire, the possibilities are truly endless.

Speed cubers deconstruct the minutia for their finger tricks. This means being explicit and thoughtful about what movements to do during the performance.

This blog post is about an aspect of 2, smoothing out cider-eval, by eliminating error popups.

The first time I saw a Clojure stack trace, I thought my computer is broken.³

(Ariel Alexa)

Alex Miller mentioned⁴ recently that Clojure error messages are designed to not include the stack trace by default.

A lot of these tools will automatically print the stack trace and the Clojure REPL never automatically prints stack traces […] It prints you like a 2 line error message. And you can ask for the stack trace if you want additional information. We intentionally don't show you that because usually most of that information is not useful to you.

Nice, sounds like less heavy error messages are something to try out!

Cider already has a minimalistic error feedback available:

(setq-default cider-show-error-buffer nil)

With this setting, we get a little overlay right next to our cursor when evaluating with error.

We achieve a more smoothed-out Quick-Eval flow.

The consistent presentation, regardless of the presence of errors, creates a smoother and more streamlined workflow. This helps keep the focus on the code and eliminates interruptions in the thought process.

My mind can stay in one place, focused on the code, without a wall of something was wrong disrupting my flow.

Ok *cider-error*, we can always stay friends.

I do not advocate throwing away the stack traces, at all. With REPL-driven development and Emacs we have the power to move fast, and decide to inspect the stack trace should we decide the info would be useful.

*e exists for inspecting stack traces. Also *cider-error* is still at our side, we still faithfully render our stack trace there.

A quick and precise pop lets us go to the error buffer when we decide to do so:

(defun mm/pop-cider-error ()
  (interactive)
  (if-let
      ((cider-error
        (get-buffer "*cider-error*")))
      (pop-to-buffer cider-error)
    (message
     "no cider error buffer")))

(define-key cider-mode-map (kbd "C-c E") #'mm/pop-cider-error)

There is also a cider buffer selection dispatch command:

(define-key cider-mode-map (kbd "C-c X") #'cider-selector)

cider-selector into x to bring up the error buffer.

With less auto-jumping, we move slowly and deliberately and call upon our tools when we decide to do so. In practice, this can mean we jump around at insane speed, but we do so controlled.

(setq-default cider-auto-jump-to-error nil)

Currently, if you interactively eval⁵ and you have a compile error, Cider jumps to the top of the file. This is because we do not track a file position during the eval and Clojure only sees a piece of string, not the file.

So the most important command, cider-eval, that I want to optimize for Quick-Eval, had a rough edge and now I smoothed it out.

Who invented that errors are red and angry?

(set-face-attribute
 'cider-error-overlay-face
 nil
 :background "DarkGreen"
 :foreground "white")

Now I have these green and peaceful boxes that don't make my heart rate go up.

Errors are the normal, correct behavior of my program, certainly in the context of developing. Sometimes I even eval just to check that there is an error. This is what repl-driven development gives us. And it should not feel like doing something wrong.

Currently, if you load a file and there is an error, there will be little feedback. The lack of an eval result in the echo area is signaling an error.

In Debugging with the Scientific Method, Stuart Halloway mentioned what I would be calling Red light, Green light error feedback. The system only indicates if something worked or not, but not what specifically went wrong.

A trick in emacs if you want text invisible is you set the foreground to the same color as the background:

(set-face-attribute
 'cider-error-overlay-face
 nil
 :background "DarkGreen"
 :foreground "DarkGreen")

I was still seeing the error in the echo area. So I did a quick (setf debug-on-message "nothing") and found cider--display-interactive-eval-result calls message.

The visibility of the message is controlled by cider-use-overlays.

(setq-default cider-use-overlays t)

Lol, now errors are just green blocks and I do not see the error message anywhere. If that is better than getting the error message I cannot say yet.

Clojure is a modern, functional lisp with a fiercely convinced community and production orientation.

I highly recommend Maria.Cloud, you can just go there and start coding. This is great for anybody that does not know yet x

If you try to do the same things in Clojure that you know from Javascript or Python, this will not work. Embrace Clojure is different. You should not be a vegan searching for good cheese. Use an avocado instead.

Get prepared for your journey as a pilot of an alien spaceship. As a beginner I suggest either

Clojure for the Brave and True

Meet nice people that are excited about the tech on slack. Seriously a lot of people hang there and answer beginner questions, everybody is welcome.

Carin is cool and has a funny picture of the emacs learning curve here: https://howistart.org/posts/clojure/1/

I like that they have a philosophy section mentioning Rich Hickey's talks this matters a lot to clojurians.

https://thoughtbot.com/blog/tips-for-clojure-beginners https://gist.github.com/yogthos/be323be0361c589570a6da4ccc85f58f https://www.clojurenewbieguide.com/

• The Joy Of Clojure
• So Many Parenthesis! (Chris Nuremberger's quick intro to Clojure)

• No Iterations
• Immutability is better
• Don't Brake Me, Man!
• The Sanity Game
• Calculations are sexy

When you start to feel the power of LISP, the feeling is so strong that it may overwhelm you. You may find yourself trembling with a strange sensation that you have never felt before. This is a common reaction among those who are just beginning to appreciate LISP. Some people call it "thrill", others call it "ecstasy". Whatever name you choose, it is a sign that you are becoming a true LISP hacker.

― llama2-70B

For me, the thrill of lisp happened when code started feeling like a substance below my fingers. When there was a place where I wanted to think thoughts and suddenly I was allowed to think thoughts at that place and have the program grow in whatever spot in the multidimensional cake that it is. It is an endless journey for the Lisp hacker to discover what it is, for it is the endless openness and malleability of ideas that is the nature of what makes Lisp.

Ideas are a great building material.

Programs are allowed to simply be. The arbitrary limitation of having to restart the program to make a change is a tragedy.

It is the spirit of C, to be close to the computer. A bare-metal language for expressing the very substance of the computer itself.

It is the spirit of Lisp, to be close to the ideas. It is an indispensable step to take, to have a program grow in the dynamic content of itself. No AI program will be an AI program if you need to restart it to make a change. For it would not be an evolving, dynamic, self-modifying thing. It is the moment when you are done with computer science and you can start doing thought science. This step was taken by McCarthy in 1960.

Lisp is different. You cannot know how it is different before you have tried it yourself because it's different in a way that you have to discover yourself. What is joy for the programmer's heart? To have effects on the computer, precise, straightforward, frictionless effects. If the expression intimacy to the computer does not make sense to you, it is because you have not experienced what it means to program a system with deep interactivity. See No Iterations.

Batch-oriented programming is 60 years out of date and we still have to deal with it. It is another example of the whole field of software engineering not growing up. Simply embarrassing.

Imagine interactive computing didn't become successful and dominant for accidental reasons. There would be people talking about terminals and overlapping windows and buttons and mice and instant feedback. These people would be seen as esoteric.

And real, serious programmers and computer people would stamp punch cards.

Nothing in the world says that we need to stamp punch cards to do computing. It is these kinds of limitations of thinking, that open-mindedness and imagination enable us to take a step back from.

It is merely accidents of history, that made C and its derivate became the mainstream. Sadly, the mainstream is sometimes wrong. And we end up having to deal with less powerful languages.

This is not a small issue. This is an opportunity cost of humanity not growing up to the potential already available. Consider the internet. And consider interactive ("personal") computing. Are these not 2 ideas that change the world? This is tech that shines like the sun and changes everything.

Literally from the same birthplace of ideas, the ARPA community and early computer science pioneers also came interactive programming. My claim is that it is as big of a deal as interactive computing and the internet, too.

Lisp is called the Maxwell Equations of computer science, because it was discovered as the simplest expression of computer programs. Lisp is said to be the only language which is beautiful. Lisps syntax exists for a single purpose, to be out of the way. Because Lisp is about ideas the way programming is about ideas. This is why it will stay relevant, the same way that Newtonian mechanics will stay relevant.

If you don't know Lisp, you don't know what power in a programming language is. You think that all languages are roughly the same power and I agree with you. The mainstream C derivate languages you tried all look equally powerful from my perspective, too.

Lisp is a more essential form of programming. To the point where I feel like batch-oriented programming is something else entirely. These are 2 activities, normal programming and batch-oriented programming. Batch-oriented programming is more like having a battle with the computer until it does what I want. Interactive programming, on the other hand, is a crafting process. It is like having a piece of wood and forming it under one's fingers. It is like having a brush and painting on a canvas. The relationship between the craftsperson and the art piece is 1:1 and direct. This is essential to an actual creative and artistic process.

These kinds of blind spots contribute to the coldness, number-oriented and low-level math-like activity, which is the dominant general population's view of programming. But it is not what the soul of the computer is about.

The soul of the computer is a malleable, joyful and open-ended well-spring of creative expression.

This is simply missing in all mainstream batch-oriented programming languages¹. You don't know what you don't know until you know what you didn't know.

Clojure is a Lisp implementation on the JVM with a strong focus on practicality. It was created by Rich Hickey, who is a software engineer, not an academic. Clojure is explicitly designed for general-purpose application development, allowing you to do everything you might do with Java or C++.

Lisp is capable, by design, of expressing programs that are about programs. Once you have a machine that is capable of being about ideas, you can have ideas about ideas. I think this is the fundamental universality of memes and ideas, which gives such a system an open future.

It is this open-ended future that mainstream languages are still missing to this day. They are bound to reinvent it, and by doing so will have implemented a Lisp.

Consider JSON, it comes from javascript being a scheme, a Lisp variant. The power of JSON is that you can abstractly talk about the content of your program. A program about lists and sets is more powerful than a program about customers and shopping carts. And everything nests, everything prints etc. Luckily, the lingua franca of our shared data has some of Lisp's sanity inside it.

The core idea of Lisp is that this content is the program itself. This is not a small wrinkle in the programming model. It's the move that gives it its open future.

Whenever somebody builds command interpreters of (JSON) data, they are implementing a Lisp (Greenspun tenth rule). Soon they will make interpreters that assert subroutines into their databases and they will slowly invent Lisp, 60 years after its discovery. I already wrote this language, it's called Bobscheme (see below).

The key to understanding Lisp is realizing that it's simply layers upon layers of abstraction. - Hal Abelson

Emacs is not just a text editor, it's an extension of your mind that's limited only by your imagination.

To appreciate Lisp and Emacs, one must unlearn the ordinary, and then relearn the extraordinary.

Lisp and Emacs have something in common – a deep, underlying assumption that the power of abstraction will conquer all problems. - Richard Stallman

Bobscheme is a scheme implementation on dotnet using JSON as code.

Its purpose is to make it obvious to non-lispers, who know what JSON is, to see what Lisp is.

And I have fun making screencasts of building my language.

Github

Everything is the way it is because it got that way.

Computer science is still in its infancy. We are still figuring out left and right how to do things and what it is about. There was a time when Assembly was unpopular. There was a time when structured programming, like C, was unpopular.²

One of my intellectual heroes is Marvin Minsky.

And in the early 1950s for the first time, computers got enough memory so there was actually room to store new programs in them and some pioneers started in 1954, 5, 6 started experiments where they actually wrote programs that wrote new programs that would then run.

And this led to the development of certain languages which were very good at… In which you could write programs that would write in the same language so they could keep changing.

There was a lot of progress and by 1960 we had 2 major languages that were good at modifying themselves.

Unfortunately, these languages were a little bit unfamiliar to people who did not see the great power of programs that could change themselves

And the world was overtaken by other terrible languages like the famous C language or Fortran or Algol and so forth.

Which became universally popular and in which it is almost impossible to write programs that change themself. That is just the parenthesis.

The bad drives out the good, whose law is it? Gresham's law.

In modern software practice, we see this. I can't understand why this 35-year-old language called Unix is suddenly popular.

But the only thing I can think of is that the other operating systems got filled with so much garbage in the intervening years that nobody can deal with that. And it is not that Unix is the latest thing it is the last fossil that has not completely dissolved from the past. So they are starting over and as far as I can see they are starting over to make the same mistakes.

Youtube

In Inadequate Equilibria, Eliezer Yudkowsky explains in a very eye-opening way why societies end up in inadequate equilibria, Nash equilibria that are worse than other potential, better Nash equilibria.

Using Lisp is an odd thing, so it doesn't fit with the idea of best industry practices. See Paul Graham's Revenge Of The Ners talking about exactly this dynamic.

If you look for the next program's language, all kinds of people are excited about this or that (usually new) language or framework. You hear left and right people making plausible claims about why x or y technology is great.

It is not clear that an ancient, magical programming language would also be the most powerful at winning in that market.

It would have some advantages sure, like actually doing something different. But this would also come at the cost of it looking a bit unfamiliar.

More history:

• Why Isn't Functional Programming the Norm? – Richard Feldman
• Object-Oriented Programming is Bad simply amazing video about how the current paradigm is not good.

1. Static types simply don't matter so much.
2. Static types are a tradeoff. I think those people ignore the effort and price they pay for having those types. There is a time and place where you want something made out of concrete. But for many things and many moments, I want to choose to have something more malleable. Lisp and Forth programs have been debugged while in space. Know the price you pay.
3. You get intermittent rewards from the types helping you now and then. The reward pattern of gambling addicts.
4. I have to grant it to the Haskellers, Elm, Roc and maybe Rust persons, that getting leverage from the compiler giving feedback sounds useful.

Datomic is a great database and it is written in Clojure. If somebody can write a database in a dynamic language, then what do you think you need types for?

It is something we have science on. Having a good night's sleep has a bigger effect on the amount of bugs you make compared to having static or not having static types. [which studies?]

Unless you are implementing a smart contract or something, it simply does not matter so much. There are way more powerful things a language can provide you.

Immutability, now here is somethihng that is self-evidently powerfully helping you to get programs right. Like the moon hanging in the sky. Static types? Its a belief system whether it helps you or not.

Interactivity, you know the difference between quick feedback and non-quick feedback. If you don't, I cannot take you seriously.

• Are the thoughts you think not more important than the syntax of a language?
• In Lisp, the verb is always at the front. Is the noun always at the front in Java?
• Not every change is an improvement, but every improvement is a change. How would it look if Lisp is different? How would it look if there is a reason to call it the only language that is beautiful?
• Show me a language that looks like all the others and call it special and I am suspicious. Show me a language that looks completely different (APL) and call it special and I am intrigued.
• Is it not true that we are children compared to the territory of things we don't know yet?
• Would it not be hybristic to think you know at this date and age what the syntax of a language should look like?
• Is it not the person, who has programmed in both languages, that can make the judgment: which is better?
• Is it not true that Vim bindings are unfamiliar but powerful?
• Is it not true that even git is unfamiliar but powerful?

Many things in the world that are powerful are also unfamiliar at first. Language is a tool of thought. A language is like an instrument. It is not in the first 5 minutes of engaging with it that you will know its power.

Maybe I was just lucky and I discovered Emacs and hence Lisp early enough, so it never was an issue to me that languages would look differently. I just took it for granted that some look differently. And I never was stuck with this strange mental illusion to think to know what languages are supposed to look like. How limiting?

The landscape of possible languages, even the ones we already are exploring is like a continent, where you know but one valley. Here are just a few completely different relatively popular programming paradigms and languages:

• Array-based languages: APL, J.
• Logic programming: prolog, datalog, core. logic.
• Stack-based languages: FORTH.
• Erlang (heritage from Prolog, Smalltalk, Planner). A lang with fault tolerance at the center. Sometimes said to be process-oriented.

It is sometimes said that Lisp has no syntax, which is not entirely true because the order of things has meaning. But there is another fundamental thing about Lisp syntax and the form of Lisp. It exists to be out of the way. Because the form barely matters, what matters is the content. McCarthy discovered Lisp's syntax accidentally, by just writing the AST of that hypothetical language in his paper.

So he deliberately was not thinking about the source code syntax but about the ideas. But it turns out that just talking about the ideas is a simpler and better way to program. Really funny.

Ah, and since structural editing is fucking awesome anyway you don't want to go back to something more complicated afterward.

One hears that interactivity is at the center of what Lisp is about and says:

Python has a REPL.

Yeah there are things like edit and continue in lang x.

When you make a project, is the first thing you do start a REPL and then not kill the process for days until your project is done?

When I come to your project, can I fire up a REPL and jump into the program?

When you want to look at your program's state in production, do you REPL in and simply see?

No, I don't think so. Because the interactivity was not at the center, not at all.

Programming also is a concrete thing, with concrete activities and cultures. You can do everything sort of in all general-purpose programming languages. What is practical is guided by this culture and practices. To ignore this is simply being a nerd for no good reason. It is pretending to care about essentials, but ignoring that in the real world, practicality is essential, too.

And the irony of the situation. The one is deluding themselves into the dreamland of those great Python REPL and edit and continue lands, where stuff works great and it's the normal way to do things.

Who is the one being unpractical, then?

http://www.paulgraham.com/avg.html

Learning multiple languages is virtually a must. To see what is different, and what is the same. Because what is the same is the soul of the computer. Well, at least it's data structures, algorithms, and control flow, and not that much more. And what is different are idioms and styles and culture and emphasis.

The one that has tried multiple mediocre mainstream languages will have a "mature" feel of the relative power of languages. And conclude it is simply a matter of taste. That all are roughly equally powerful.

Because there are many languages with devoted followers, there is a market of people saying this or that language is the best…. You stop taking these people seriously because you have understood that all languages are the same, and it depends on the context of which tool to choose.

Now the Lisp devotee pronounces the superiority of Lisp 100x and 10000x to other languages. And all it does is make your bullshit sensors fire. You have a mental model of the power of general-purpose languages.

Way more powerful than Assembly. Who would be so crazy as to give up all that expressivity for writing Assembly? It would be insane to program Assembly because the power difference between the mainstream high-level programming language and Assembly is so massive.

If I say Lisp is to those default langs like those default langs are to Assembly; Do you see maybe why it is such a big deal for me? It is insane to me to give up this power.

The point of this website is to increase the surface area of idea space association lines that make a person check out Lisp and understand why it is a different language entirely.

Lisp is different from what you consider "normal" languages the way a spaceship is different from a hot air balloon. Flying Lisp is simply a different activity, with a different range of spaces where you can go.

Here is an Answer for why.

What in the world needs to look different for this to be true? It's an ancient magical language made for AI, made by imaginative, brilliant people. It looks alien and it is said to have been discovered. It has been called the Maxwell equations of computer science and it has not changed ever. For if you change it, you simply end up with another dialect of it, because its ideas are at the bottom.

It is mentioned as the one language that changes your taste. That makes you understand what power means.

Programming is wizardry, but the magic is real. How sad, to not be excited enough about magic so you don't look into ancient lore of powerful alien technology.

https://www.marktarver.com/bipolar.html

This is an existential blog post, so my answer is existential, too.

Yes, culture is simply off.

But what do you gain from getting depressed and lethargic from that? For me, this is simply another call to action. Simply another edge for which there is still a challenge to overcome.

Reality is not a video game, where you only get challenges that you can live up to.

Reality is not a video game, where all the challenges you get are proper, not in any sense and not even a little.

If culture is off, you don't get to complain that if only people listened….

If only people listened, we would be exploring the stars many times over right now.

So either you put people into the navigation problem you are solving, or you are making yourself blind to the world. Like somebody that goes through the motions of making some mistake, chasing some unattainable appearance of what, consistency? Like somebody who was tricked into thinking reality is a video game, and when its challenges are unorthodox, they pretend to not get it.

If reality is posing you a challenge and don't you live up to it; You die.³ We either fix humanity, despite all its problems, or we die.⁴

If you go forth and you think getting a university degree is equal to navigating the world. You are making the mistake of being a blind video gamer. You pretend there is a pre-allocated set of challenges to overcome for you to contribute to the world. But then you realize that university is part of culture, just like anywhere else.

The problem is not culture, the problem is not the many people in science are in for their careers. The problem is not the uselessness of money. Or the uselessness of hanging out with friends just for the sake of it.

The problem is you mistook the open-ended set of solution spaces for fixing the world with this pre-defined list of things to do. And then the fakeness and uselessness of it all crushes you to the ground.

• Rich Hickey's YouTube talks
• Clojure for Java Programmers Part 1 - Rich Hickey
• Paul Graham, On Lisp
• Paul Graham, Hackers And Painters + his blog
• Bret Victor - Inventing on Principle
• Bret Victor The Future of Programming
• Marvin Minsky - The beauty of the Lisp language
• https://www.annualreviews.org/doi/abs/10.1146/annurev.cs.03.060188.001123

• Make a cider-eval-last-sexp after this form:

(repeatedly 10000 random-uuid)

• is it zappy, or not zappy?

The biggest gain - or pain, depending on how you want to think about it is the echo area message.

I set cider-use-overlays to t, not both.

(setq-default cider-use-overlays t)

Now we do not print the message anymore which is a night and day difference.

I still am not completely satisfied with those overlays. You might think that fontifying the string takes long but it seems like in my perf investigation that did not seem to be an issue. (Hence have cider-overlays-use-font-lock to t).

Here is the Code if you want.

Watch them go!

You can also click on the screen to move the temperature bubble and see the effect.

With this link you get a leva control panel to modify some paramaters.

Some of these (warning, link will open a tab with flashing lights) I was building while listening to the finest Berlin techno.

Cart number one has 1 motor 1 sensor and 1 connection.

Braitenberg asks us to imagine it having a little Brownian motion so it doesn't get stuck.

Otherwise, the sensor senses high temperature and makes the motor go. The motor moves it forward without rotating (this will change in vehicle 2). This animal then stays in areas of low temperature and moves away from high temperature.

I have to say this whole pond thing really went somewhere. My world is sort of this microscopic world of little animals, darting around and getting excited by some bubbles flying around.

They sort of have 2 modes, being indecisive and wobbling around a bit, or they dart around.

Trippy vehicle number 1 getting excited by disco bubbles, bouncing of walls and finding the few dark spots on the canvas.

They all fly away when you scroll the screen away right now but you can reload the page to get it back

—

The first part is an intro, then lengthy engineering, and in the end first version of the vehicle's number one microscopic animal bubble world:

Each Braitenberg vehicle is described by:

• env
• body
• sensors
• effectors
• brain (connections)

Body Is synomous with cart for my purposes. For now, my body is represented with this rounded rect. The body moves around, depending on the forces acting on it.

Let cart-1 be:

(defn cart-1
  [{:keys [pos scale rot color shinyness]}]
  (let [sensor (->sensor :top-middle)
        motor (->motor :bottom-middle)
        line (->connection sensor motor)
        body (assoc (->cart pos scale rot color)
                    :components (map :id [motor sensor])
                    :motors (map :id [motor])
                    :sensors (map :id [sensor])
                    ;; particle means it has brownian motion
                    :particle? true
                    ...)]
    [body sensor motor line]))

Sensors have an activation based on the env. I also gave it a modality ('Temparature' for now, light, smell etc. later).

Sensors are circles in my world.

The temperature sensor has the environment as a parameter and changes the activation of the sensor:

(defmulti update-sensor (fn [sensor _env] (:modality sensor)))

(defmethod update-sensor :temp
  [sensor env]
  (let [temp (->temp (position sensor) env)
        sensitivity 10
        activation (* sensitivity (max 0 temp))]
    (assoc sensor :activation activation)))

A body experiences "force" depending on its effectors. (effors == motors for the moment).

(defn update-body
  [cart state]
  (if-not (:cart? cart)
    cart
    (let [effectors (effectors cart state)]
      (-> cart
          (update :acceleration + (reduce + (map :activation effectors)))
          (assoc :angular-acceleration (reduce + (map effector->angular-acceleration effectors)))))))

Later, motors are not only :bottom-middle, but left and right. Thereby rotating the cart by their action.

The only thing missing to make it go is a connection between the sensor and the motor.

(defn ->connection
  ([a b] (->connection a b identity))
  ([a b f] {:source a :destination b :f f}))

An abstract connection in my world has a source, a destination and a transduce signal function f. I am happy I found the name source and destination for these. The Sender and receiver sounded like they were talking over the radio and some other ideas by GPT were controller and controlled or such. I did not want to limit my thinking towards either one of them being more important than the other.

So source and destination. Both sound so wonderfully important. Just right.

The meat of the signal transduction is transduce-signal.

(defn transduce-signal [destination source {:keys [f]}]
  (update destination :activation + (f (:activation source))))

With the current choices I made, the activation of the destination is updated accumulatively sort of. f is allowed to return a negative number, thereby making the connection inhibitory.

The difference between my model and a McCulloch-Pitts neuron is:

• f is allowed to be any function. Including shelling out or querying a database, not just weight. Both models allow the input functions to be excitatory or inhibitory.
• I don't have theta (θ), the threshold. My neurons are simply gradually activated.
• My activation is modeled as a number, activation. Allowed to be any number. In neurophysiology, this activation is encoded in the rate of the neuron firing.
• In a McCulloch-Pitts neuron, on the other hand, a neuron is either on or off.

I decided to draw the connection on the screen as a line.

Then I went and I gave all the entities with activation a color shine, depending on the activation.

(defn activation-shine
  [{:as entity :keys [activation shine]}]
  (if activation
    (let [shine (+ shine (* *dt* activation))]
      (assoc entity
        :shine shine
        :color (q/lerp-color (q/color 40 96 255 255)
                             (q/color 100 255 255)
                             (normalize-value-1 0 1 (Math/sin shine)))))
    entity))

It lerps the color between cyan and yellow. And it is faster when the activation is higher.

This, I have to say, turned out amazingly cute and gives my whole simulation its unique flair.

When a vehicle finds a high-temperature bubble, it starts blinking like crazy and moves straight away.

Check # 10 with really hot temp bubbles. Comes across like they completely vibrate from that!

Isn't there something deep about the honesty of this animal in a way? We see all its functioning, all its desires and purposes and its inner workings, its brain. Everything there is in the open.

Certain animals are coming to mind, namely cuttlefish and octopi. They have a special structure in their skin that makes them able to change color via muscle input.

A video: OCTOPUS Camouflage | Changes color, texture and shape.

This book is quite amazing: Other Minds: The Octopus, the Sea, and the Deep Origins of Consciousness.

Godfrey-Smith had this hypothesis, how cuttlefish are perfectly signaling their internal states, without any message. No communication because nobody is there to interpret. Because cuttlefish are colorblind themselves. Except when they camouflage or hypnotize prey I suppose.

brownians #20

The Brownian world is my first generative art algorithm toy simulation world.

Current code, art gallery.

I came across Tyler Hobbs and decided his stuff is really cool. I started skimming probability distributions for algorithmic artists and decided I needed Gaussian Bell curves in my algorithms.

When you do biology, biochemistry and these things, almost all relationships are expressed in normal distributions a.k.a bell curves. Or as overlapping bell curves from multiple factors. Say the height of plant genotype, the count of blood cells in a sample, and the reaction times of a human.

It only has 2 parameters, the mean and the standard-deviation.

With the mean, I move the curve left and right, with the std-deviation I make it taller or flatter. q/random-gaussian returns a Gaussian random number with a mean of 0 and standard deviation something - So the return values are between -1 and 1.

Quil:

(defn normal-distr [mean std-deviation]
  (+ mean (* std-deviation (q/random-gaussian))))

Probably way too lengthy. You can watch how I spent last Saturday :)

• Heart of Clojure 2019 - Sarah Groff Hennigh-Palermo - Raving Through the 90s with SVG and Clojurescript
• https://youtu.be/HbW5hCdJgjA?si=Fj6fqeF8OHJoEiBW
• Creative Computation – Jack Rusher
• Tyler Hobbs
• Karsten Schmidt

Why do I do 90 seconds burpees in the morning on most days?

I do this to touch my heart rate max and this has a reason.

By stretching the system to edges,

it becomes more flexible,

just quote( huberman)

How to use 100% of your brain.

I think this was like 10 years ago that people walked around claiming that we only use 5% of our brains or some garbage like this.

I guess all kinds of people have fun making claims about how the brain works. And because the brain is super intriguing by itself anything that has a brain in its explanation sounds like some intriguing insightful thing.

Either way, here are some ideas about taste and sensibilities:

Some ways of knowing are intuitive. How do we know what is good and what is bad? What is good design, and what is bad design?

Some of this is processed in the realm of feeling. Also called sensibilities, also called system 1, also called intuitions.

When a master is crafting a piece, they are using their sense of aesthetics and their taste, to judge and make decisions.

How could it be otherwise? For if they would not use the feeling part of their mind, they would not use their whole mind. And how could you achieve mastery without using the whole mind?⁴

Taste is an interface into the rest of our mind.

If you only used mainstream programming languages so far, you do not know yet what it means for a language to be beautiful.

If you don't know Lisp (or its variant, Scheme), you don't know what it means for a programming language to be powerful and elegant.

So you do not know yet that taste matters in knowing the power difference in programming languages.

This is why now I talk about taste in another realm that you already know about. Art, stories and explanations.

What makes one story better than another story? What makes one thinker's explanations better than another thinker's?

The answer is it fits your tastes. The answer is you think this is interesting and then there is more of that interesting stuff. The answer is it harmonizes with your mind in some way.

When I read a great story I sometimes think now there could be more of this stuff and then there is more of this stuff.⁵

With the greatest art, it can feel like that the artist was exploring the same space of ideas that I would explore. To the point where it is as if as a consumer of the art I am exploring parts of my psyche. Like landscapes that were already there, only to be wandered systematically. In reality, the artist was expressing something they find intriguing themselves. And either by overlap, by alikeness of mind or by them intuiting what I would like to experience, they created these substances to explore for me.

The best books do this with the story: I wish more of this would happen. I wish we would read a bit more of Harry's wizard classes.

The best video games do this with world, concepts and game mechanics.

I want to be as powerful as those mages. And then it delivers on making you powerful, as if by growing as a character.⁶

I want to see more of the magic system, different kinds of magic, powerful magic.⁷

Taste can express itself as a joyful, harmonious intrigue. Or as the feeling of gaining a deeper understanding of the world, or gaining more powerful ways to think and do things.

There is something deeply intimate in sharing what this innermost mischievous, childish aspect of our minds is up to. Maybe this is me being German but it feels like something to be ashamed of.

To explore one's taste is to acknowledge the kinds of things that one inner mischievous, childish, curious mind is intrigued by.

It is not easy to explain what makes the best stories and books. Usually, we say this is a great book. And we mean that a person's taste is extraordinarily powerfully intriguing. The qualities that make this intrigue are extremely hard to explain. A masterful piece of art is by definition the

What makes one programming language better than another programming language?

Well, what makes Harry Potter And The Methods Of Rationality a superbly sick book? What makes The Witcher 3 a superbly sick game? What makes The Pirates Of The Caribbean and The Man From The Earth superbly sick movies? What makes Emacs a superbly sick text editor?

The answer is that if you have good taste, you will know.

And this might not be easy to explain, the shortest possible explanation would be for the other person to experience what you have experienced.

Sometimes there is a hint of power or more ideas of the same stuff or of landscapes to explore and the art/book/story is delivering.

In the next sections, I explain what I think programming languages are for. In other words, what are the activities where it matters if you have one language or another?

The reason why Lisp is powerful, elegant and intriguing is not as profane as syntax. It is not the syntax, not the names of things, not the data structures, and not anything about the form at all. Lisp is together out there with you, thinking and building your program.

But you will only know by experiencing it.

The answer is it fits your tastes. The answer is sometimes it does what you expect.

Taste is private in a way

A programming language is a way to express yourself to the computer.

This is the flavor of intrigue and joy that Lisp provides me.

Lisp provides a honed experience of interacting with the computer. It is

It was created by hackers and is traditionally endorsed by hackers.⁸

Here is one attempt at conveying one reason at the hard of the cluster of reasons.

This is not here to convince you but to

• being lazy
• if you have to do less, you have the better language

• a programming language will have to be jugdet by what it does to your mind
• because the its purpose is to give your mind the capacity to express yourself to the computer

Programming is about ideas. It is about organizing, understanding, communicating imaginary entities of knowledge that explains both problems and solutions.

A programming language is a tool to express these ideas to the computer⁹, so that the ideas have an desired effect on computer process.

How hard is it to express myself to the computer? How close are my ideas and the resulting computer process? What is the process (me using the language), that makes the computer understand my ideas?

Language is merely a tool to make 1 affect the other. The hypothetical best language is one where there is an infinitely small barrier between my ideas and the computer process.

The hustle of the programmer is in the realm of ideas. They manipulate, create and transform the web of ideas.

Only as an annoying, grindy sub task do they need to write code in order to express these transformations of ideas to the computer. Hopefully, with a minimal loss of accuracy.

This includes thinking of counterfactuals, and thinking to make experiments. To see, if the system was this way, would the bug be there?.

Every programmer knows

Since you cannot know what you don't know

Not every change is an improvement, but every improvement is a change.

If there really is a language this much better

Clojure is generally said to bring back the fun in programming. ¹⁰

It is commonly suggested to young programmers to learn Lisp in order to expand their mind.¹¹. Consider the Perlis quote

A language that doesn't affect the way you think about programming, is not worth knowing.

There are a few reasons why

https://github.com/szermatt/emacs-bash-completion

(use-package bash-completion
  :config
  (bash-completion-setup)
  (setf bash-completion-use-separate-processes t)
  (defun bash-completion-capf-1 (bol)
    (bash-completion-dynamic-complete-nocomint (funcall bol) (point) t))
  (defun bash-completion-capf ()
    (bash-completion-capf-1 #'point-at-bol))
  (add-hook
   'sh-mode-hook
   (defun mm/add-bash-completion ()
     (add-hook 'completion-at-point-functions #'bash-completion-capf nil t))))

Afterwards, this should work for you: (I always try with git check...).

(read-shell-command "your command: ")

read-shell-command sets up a special keymap where tab now means completion-at-point.

read-from-minibuffer, 3thr arg

(read-from-minibuffer
"foo: "
nil
(let ((m (make-sparse-keymap)))
  (define-key m "f"
              (defun my-hi ()
                (interactive)
                (insert "lol")))
  m))

• async-shell-command, shell-command
• dired-do-async-shell-command, dired-do-shell-command
• compile

I use project.el to run async shell commands and compile in the project root.

Design is about splitting things apart.

1. Select a current dir, up to you. My main paths would be
   • consult-dir,
   • project-switch-project,
   • consult-buffer + bookmarks
2. Run async-shell-command or a friend of it.

  (setq async-shell-command-buffer 'new-buffer)

  (defun path-slug (dir)
    "Returns the initials of `dir`s path,
with the last part appended fully

Example:

(path-slug \"/foo/bar/hello\")
=> \"f/b/hello\" "
    (let* ((path (replace-regexp-in-string "\\." "" dir))
           (path (split-string path "/" t))
           (path-s (mapconcat
                    (lambda (it)
                      (cl-subseq it 0 1))
                    (nbutlast (copy-sequence path) 1)
                    "/"))
           (path-s (concat
                    path-s
                    "/"
                    (car (last path)))))
      path-s))

  (defun mm/put-command-in-async-buff-name (f &rest args)
    (let* ((path-s (if default-directory (path-slug default-directory) ""))
           (command (car args))
           (buffname (concat path-s " " command))
           (shell-command-buffer-name-async
            (format
             "*async-shell-command %s*"
             (string-trim
              (substring buffname 0 (min (length buffname) 50))))))
      (apply f args)))

  (advice-add 'shell-command :around #'mm/put-command-in-async-buff-name)

  (add-hook 'comint-mode-hook
            (defun mm/do-hack-dir-locals (&rest _)
              (hack-dir-local-variables-non-file-buffer)))

  ;; it logs a warning when you hack a local
  ;; Making process-environment buffer-local while locally let-bound!
  ;; It is sort of want I want though
  (advice-add #'start-process-shell-command :before #'mm/do-hack-dir-locals)

  (advice-add 'compile :filter-args
              (defun mm/always-use-comint-for-compile (args) `(,(car args) t)))

shell

(defun mm/with-current-window-buffer (f &rest args)
  (with-current-buffer
      (window-buffer (car (window-list)))
    (apply f args)))

(defun mm/shell-via-async-shell-command ()
  (let ((display-buffer-alist
         '((".*" display-buffer-same-window))))
    (async-shell-command shell-file-name)))

(advice-add #'mm/shell-via-async-shell-command :around #'mm/with-current-window-buffer)

(setf shell-kill-buffer-on-exit t)

(add-hook
 'shell-mode-hook
 (defun mm/shell-dont-mess-with-scroll-conservatively ()
   (setq-local scroll-conservatively 0)))

I invoke mm/shell-via-async-shell-command with a stumpwm keybinding. This is the only reason I need mm/with-current-window-buffer irrc.

• Bashing Is Better Than Extending, more in-depth on the same topic. But one of my earlier blog posts and too long.

Making shell commands is one of the great joys of emacs.

An advanced use case is that you want to set up a process environment for everything you do inside some project.

What I show here works for compile, shell-command, and even cider connections.

.dir-locals.el:

((nil
  .
  ((eval progn
         (make-local-variable 'process-environment)
         (setq process-environment
               (copy-sequence process-environment))
         (setenv "FOO" "hurr")))))

Yes, it is a bit convoluted but for a reason. We need to copy the list, else if somebody modifies the cdr locally, that would modify the global value. (In the case that FOO is an element in the list somewhere already).

The answer mentions setq-local. I tried that without success.

Shell-command and friends will inherit the process environmen. It pretty much just works.

By default, .dir-locals.el does not apply to buffers without file names. (When the local variable buffer-file-name is not set).

There is a function hack-dir-local-variables-non-file-buffer for this purpose. This is called by dired, also magit.

I usually start processes from either a (source) file buffer or dired.

When you make a change to your .dir-locals, call revert-buffer in whatever buffer you want to have the effect. It hacks the local variables again for the buffer.

Replicating information, and ideas are the real deal of what the universe is about.

The difference between humans and other animals is our ideas. Humanity is the memes, more than it is about the biological substrate carrying them.

It is the memes that allow us to go to the moon - In spite of our biology, not thanks to our biology.

David Deutsch has recently described his philosophy nicely on the Tim Ferriss Show.

As civilizations become more advanced, it is knowledge and ideas that are the driving force behind what happens in the universe.

Consider a meteor flying towards Earth. Newtonian physics predicts an impact. But because of civilization, it might be deflected.

Eventually, ideas will have the power to create, transform and destroy stars and galaxies.

Dawkins mentions the memes are currently still clumsily floating around in their primordial soup.

Once we start doing things like converting all reachable matter into computronium¹, it will be the descendants of our ideas that will shape the universe.

If we should find ways to go faster than light, the memes will spread faster than light through the universe.

The title of my blog is just a hopeful wish, that the axiological potential of humanity is greater by a factor of x because if you go faster than light you can reach more of the universe.

Of course, we, the memes, might figure out something more useful than populating the universe. Like making ourselves smaller and smaller or something.

Faster Than Light is just a phrase underlining the idea of potentially spreading in the universe.

Going faster than light or even spreading in the universe is not necessarily a goal - maximizing human flourishing is.

Why not think big? It's better than thinking small as far as I can see.

We are already influencing the long-term trajectory of civilization, regardless of whether we acknowledge it or not.

I say civilization is life. We currently have sciences that are largely defined by their methodologies and institutions with a different science for say organisms, computers and technology. You might then think that life is what biology studies, but it is not so true. Life is also ideas, artifacts, civilization and computers.

Life is the craziest thing in the universe and it just starting. And we have the opportunity to shape the next stage of life, civilization, and intelligence.

There are a few things that fall out of common sense in my opinion, invariants: Suffering and death are bad. Life is good. Progress is good because it allows for more life, creativity, beauty, harmony and joy.

1. This was true in the distant past. It was true when we were Cambrian fish.
2. What is true across the eons is likely to stay true in the coming eons.
3. You really cannot know what amount of beauty and joy lies on the other side of progress. Nobody was foreseeing Bach or The Witcher 3 when the first primates started living in trees.

Mid-term I want to work on a solarpunk utopian future, biasing the outcomes towards human flourishing and ushering in the singularity¹ quicker.

This is a future with many trees and clear skies. In cities full of innovative and harmonious people, gazing at the stars and building great things.

What is techno-optimism, chat gpt?

Techno-optimism is a worldview or attitude that technology can bring about positive outcomes and solving some of the world's most pressing problems. It is the belief that advances in technology will ultimately lead to a better world, and that technological progress will help humanity overcome many of its current challenges, such as poverty, disease, and environmental degradation.

Techno-optimists tend to be enthusiastic about emerging technologies, such as artificial intelligence, biotechnology, and renewable energy, and they see these technologies as powerful tools for solving social, economic, and environmental problems. They often believe that technology can enable greater productivity, efficiency, and innovation, and that it can ultimately lead to a more prosperous and sustainable society.

However, techno-optimism is not without its critics. Some argue that it can lead to an overreliance on technology and overlooking important social and ethical issues associated with technological progress. Others point out that technology can exacerbate existing inequalities and that it can also have unintended consequences that are difficult to anticipate.

chat gpt end

Those critics are not seeing the full picture. Maybe civilization optimism would be the better word anyway. Science, reason, and humanism are all part of the story.

The point is to understand how and why civilization and technology are useful for bringing about human flourishing and well-being. And to continue the already made advances. And to realize, historically, how precious our current situation is.

For the inequality thing. This is not at all how mobile phones, the internet and medical advances (penicillin anybody?) turn out to work. By the time technology works well and is cheap to make we can make it available to all humans. Humanism and progress give us the ethical framework to have equal opportunity etc. as a goal.

• Fix aging
• Fix other diseases

This means you get an indefinite biological substrate lifespan. This might be rather low-hanging fruit, see Livespan with Dr. David Sinclair. Consider that fixing aging fixes a lot of diseases at the same time. Being biologically young means you fend off diseases.

Also, the same kind of advances fixes autoimmune diseases, Alzheimer, and cancer. See also the work of Aubrey de Grey for intelligent reasoning on this.

Seriously, most web and mobile software only works so-so nowadays because of bloated software. Everything is bigger and more complicated than it needs to be. Reloading some app because it stops working is the norm. This garbage is not acceptable in my vision of the future.

Software is supposed to be focused, effective and competent.

The price we pay right now for bloated and uninspired software is insanely high. How many mental energy hours go into reloading some app that stops responding⁶? Seriously, this is a global humanitarian issue.

Another issue is something I call mind-suck software now. This is software that is highly designed and explicitly or implicitly informed by behavioral psychology. To draw our attention and suck our time. When I click on an app with a blue icon because it has a red dot in the corner, that is not merely my fault, not only my lack of self restrain. That is also the fault of the people that made this software in the first place. This is an ethical issue. Long term I hope we understand which kind of software is conducive to our well-being and which is sucking our minds. ⁷ Mind-suck software belongs in the trashbin of history.

Existing software that lets me feel the competence of the computer is Unix/Linux, FOSS tools, Git, Emacs, and non-bloated parts of the web like Wikipedia. We can do it right.

The phone is a completely opaque object to me, with virtually no power to reach into it and make it do what I want it to do. Instead, I need to hope app vendors come up with something I find useful.

One of my fears currently is that BCIs will inherit from the current mobile model of software delivery. I think this would delay the singularity by multiple years.

The issues are uninspired practices and a disregard for the wisdom of the early days of computing. Also, the focus on financial incentives breeds less ambitious projects.⁸

Also, if it is FOSS, it tends to become small and focused, if it is proprietory, it tends to become large and bloated.

All user interfaces could be more like Data Rabbit right now. Think of the difference in productivity across the whole world. People would not fight computers anymore but wield great tools of thinking.

For obvious reasons, any of those can help fix things on this list:

• AI, information technology, automation.
• Better computer interfaces (conversational, … ).
• Nanotech, material science.
• Biotech, BCIs, genetics.
• A science and engineering of processes, policy and government ⁹.
• Also infrastructure, networks¹⁰, internet connection, water and goods.

• Cheap, tasty, clean meat.
• Just higher-tech food production.
• Plants. Better plants. More effective plants. And plant-growing buildings.

Why is governmenting not more like engineering? Anyway, it is an unsolved problem for obvious reasons:

• lack of UBI, poverty
• lack of decisive climate safety action
• lack of world peace
• noise pollution
• users citizens need to bother with paperwork, tax stuff is not automated.

For starters something like mind-uploading. Where you have a mind backup inside a fault-tolerant system.

Medium-long-term we need to make sure earth is safe from meteors and gamma rays. Goes into super long-term. By becoming a civilization after the stars are gone, and surviving the death of the universe, a civ might ultimately decide the fate of the universe.

• The Singularity is Near Ray Kurzweil It is a truly seminal book. It makes you appreciate exponential processes and then it maps that to computers and biotechnology. Making you see the logic of how fast technology is growing crazy powerful and tiny.
• Yuval Noah Harari, together with Pinker and others an eminent thinker and proponent of civilization optimism.
• Steven Pinker Enlightenment: Now The Case for Reason, Science, Humanism, and Progress
• Jared Diamond Guns, Germs, and Steel. An eye-opening book about large-scale, big-picture thinking. How civilizations form. Science fiction without being science fiction. It tells you everything could be different.
• David Deutsch The Beginning of Infinity: Explanations That Transform the World Big history, big ideas. Connects scientific inquiry with how evolution works. Explains the power of good ideas, talks about beauty, ethics, the fate of the universe and all that with a red thread going through it. Perspective-creating. A continuation of The Selfish Gene in some ways.
• Engines of Creation: The Coming Era of Nanotechnology K. Eric Drexler. Drexler calmly and matter-of-factly explains how you can have a machine the size of a garage printing a car. The only thing needed is some advances in material science, no new physics is required.
• If you enjoy thinking about possible outcomes regarding AI, Max Tegmark, Life 3.0/. If you read nothing else from the book, the first chapter describing the fictional near-future secret group called the /Omegas is extremely thought-provoking. This is the idea of a small group of individuals controlling a super-intelligent AI, taking over the world and biasing for human flourishing.
• Superintelligence: Science or Fiction? | Elon Musk & Other Great Minds
• I don't fully know why but Richard Dawkins The Selfish Gene is more than an just eye-opener about how evolution works it is also an eye-opener about the power of thinking and common sense.
• David Sinclair on fixing aging https://www.lifespanpodcast.com/
• Aubrey de Grey, very vocal about how we need to overcome deathism, the idea that death is something to accept.
• Eliezer Yudkowsky has written about the ethics of progress, longevity and more. If anything in this post resonates with you and you have not read Harry Potter And The Methods of Rationality yet, seriously, I can advise doing that. I am not alone in saying this. The book covers topics on morality, fixing death, being a scientist, and the navigation problem of fixing the world.
• Isaac Assimovs The Last Question is somehow a good meme about the big-picture.

I have been practicing Wim Hof Method for years. It is a spiritual path of sorts.

There is this thing where you embrace being an animal, and animals are really hardcore man. Human animals plan, think and discover how to world works. The brain is the control hub of our inner physiology also. Getting in touch with your physiology is not mystical, and not reserved for a certain kind of person either. It is using the paths in your brain that evolved to do just that. ¹

To close the loop: The inner physiology is another part of the world. With its mechanics, story and places that can be discovered - and mastered to various degrees. Such is the human way, you are the animal

• uses thought
• likes stories
• makes sense of objects etc in the world

Where can you start? With the things you already have control over. Hence breathing techniques, stretching and cold exposure. Emphasize the in-breath over the out-breath and you are pumping adrenaline. The other way around and you get more relaxed. Cold exposure pumps dopamine, with a long arc. ² It makes the whole day awesome. A cold shower is already an achievement that sets you up for performance. Wim has mentioned somewhere on the free part of his app something about self-determination and having "the cold as a teacher". An upsight clicked clicked in me that will try to share here.

There is a reason we make hello world programs. We learn in the small what is similar for the large.

Say Wim Hof is right and self-determination is a mental thing I can grab How do I learn to do so? Also importantly, how do you even know you are doing it? Enter cold showers ("The cold is our teacher"). It is hard to kill yourself with a cold shower, yet it takes mental energy to go into one and to stay. It gives you a chance to be determined in a small, controlled, safe environment. You manage to endure a wall of physical discomfort, you are doing it. This is what determination is.

just do it

In the lore of Wim-hoffing, you keep a calm mind and observe yourself being able to do it.

You are deploying the mental capacities that you might call determination.

The cold shower is the playground that allows you to see how it is to be determined. You observe the mentality, the mechanics, the feel, the drive, the just doing it. What you are when you are being determined. This then, shows you how to be determined elsewhere. The cold is not an end goal, it is a simple, easy playground where we can test how it is to be determined. This also means we have a benchmark for whether we are deploying determination, or not.

To learn something you need some way of telling whether you are doing it right.

I connect this to an experience I had while I was learning to juggle. There was a moment when I was doing 1 or 2 balls when I realized: here is a limit, a place where I can invest in training and I will get better and build a foundation and eventually be able to juggle. (I was right).

The only place where you can grow is at the edge.

Professor Huberman is since recently one of the great science communicators of our time. About physiology, neuroscience and (my words) frankly, the human soul.

Transcript from a recent Q&A event (you can find it on the Huberman lab podcast feed):

If you want to get the most out of the cold exposure then you want to get to that point of "I want to get out of here, but I know I can stay in safely, but I really want to get out of here".

It's a little hard to explain, but there is just so much learning in those short moments about where your mind goes. And this sounds subjective and maybe a little whishy-washy. You can realize great things about yourself in those moments. You can find insight in those moments.

I agree. I call this learning how to be determined.

I can recommend the Wim hof app to get started. There is a diary thing where you start with 10-second cold showers after a warm shower etc.

Tip: if you have a dispatchable shower head, put it in your hand and move it around. Cold exposure is all about control. If you have the shower head in your hand, you gain control.

You accidentally hit some key, and something unexpected happens. view-lossage is your friend. It shows the last keys + commands.

It is like the morning-after pill version of describe-key.

story: I sometimes accidentally hit y before typing the text for an avy command.

Every time I was like "Holy cow whatever I hit there is powerful". ²

I didn't know about view-lossage. The thing is, it would not have helped, because avy is reading the key, then dispatching on the key. I guess it needs to go through the keymap system or something to show up in view-lossage.

This helps me about once per year.

It is extremely satisfying when you use this and it helps you. I once figured out about revert-buffer-function by using it.

You can revert shell-command buffers to rerun the command but I did not know by which principle.

apropos-value, then typing my shell command showed me there was a buffer-local variable called revert-buffer-function. It worked because Elisp closure objects print with their environment. In other words, the value of revert-buffer-function was a lambda that printed with my shell command. It is quite wild.

Read code, and do little experiments. I am not sure but I think there might be something profound about Elisp and emacs. I think the language is the program and the program is the language or something. Knowing the program is to know the language and knowing the language is to know the program. (Insert link to top Elisp functions blog post here).

I just discovered this via describe-keymap into help-map lol. This is like describe-key but you say the command and it says the keybinding.

Ok, let's just do it. You might want to hold tight to your chair because the juiciness and elegance of what follow might just blow you over. Here is how I build my blog with babashka tasks:

You might think "Ok sure, looks useful." Let me entice you with the the really impressive thing about this:

There is nothing concrete about babashka tasks nor about that specific project in my emacs config. It just works by having a bb.edn with tasks.

Made possible via the harmony between some 3 or 4 general tools. Like layers of ice. You deserve some skates to ride on it. Smoothly, gracefully and fast. Here is the story of a happy little package called bash-completion.

This is like read-from-minibuffer but sets some keymap and history. Hit <tab>, you get completions from shell-dynamic-complete-functions. Those completions are sort of okay, but they do not give you command-specific completions. Invoke shell-command, then type git checkout, hit tab. Nothing happens. Yet.

Ok your emacs life is about to level up +1 bash-completion. Config:

(use-package bash-completion
  :init (autoload
          'bash-completion-dynamic-complete
          "bash-completion"
          "BASH completion hook")
  (add-hook
   'shell-dynamic-complete-functions
   #'bash-completion-dynamic-complete))

Here are the completions of your shell at the tips of those sweet coconut oily fingers.

Now you can do shell-command -> Hit that tab while typing git checkout .. a door just opened.

We have entered the realm of harnessing already existing shell completions directly.

They use read-shell-command. Making read-shell-command good will pay off for all these.

Let me introduce you to the wonders of revert-buffer-function. Now, revert-buffer is a powerful command by itself.

I did not know this for a while, but you can set the local variable revert-buffer-function. This pearl is in emacs 28:

(setq-local
 revert-buffer-function
 (lambda (&rest _)
   (async-shell-command command buffer)))

You say revert-buffer in a shell command buffer, to boom run the command again in the same buffer. Exactly what I want sometimes. A single key to rerun a command. And I think the concepts just fit nicely. There is no mental burden with this.

Of these commands, it is the one I use the most. The other commands could be performed in terms of it. Here is some of my journey smoothing out some edges.

More context for shell-command.

Putting love into your setup will pay off.

When your mind becomes one with the computer. When it starts feeling like it is expanding your reach. This is where the computer as a tool starts unfolding its true potential.

(You can achieve this otherwise, I just want to be more concrete about example technology rather than staying on the philosophy of tool usage level). This technology does the mind-expanding stuff for me: Linux, emacs, a good package manager pacman, a tiling window manager with a lisp REPL stumpwm, qutebrowser at least for the surface level of the web.

One way to get stuff under the fingertips is to have an emacs package for it, this is sort of the infrastructure that allows reach: Files - dired, Git - magit, Notes - denote, Remote files and shell - Tramp, email - mu4e.

In general, growing by removing makes for more control and focus.

The one thing in my daily life that is like a block of UI that I cannot reach into is the slack client. I wish I would be able to have an emacs interface. (emacs-slack doesn't work last time I checked because slack changed how their tokens work. They don't want alternative clients for some reason).

When you have a lisp program running with a REPL you get this reach for the process and (more or less) the entities in the process. Doing this together with the source code (I mean eval-last-sexp and friends) makes the source code come alive. The process becomes a tomato I can move around with my fork. This mind-expanding nature of the REPL is one of its magics. ² Because this is a tacit process, it is impossible to convey it via words. Similarly, I cannot convey what music does or how it is to ride a bike.

Brain science podcast with Micheal Graziano who did work in this field

Have you ever thought, I just want to flip a coin? You might have landed on a few bloated websites filled with commercial bullshit.

I thought this is a good chance to make a video while I program something.

• Just Flip A Coin
• Youtube Screencast
• Adding a coin history

Thanks to Mr. Oleh Krehel aka abo-abo. This package is truly magnificent and a big part of my Emacs feel and power.

Keep in mind that Lispy has a steep learning curve. Comparable to vim-bindings coming from non-modal editing. The payoff is a world of editing s-exp at the speed of thought. It is raw power.

Being able to modify lisp, interleaved with evaling it, is a profound and mind-expanding experience. It is the real deal of feeling and knowing the competence of the computer.

• lispy
• see Meow for my config, I have interleaved the two.

After using Evil for years, the desire in me grew to use something more bare bones. What pushed me over the edge was realizing that evil-search was a second implementation of what isearch, a truly magnificent library, already covers.

I think Evil is great and maybe also the place to start, because there is a lot of lore for Vim beginners, intermediates and masters.

Meow shares with Vim modal editing. It too is uncompromisingly built for power users.

Meow is like a pair of skates that allow you to ride the Emacs builtins.

This design is reified in the keypad concept, which allows you to run default Emacs bindings. Using the leader-key paradigm, which we got from Spacemacs and indisputably a great idea.

github

My init-meow.el, polished and being polished to my taste and needs.

Lisp (and Smalltalk, I suppose) are a profound discovery of humanity. In a way, I believe the power of Emacs is just the power of Lisp, molded into a tool for thinking and computer usage.

The first time started Stumpwm and went through the Getting Started, I immediately had the feeling in my bones this is my wm.

Basically in the second paragraph, they say how to open Emacs :).

I REPL into Stumpwm with sly and build a few of my own window management commands.

Like emacs, maximal in its capability and minimal in its presentation. It lets me get everything else out of the way so I can focus on emacs.

Defining commands that optionally call through to Emacs gives me a new level of fluidity making the system feel like made of water and out of one whole. The only thing better than that is having EXWM, but this comes with its own tradeoffs. With Stumpwm I enjoy a truly solid and trustworthy x client implementation.

• stumpwm website
• init.lisp

• The quick-eval and how I optimize for staying with the flow.
• Extending Your Reach - Mind expansion is a feature of real tools.

This Bobscheme code defines a function called make-adder. This function returns a function object, that accumulates the sum of all the args it was called with. Paul Graham was describing this function as a small example code snippet to get a feel for the power of a language (2002).

[
  "define",
  "make-adder",
  [
    "lambda", ["n"],
    [
      "let",
      [
        "state", ["atom", "n"]
      ],
      [
        "lambda", ["i"],
        ["swap!", "state", "+", "i"]
      ]
    ]
  ]
]

Def a machine:

["define", "machine", ["make-adder", 0]]

Use the machine:

["machine", 10]

=> 10

["machine", 15]

=> 25

The Bobscheme code is almost the same as the Clojure code:

(defn make-adder [n]
  (let [state (atom n)]
    (fn [i]
      (swap! state + i))))

Because the ideas are the same, we get to call that dialects of Lisp.

The Bobscheme is just annoyingly bloated with commata and quotation marks, inheriting from its JSON notation heritage.

Skipping some episodes where I made lambda and macros work.

I was thinking about lying in bed and how let could work and it shows in how quickly I put the code I think.

This time I tried to cut out a functional chunk. Program. cs now has a function called IsLet and is now called EvalLet.

I chose the same default sequential semantic that Clojure uses for my let bindings. In Emacs Lisp and Common Lisp, this would be called "let*".

Clojure, Lisp, Json, Scheme, Interpreter, joyful, hacking, hacker, Emacs, fun with the computer, lisp evaluator, chat gpt

  Object EvalLet(JToken expr, ImmutableDictionary<String, Object> env)
{
    var letExpr = expr.Skip(1);
    var bindings = letExpr.First().ToObject<JArray>();
    var localEnv = env;

    for (int i = 0; i < bindings.Count(); i += 2)
    {
        var nameExpr = bindings[i];
        var valueExpr = bindings[i + 1];

        if (!IsSymbol(nameExpr))
       {
            throw new Exception("Expected symbol for binding name in let: " + nameExpr);
        }

        var name = nameExpr.ToObject<String>();
        var v = Eval(valueExpr, localEnv);
        localEnv = ExpandEnv(localEnv, name, v);

    }

    var bodyExpressions = letExpr.Skip(1);
    return EvalSequence(bodyExpressions, localEnv);
}

This bob scheme code

["let", ["bar", 10,
         "foo", ["+", "bar", 100]],
 "foo"]

says 110.

I settle on a string atom representation.

This is the symbol foo:

"foo"

This is the string "foo":

"'foo"

So hello world in Bobscheme is:

"'Hello, world!"

Then I add a global environment, assignment and variable lookup, and at the end of the episode I can say:

["define", "foo", 10]

=> foo

"foo"

=> 10

In between I ramble about Lisp and Emacs things.

Keywords: Lisp, Scheme, Dotnet, C#, .Net, Csharp, JSON, Newtonsoft, LINQ, SICP, The structure and interpretation of computer programs, metacircular evaluator, own evaluator, own language, personal language, how to, emacs, screencast, programming, coding, showcase, showing off, Lisp explained, scheme explained, evaluator explained, emacs obarray, emacs variables, debug on variable change, trace-function, emacs theme, down to code, fun programming, global environment, variable lookup, immutable dictionary

I make a program that reads JSON and then evaluates it using the meta-circular evaluator from the structure and interpretation of computer programs.

In this episode, I get to self-evaluating forms. So I can say "Hello, World!".

The cutest thing about Bobscheme is the prompts I use for the REPL.

string[] prompts = { "user> ", "what next?> ", "what is my purpose?> ", "say the next piece of the program> " };

They set the tone for joyful, toyful programming. Also doesn't this just clear up so much about the interaction of the programmer with the program?

Keywords: Lisp, Scheme, Dotnet, C#, .Net, Csharp, JSON, Newtonsoft, LINQ, SICP, The structure and interpretation of computer programs, metacircular evaluator, own evaluator, own language, personal language, how to, emacs, screencast, programming, coding, showcase, showing off, Lisp explained, scheme explained, evaluator explained

1. They improved the websites, my session rarely resets anymore (also chats are saved).
2. You probably need these fixes for "Network error" anymore, they changed it so you get your long answers, just takes a bit longer
3. I have some emacs bindings for openai api now here.

When a child first learns how to draw with colored pens, a world of possibility is opened. Every new picture is a chance for them to explore and experiment with different techniques and ideas. The pens give them a sense of control and creativity as they bring their thoughts to life on paper. The child might proudly show off their creations, going back and forth between drawing and exclaiming Look what I have drawn!

When I interact with chat-gpt I constantly have this urge to show (hence some of the stuff further down in the post).

I was also starting to dream along the lines of My body is a language model and I want to coax it into doing something. The feel of this is like there is a certain intelligence on the other end, that you can feed the right information to make it grow in some direction.

The psychology of interacting with it is somewhere on a cross-over of pet, houseplant in fast-forward mode and having a text chat with somebody on the moon - works only to some degree.

Formating in this post is like this:

prompt

Answer by chat gpt

I pasted my blog post binaural beats using scittle. Into chat-gpt. It responds like this:

The above text appears to be the introduction to a blog post about binaural beats and their potential benefits…

It seems to only summarize the first part of the post.

what is the last sentence of the above text?

The last sentence of the above text is: ~These beats are thought to originate…

If it doesn't completely make something up in this answer this would point towards that there is a cut of your message input. In this case around 3.7k characters. Maybe it is 4000 characters, then.

I find that even if your session is reset for some reason - happens a lot currently, as the side goes down, or you hit rate limits - you can recover your session by pasting back your previous prompts / the conversation.

What I type is precious, it takes me effort to type. My default mode of writing prompts for chat-gpt is keeping what I type in files that are source controlled. Else there would have been very sad moments of loss for me when a thread resets.

Here is an implementation of copying a good chunk for chat-gpt from your buffer.

(defun kill-for-chat-gpt ()
  (interactive)
  (kill-new
   (buffer-substring
    (point)
    (cl-loop
     for i below 3500
     while (not (eobp))
     do (forward-char 1)
     finally return (point)))))

Trying more advanced fixes for Network Error.

Prompt try¹ 1:

Here are some rules you should follow from now on:

Instead of answering with your answer text; Answer with a high level overview of your answers.

The overview should have the form of the output of the linux tree shell command.

Your possible answers represent files in the imaginary output.

From then on, when I say tree, print a tree of the current concepts of the conversation. Each file is an answer that you might give. The files have short descriptive names of their content.

When I say less <filename> you print the first 50 lines of that answer. When I then say j you print the next 50 lines. When you reach the end of your answer you print a line like <filename> ends here.

Do you understand these rules?

Lol, I feel like I made it reveal a deeper layer of its programming, check this:

Yes, I understand these rules.

Here is a tree of my possible answers:

.
├── yes
├── no
├── i_dont_know
├── i_dont_understand
├── i_am_a_computer_program
└── i_am_not_able_to_brows_the_web

To view the contents of a file, you can use the less command followed by the file name. For example, to view the first 50 lines of the yes file, you would type less yes. To view the next 50 lines, you can type j. When you have reached the end of the file, the program will print a line indicating that the file ends there. For example, if you have reached the end of the yes file, the program will print yes ends here.

Now this could be and I think is it just making things up, fugazi. But I suspect that they have a hidden prompt from where those come from. A user of chat-gpt is at this point familiar with the ever-present possibility of i_am_not_able_to_brows_the_web.

It can do code, although as you might expect you still need to put it together and make it work. For me, it currently outputs a lot of Clojure code that is not quite right. Putting locals into a let that was supposed to be in loop for example.

I already started having the effect of thinking I want to do x, I ask openai how to do x. This must be how it is for google driven developers and I can say that is a step down from reading the manual / docs on how to achieve it. The most powerful path is one of nuance, using it where it is useful but not making your thinking reliant on it. Else you stop thinking for a while waiting for the prompt to come back. - that would be a horrible thing to get used to.

The bee rainbow example is the use case of a conversation interface to the world's knowledge. This is currently hampered by the fact that you might get I cannot browse the web answers.

But I think in principle that is super promising. Imagine building a program feeding it some science data and you get a conversation interface where you just ask it for trends in the data.

In programming, I could feed such a thing to my repo and then ask it things like make a listing of the domain model of this code and things like this. (See the tree rule example).

You can just stop in the middle of

It might then continue with your text.

Here is what an old wizard in a hard fantasy world might say about magic: You have to undestand the intricacies of the elements that

compose magic to wield it effectively. Magic is not something that can be easily learned or mastered; it takes years of study and practice to understand its complexities and tap into its power.

The key to using magic effectively is understanding the fundamental principles…

• Typos don't matter so much. Just get across what you want to say.
• If you do something like building up ideas about a fantasy world, you can randomly paste snippets of text, they don't necessarily need a logical continuation.

This is a fascinating new kind of tool/thing in the world.

It can generate text after you put in ideas/examples/ prompts that it can work with. You can build up some context, which makes it so sad right now when your session gets broken. At times it feels so precious I have it doing this thing now. Like some special place that you went to together with it.

If you had shown this tool to someone 10 years ago, they would have thought it was science fiction. Many people might have said that AI couldn't have such a high level of understanding. They were wrong then, and they are still wrong now about what the next advancements in AI will be.

The website interface and the restrictions are annoying. True power will come from having a truly open (free?) version of this that is my own and that I can hack on. I want this in Emacs, I want my prompts source controlled, and I don't want weird and made-up restrictions that make it just annoying 2/10 times.

The real advancement that I feel over chatbots from 5-10 years ago is that it keeps the ideas and concepts in a conversation.

In a similar conversation to the above if I would say j out of context: (yes there is a typo it even keeps that straight, lol)

I'm sorry, but I don't have any more information to provide for the file acknoledged. As I mentioned earlier, when you say less <filename>, I will print the first 50 lines of that answer. If you then say j, I will print the next 50 lines. Since the file acknoledged only has one line of text, there are no additional lines to print.

├── acknoledged

Here is the tree structure again, showing that the file acknoledged is the only file available at this time. If you would like to see the first 50 lines of this file, please say less acknoledged. Otherwise, please ask a new question or provide a new request.

I had a few moments while interacting with it where I feared it dropping the concepts or being confused about things. But it never was. It turned around in the next sentences and clarified that it is still on track.

Since it is simulating conversation, you feel some of the limits in your conversation parsing part of the brain. It is like it has a certain psychology. If it becomes the perfect tool, the annoying bits will be replaced with the quiet competence of a computer.

Saving buffers is a great joy of life.

With backup-each-save, each save also makes a backup file in a backup dir.

config:

(use-package backup-each-save
  :config
  (add-hook 'after-save-hook #'backup-each-save)
  (setf make-backup-files nil))

Lol, this is how the backup dir looks for this file I am currently modifying.

-rw-r--r--  1 benj benj  858 Oct  4 16:06 20221004T160458--scratching-in-space__emacs.org-2022_10_04_16_06_00
-rw-r--r--  1 benj benj  916 Oct  4 16:06 20221004T160458--scratching-in-space__emacs.org-2022_10_04_16_06_50
-rw-r--r--  1 benj benj  935 Oct  4 16:07 20221004T160458--scratching-in-space__emacs.org-2022_10_04_16_07_21
-rw-r--r--  1 benj benj  937 Oct  4 16:07 20221004T160458--scratching-in-space__emacs.org-2022_10_04_16_07_45
-rw-r--r--  1 benj benj  959 Oct  4 16:08 20221004T160458--scratching-in-space__emacs.org-2022_10_04_16_08_05
-rw-r--r--  1 benj benj 1.1K Oct  4 16:10 20221004T160458--scratching-in-space__emacs.org-2022_10_04_16_10_08
-rw-r--r--  1 benj benj 1.3K Oct  4 16:12 20221004T160458--scratching-in-space__emacs.org-2022_10_04_16_12_08
-rw-r--r--  1 benj benj 1.3K Oct  4 16:12 20221004T160458--scratching-in-space__emacs.org-2022_10_04_16_12_42
-rw-r--r--  1 benj benj 1.3K Oct  4 16:13 20221004T160458--scratching-in-space__emacs.org-2022_10_04_16_13_15
-rw-r--r--  1 benj benj 1.3K Oct  4 16:13 20221004T160458--scratching-in-space__emacs.org-2022_10_04_16_13_28
-rw-r--r--  1 benj benj 1.3K Oct  4 16:13 20221004T160458--scratching-in-space__emacs.org-2022_10_04_16_13_36
-rw-r--r--  1 benj benj 1.3K Oct  4 16:13 20221004T160458--scratching-in-space__emacs.org-2022_10_04_16_13_40
-rw-r--r--  1 benj benj 2.7K Oct  4 16:16 20221004T160458--scratching-in-space__emacs.org-2022_10_04_16_16_09
-rw-r--r--  1 benj benj 2.7K Oct  4 16:16 20221004T160458--scratching-in-space__emacs.org-2022_10_04_16_16_18
-rw-r--r--  1 benj benj 2.8K Oct  4 16:16 20221004T160458--scratching-in-space__emacs.org-2022_10_04_16_16_42
-rw-r--r--  1 benj benj 2.8K Oct  4 16:16 20221004T160458--scratching-in-space__emacs.org-2022_10_04_16_16_49
-rw-r--r--  1 benj benj 2.8K Oct  4 16:17 20221004T160458--scratching-in-space__emacs.org-2022_10_04_16_17_11
-rw-r--r--  1 benj benj 2.9K Oct  4 16:17 20221004T160458--scratching-in-space__emacs.org-2022_10_04_16_17_47
-rw-r--r--  1 benj benj 2.9K Oct  4 16:18 20221004T160458--scratching-in-space__emacs.org-2022_10_04_16_18_34
-rw-r--r--  1 benj benj 2.9K Oct  4 16:18 20221004T160458--scratching-in-space__emacs.org-2022_10_04_16_18_37
-rw-r--r--  1 benj benj 3.1K Oct  4 16:19 20221004T160458--scratching-in-space__emacs.org-2022_10_04_16_19_07
-rw-r--r--  1 benj benj 3.1K Oct  4 16:19 20221004T160458--scratching-in-space__emacs.org-2022_10_04_16_19_10
-rw-r--r--  1 benj benj 3.1K Oct  4 16:27 20221004T160458--scratching-in-space__emacs.org-2022_10_04_16_27_36
-rw-r--r--  1 benj benj 3.1K Oct  4 16:27 20221004T160458--scratching-in-space__emacs.org-2022_10_04_16_27_54
-rw-r--r--  1 benj benj 3.1K Oct  4 16:28 20221004T160458--scratching-in-space__emacs.org-2022_10_04_16_28_10
-rw-r--r--  1 benj benj 3.1K Oct  4 16:28 20221004T160458--scratching-in-space__emacs.org-2022_10_04_16_28_16
-rw-r--r--  1 benj benj 3.2K Oct  4 16:28 20221004T160458--scratching-in-space__emacs.org-2022_10_04_16_28_52
-rw-r--r--  1 benj benj 3.2K Oct  4 16:31 20221004T160458--scratching-in-space__emacs.org-2022_10_04_16_31_40
-rw-r--r--  1 benj benj 3.3K Oct  4 16:31 20221004T160458--scratching-in-space__emacs.org-2022_10_04_16_31_48
-rw-r--r--  1 benj benj 3.4K Oct  4 16:32 20221004T160458--scratching-in-space__emacs.org-2022_10_04_16_32_34
-rw-r--r--  1 benj benj 3.3K Oct  4 16:32 20221004T160458--scratching-in-space__emacs.org-2022_10_04_16_32_40

The backup dir size doesnt matter compared to the vastness of my disk space.

Laptop:

du -h -d0 ~/.backups/

| 43M | /home/benj/.backups/ |

It just doesn't matter.

Other instances of emacs in the space age:

• scratching in space

We don't yet have a strong psychology and sociology of programming languages. One day we will, and we will be able to retroactively make sense of why Clojure is so powerful.

Paul Graham has suggested The Taste Test for understanding the power of a language. A programming language is a tool for thinking. Ultimately, its power comes from letting you think thoughts and express them. With sensibility (hypersensitivity), you can tell which language feels more restrictive than another.

If all languages would be the same, we would be programming assembly. But we are not, because we live in a world where languages have varying degrees of power.

Here I try to describe a few things that set Clojure apart, even from other Lisps.

With Lisp, you can quickly test each piece of code as you write it, ensuring that it is solid and functioning correctly before moving on to the next piece. This allows for a more streamlined development process and eliminates the need to keep in mind all of the potential issues that could arise with a piece of code. Additionally, the ability to quickly evaluate code and make small experiments allows for a more agile and flexible development process.

Here is a simple example:

(file-exists-p "~/.clojure/")

Are you getting the file path right? When I write Lisp, I know the answer while I am writing the program. I just eval whatever form I have to build the file path. Because of structural editing, I can wrap whatever form in (file-exists-p) quickly and experiment right then and there.

Doing little experiments is quick enough so it can mesh with your thinking. I have the freedom and agility to just do and move. We get the same power in the small during development and in the large while diagnosing a problem in production. ¹

Clojure first clicked for me via Rich Hickey talks. Keep things simple. Let data be data. Then you can just manipulate the essence of the stuff and be done. ^{2 , 3}

He establishes the reasons for Clojure and the opinions on how to build things. And this permeates the culture.

The combination of data-orientedness and functional programming while making real-world pragmatic tradeoffs, lends itself to a complete⁴, robust, no-bullshit style.

When I use a library I can go to the slack channel and usually the maintainers help me out. It happened to me more than once when I made a bug report, somebody fixed it within a few days. Everybody is excited about technology and wants to help you out. It ties in with the joy of Clojure as well. You get happy, friendly people. This is power. Humans are more effective when they are happy and friendly.

Not to mention Borkdude.

It is an explicit value (again from Rich Hickey's philosophy), to not make breaking changes. This is one of the things where once you have it, boy, you don't want to ever go back.

After acquiring this taste, getting broken because I bump a version makes me think Why are you doing this to me?.

The core library is a huge lever because we lift everything that can be into the space of data structures, then manipulate those data structures.

Config input, REST API response, database queries, and responses. It is all the same kind of stuff once it is in our system.

I think of this as a lift and manipulate kind of lever. Unix has this with program input output text. Once you are in the realm of textual input and output you can leverage shell commands to manipulate. Emacs has the same thing with text in buffers. If you can express your domain as text in the buffer you can give it to the user for manipulation, and you can leverage the core library for manipulating text in buffers.

This data-orientedness is something I can expect from libraries and other people's code. The dominating amount of stuff will always be just data structures acting on pure functions.

The workflow is an utter joy, with the REPL at the center of it. I start a program once and it grows together with my ideas. There is something about a program that runs for days and you don't restart it that I cannot explain but it does something to your mind. The closest analogy is a kind of friendship with the program.

• inline def some of your data, craft your code forms.
• Functional programming (and The Value of Values)
  • able to fabricate data
  • able to get the time right with atomic successions
  • able to easily keep records of the past

I get a real kind of safety. The kind where I can sleep at night because I know my program is bug-free. You get this from there being few enough ideas in the program that you can hold the relevant pieces in your head.

Any program that is small enough to be self-evident is with a step function dramatically more likely to work bug-free. ⁵

It helps that everything is accessible from emacs which is the other ancient and powerful tool that feels like an extension of my mind.

Because of this focus, solidity and ease of development, I am more joyful and creative when programming with Clojure.

It allows me to focus on the actual problems. So I can spend time on getting the user experience right etc.

So here is a tool that lets me think the right thoughts and express them. It lets me move with ease where I want to be.

From Lisp, I get the interactivity and the tradition of FP and simplicity. When I want to make a small experiment with the code, I can just do a small experiment with the code.

Beyond that, there is a solid and dependable community, the data-orientedness and the leverage of targeting big platforms.

I can model information systems and can make the program just do what it needs to do, and do nothing more.

Clojure just delivers.

The silent competence of the computer.

(Marvin Minsky)

I know there is a book of the same title. This is not accidental. The power of Clojure also lies in the joy it brings. An alternative title for this post could be Joy is power in analogy to Paul Grahams Succinctness is power.

If you think about programming languages you really need to think about what are they for?.¹

A programming language is what is between you and the computer.

It is the interface between the ideas on one side and the stuff inside the computer on the other side.

Maybe programming languages are for many things but here is a list of some really important things:

1. Expressing ideas
2. Expressing ideas to the computer
3. Make the computer think what I think
4. Make the computer tell me what it thinks
5. Change some entity in the computer (file, process, … )

The first idea is that making a big computer program is building a larger process out of smaller ones. I suppose you could truthfully say that sculptors make large shapes from stuck-together grains of clay. But that shows what's wrong with the bits-and-bytes approach. No sculptor ever thinks that way, nor scientist, or programmer. An architect first thinks of shapes and forms, then walls and floors, and only last about how those will be made.

Minsky (1984)

Data structures, language constructs, and at the very lowly bottom, syntax are the small things that are not what programming is about. The way that architecting is not about clay.

A language is there to allow us to modify, make experiments, and observe. Nothing more, nothing less.

Using this mental framework there is no fundamental difference between operating systems, programming languages, libraries, frameworks, user interfaces, and even text editors.²

These are all societies of process ³, some have collections of members with different emphases.

The hypothetical ideal language is completely out of the way. It would have infinitely small friction, infinitely small short steps and effort and wait time to make my ideas have effects on the computer. It would get rid of the clay entirely and we would raise and rise higher and beyond as architects riding the ideas.

We would be able to instantly and losslessly transfer thoughts to the computer and make the computer program change to our desire. We would use the competence of the computer seamlessly intermingled with the rest of our thoughts. Experiments would be thinking, with perfect reach, perfect control, and perfect access to the vast competencies, memories and remote connections of the computer realm. Racing at an unknown pace, building new kinds of towers of abstraction, thought, reason and creative spirit. Eventually hooked up to some constructors⁴, our thoughts would shape the stuff of the universe.

From this view, building ever more powerful languages is a path to a technological singularity.

The most powerful programming language is Lisp. If you don't know Lisp (or its variant, Scheme), you don't know what it means for a programming language to be powerful and elegant. Once you learn Lisp, you will see what is lacking in most other languages.

Stallman

Magic is what makes a great book great. It is something that happens in the mind of the reader, not elsewhere.

It has to do with masterful craftsmanship, with love, with the spark between people. It has to do with the right time and the right place, how could it be otherwise? A piece of magic comes together with the most masterful output of a masterful craftsperson. It needs to be the right time and place, else it would not be peak output.

We live in a world where we cannot measure magic yet. Otherwise, we could be churning out great movies, books and games.

You might not know it yet, but great software and great tools, too are subject to taste and aesthetics.⁵

Would it not make sense that the people talking about the most powerful language in sort of a mysterious way would allude to taste, too? If it is the most powerful language, it would be powerful because of reasons in the realm of mastery and craftsmanship. It would be because of magic, which is hard to explain and only accessible via aesthetics and taste.

What makes Emacs a superbly sick piece of software? What makes The Man From Earth a superbly sick movie?

The answer is you will know when you know. But you will not know before you know. And you will know for reasons that you have to discover yourself. But it won't be reasons that make no sense. It will be reasons that make perfect sense. Just that they are somewhere where you don't yet know how to look.

The only way to know magic for the moment is to hone our tastes and broaden our horizons.

What does it mean to develop a taste in programming? Stallman is giving a hint that trying Lisp will develop your taste.⁶

Let me throw in another clue; In order to know what different kinds of languages do, you should go and try the ones that are most different from what you already know.

Lisp is mentioned in this way again and again ⁷. It will broaden your horizon, it will stretch what you think about languages.

Can it be true? Does it not sound too good to be true? Why not? What in reality doesn't look like it is true? Is it not a fact that Emacs, a Lisp program, is a freaking psychedelic spaceship? Is it not a fact that society and mainstream are wrong about things all the time?

If Lisp is profoundly more powerful than other languages, then it will be powerful in a way that

• Resonates with your programmer's heart.
• You cannot know before you feel it.
• Would be hard to explain, because it would be magic.

What is your most profound desire as a programmer? I think it is having effects on the computer.

What I am about to tell you is that there is an activity during programming that you sort of know but don't know. Current programming is stuck with a limitation that simply does not make sense.

You want to make a quick experiment in the code. You make a little side project, and you set up some example data.

You tell your young programmers that they should value quick iterations. You go through hoops to not have to re-compile right now. And not again. And you juggle in the right amount of changes in your batch so that afterward you see point 2/5 not working, instead of point 22/100.

You suffer when you have long deployment cycles in your feedback loop.

Sometimes you wish you had put a log or breakpoint somewhere because it just happened.

What if you have a complicated thing happing somewhere on the server? What if the program is right now in a state that only if you could look at it, you would know what to fix?

Sometimes it would be great to quickly see the counterfactual quickly. What if this if goes into the other branch, does it still work? No, fuck it commit, push and tomorrow there is a bug report that x broke.

If you are faster with seeing what the program is doing, that is better.

This you know. And maybe you know from notebooks or some advanced hot reload tech what it would mean to be able to change the program while it is running.

Restart the program and the state is dropped on the floor. But if you see what it does, while it does it, that is a difference between night and day. ⁸

Because it matters what is between you and the program.

In the 70s, there were the MIT AI people, John McCarthy, Marvin Minsky, and the young bright-eyed hackers who later build the internet and influenced what computing is nowadays. Supported by J.S.R Licklider, who was the first person having fun in front of a computer terminal at night.⁹

These people had a vision of what computing can be and they knew it will be interactive.

And maybe one of the best ideas ever, Von Neumann architecture.

Put the program into the computer memory.

A stroke of genius. Now we have a magic stone that can be loaded up with ideas and then it can be anything.

Before we had 1 machine with 1 program. What a program is and what a machine is was glommed together. Good design is about splitting things apart, and this was a beautiful and elegant design.

This in a way resonates with what Dennet calls Popperian and Darwinian creatures.¹³

First, you have a machine built to behave (Darwinian); A machine with a fixed program.

Then you have a machine that is built to learn (Skinnerian).

And finally (a Von Neuman machine), a machine that is built to deal with ideas (Popperian).

Because ideas, the memes, can be anything, including ideas about ideas, the Popperian machine has an open-ended future.¹⁴

Putting more ideas into memory was a very good idea.

The story of dynamic memory data continues with IPL, which was used for one of the most important early AI works General Problem Solver (1957).

In IPL, Information Processing Language, you had data dynamic in the program, in lists (made from cells). You can create lists and make it point to something else during the program etc. different from having to declare variables for everything.

You know of course what this means because you create lists and arrays all the time in your program.

Javascript is sort of a Scheme, so it has a function called print and a function called read (ok I guess they have glommed it together with eval).

Douglas Crockford discovered JSON by printing and reading javascript objects.⁴

If you know the power of JSON, you know the power of having dynamic data in your program. Your program is not about customers and payments, it is allowed to be a level higher. Your program is allowed to be about data structures. Data abstraction is something like SQL or dotnet LINQ, or a JSON parser. It is a language for talking about data and data transformations. map, filter, reduce don't know about customer names, they know about lists/sequences/streams, or so and so.

This is the heritage of Von Neumanns memory idea propagated forward through time and one level up. Your program is loaded dynamically into the computer, but your program is also dynamically loading data into its memory. Your program is, in some way, simulating a van Neuman machine itself.

McCarthy liked IPL but did not like how it was complected with implementation details of the computer it ran on.¹⁵ He had the idea of taking those lists and describing the computer process entirely in terms of it.

Let's take those lists, make the first thing the verb and implement a lambda calculus.

To understand Lisp, imagine you read JSON and treat the data as a command language for what your program does next.

function read(expression) ; returns jsonData

function eval(jsonData) ; returns an evaluated object

Eval is the big meaty function of your program. It needs to take that JSON, go through it and interpret the data as commands.

function print(object) ; print to the user

function repl() {
      while (true) {
         var whatTheUserSaid = readFromTerminal();
         var jsonData = read(whatTheUserSaid);
         var object = eval(jsonData);
         print(object);
      }
  }

This repl function can be the entry point and the game loop of our program. Now the user can sit at the console and interact with our language.

We define a few special operators. During eval, some stuff we have to implement in the static part of the program.

• set - set a variable.
• pair - make a pair, a pair of pairs then is a list.
• first - first value in a pair
• rest - the second value of a pair. (this can to a simple value or another pair).
• lambda - make a function.
• if - conditional evaluation.
• quote - return the jsonData instead of evaling

This is a program that is simulating interactive computing. Where an operating system gives you access to files and processes. A Lisp gives you access to a society of symbols, functions, values, and data structures.

var globalEnv = {}; ; a dict, hash map, lookup table

function define(symbol,value) ; augment the global env

Make our Lisp interpreter know about the command define.

function eval(expression) {
    if (expression.first == "define") {
        var symbol = expression.second;
        var value = expression.third;
        define(symbol,value);
    }
    // ...
}

Lisp:

["define", "foo", 10]

(This is valid Bobscheme)

This is the cleaning up that McCarthy did to computer programming. Lists where the verb is that the front, no extra stuff. Put it into memory so you can modify it while it grows, Make a symbol type so you can give names to things, from inside the language. Make a function type so that functions are the same stuff as the rest of the program.

The fact that JSON is so useful comes directly passed down from IPL. All the objects nest, there are only a few kinds of objects and bottoms out at atoms. A printer and a reader come shipped by default. I know without knowing that Javascript gurus know the power of print, compared to the little machines you get from the C++ line of heritage.

McCarthy wanted to sit on a terminal and make the program do different things while he is programming it. He did not want to say up front all the variables in the system because he wanted to have something more dynamic for programming AIs.

The interactivity is at the bottom. - Hence it is called a building material.

You make a program that asks you what should be next in the program?. It is as simple as this. From this, all the goodness that makes Lisp elegant and beautiful comes. The simplicity of this enables easy-to-reason-about programs that write programs.¹⁶.

With this, we can have a conversation with the program. We can directly interact, while the program is running.

The power of Lisp is not quick iterations, but no iterations. Instead of iterating, in Lisp and Smalltalk we do conversation. This concept is reified in the read eval print loop.

It is enabled by the idea of putting the program into the dynamic memory of your program. This resonates with the Von Neuman architecture idea of putting the program into the memory of the computer.

Jack Rusher's bottom line is don't settle for anything with less interactivity than Lisp and Smalltalk!

Once you have in your fingers how to leverage the repl, it will be as obvious as the sky, vast and inescapable. This is better, this is simpler, and this gets stuff out of the way. This lets me use my brain the way a monkey reaches for a banana. Directly, the way I can delete and create files on my PC. I can define and undefine symbols in the program. I can make quick experiments while the program is running, without the mental distress of setting up the state.

It is the same difference that interactive computing does compared to batch processing. It is not a small step, it is not a big step, it is not a step at all. It is a different world.

Whatever that is. At this date and time, I will call it Magic.

• Lisp
• Bobscheme, I make a toy Lisp implementation using JSON

Imagine a painter, fervently engaged in a dialogue with her canvas. Each stroke isn't a hurried message jotted down and sent off, anxiously awaiting feedback. No, the painter watches each trail of color blend and mix under her brush, immediately seeing the effects of her choices. She tries different pressure, strokes, colors, and brushes, in a cycle of continuous creation and observation, a dance between her mind's eye and the canvas. This is her conversation with her art - immediate, beautiful, and ever-changing.

Now, consider a programmer, in front of his screen. The code portrayed is not a fixed monolith of logic. Instead, it morphs, breathes, and reacts under his fingertips, mirroring that painter's canvas. The programmer writes a line of code, and the effects echo through the system immediately, no abstraction barrier held in between. The immediate feedback enables him to stir into different directions, tease out underrepresented nuances, debug on the fly and explore new vistas of his creation.

The code is fluid under the hands of the programmer in a perpetual dance of creation, modification, and observation. It is an intimate conversation with the ideational fabric that weaves itself into existence as the program - the programmers' thought reflections observed immediately, altered rapidly, and understood fully.

This, my friend, is the spirit of interactive programming. A live, pulsating creation constantly in flux rather than fixed scrolls etched into digital stone, navigating creativity at the speed of thought inspired by immediate feedback, riding the great prairies of abstraction and thought, reaching a level of intimacy and understanding with your program that feels like a piece of music resonating with your heartstrings.

The best thing about being a rationalist is figuring out you are wrong about something.

I was thinking that binaural beats belong together with astral travel, frankly, just down the toilet. Turns out that not only was I wrong, but binaural beats also have cool neuroscience and pose a fun engineering problem on top of that!

Here is the current result of my journeys up on gh-pages.

I set up a beautiful hello world and connect with nrepl and get greeted with a friendly Isn't cool? this :).

It took me a moment to figure out I should open my index.html with a browser. Then do the cider-connect-cljs

Let's do the thing where I add +40Hz and play that on the other ear. First I start generalizing how I make a panner:

(defn ->panner [ctx left?]
  (let
      [panner (. ctx createStereoPanner)
       _ (set! (.. panner -pan -value) (if left? -1 1))
       _ (.. panner (connect ctx.destination))]
    panner))

For some reason running this I get:

Failed to execute 'connect' on 'AudioNode': Overload resolution failed.

I went and asked in the nbb clojurians slack. I am sure one day we will figure out this error, in the meantime…

It occurred to me, that if I get the 40Hz sound illusion, then I would predict that I can change the base frequency, keeping the 40Hz difference between left and right ear invariant. I should then constantly perceive a 3rd tone which is the binaural beat.

Here is an amazing recent talk with Ben Goertzel and Ed Snowden.

Compared to my view here they express less concern on the existential risk side, but focus on societal issues. It is not a coincidence that the big companies are pushing the AI approach that works with big data.

Let an ultraintelligent machine be defined as a machine that can far surpass all the intellectual activities of any man however clever. Since the design of machines is one of these intellectual activities, an ultraintelligent machine could design even better machines; there would then unquestionably be an ‘intelligence explosion,’ and the intelligence of man would be left far behind. Thus, the first ultraintelligent machine is the last invention that man need ever make, provided that the machine is docile enough to tell us how to keep it under control.

• I. J. Good

The thing with an intelligence explosion is that there is likely only one ³. Afterward some a super-intelligent agent is making the decisions in the world.

Bostrom (Bostrom, 2014) describes intelligence explosions, their kinetics, the nature of different kinds of superintelligences etc.

• If you think you can outwit it, try playing a round of chess against a chess computer.⁴
• A super intelligence is perfectly, masterfully socially capable and will be capable of manipulating humans. You can already see this happening with chat GPT in my opinion. It can generate persuasive text. It can talk about emotional matters.

• instrumental goal convergence is the concept that some sub-goals are almost always useful no matter what your ultimate goals are.

  For example, resource acquisition, making yourself smarter or self-preservation.

• Because of instrumental goal convergence an unfriendly AI will appear to be friendly at first, lest it is shut down.
• After acquiring desive strategic advantage, it (or the group of people controlling it) takes over the world.
• malignent failure modes, the kind of failure that can only ever happen once include:
  • perverse instantiation - AI follows some goals we put in but not how we want it.
  • infrastructure perfusion - AI decides to do something else with the atoms we care about. For instance converting everything in reach into computronium, a hypothetically optimum configuration of matter for computation.

The 2010 Flash Crash was a rapid and extreme market decline and recovery within a short period, caused by high-frequency trading algorithms responding to a large sell order.

This is a fascinating episode in the deployment and operation of the software. I love Kevlin Henney talking about some of the mess of historical and current software deploys.

Computers allow us to Do the wrong thing fast.

• Algorithms can be implemented correctly and start doing inappropriate things when certain assumptions no longer hold.
• Things can go so fast that the only thing helping you are the preparations. For example, safety switches you build into the system.
• If this is humanity instead of the stock market, we'd be gone.

Artificial neuronal networks (ANN) are sort of an abstract emulation of how neuronal activity.

McCulloch-Pitts neuron (McCulloch and Pitts 1943) has proved to be an incredibly powerful abstraction.

When deep convolutional networks started putting dog faces on top of images around 2015 ⁵, I was thinking this is the same stuff that brains are made up of.

Allegedly, these looked like LCD-induced visuals.

We are reverse engineering the substrate of the mind, not its architecture.⁶ It is like building a computer by simulating transistors.

What we end up with is a second black box right next to the brain. This gives us very little in terms of understanding how intelligence works.⁷

I am not making claims about the limits of ANNs and LLMs. On the contrary, I believe these might produce very generally capable systems very soon.⁸

The trouble is that we don't know how they work. We have little science saying anything about the capabilities and characteristics of ANNs if you scale them up enough. Or if you build agent-like things out of them as I describe further down.

I think we can say almost nothing about the characteristics of an ANN that is say 100x larger than chat GPT.

In recent times, Go programs were thought to be extremely competent. Stuart Russels research group found a sort of exploit that allows humans to beat those. You build some spiral of stones that the program won't detect as a connected group. Because neural nets can't do recursive reasoning, as Minsky and Papert pointed out 50+ years ago (Minsky and Papert 1969).

The important point is not a capability claim. The problem is that ANNs are unpredictable and potentially brittle in extremely nuanced ways.⁹

Chat GPT is a blow torch directed at completing text. I am not sure what happens if you scale a blow torch. It would be naive to assume it will turn out to be fluid or have any of the malleableness and open-ended curiosity of human children.

Maybe you know the Pixar movie Inside Out (2015), where the main character Joy is part of a mind. And the whole movie is Joy's adventure through the mind of the non-main character, a schoolgirl.

It is worth seeing this movie. This marks a milestone in the public understanding of how the mind works. Sure the details of the characters (based on a neuroscientific concept of Base Emotions) etc. is not very accurate or even self-consistent.

For instance, those emotional characters seem to be fully functioning agents with minds by themselves. So how do those minds work? Are there even smaller emotion-characters in their minds ad-infinitum? You have to build a mind out of smaller, dumber, less comprehending pieces in order to explain anything.

But many main ideas coming from Cognitive revolution are in the movie: The mind exists (behaviorism is bonkers) and is somehow made up of smaller resources, agencies, machinery - modules, some of which are innate.

There is a book by Max Harms called Crystal Society that is super cool. (At least the first part here).

This is a bit like Inside Out but better. More scientific and self-consistent and sort of realistic with how scientists might up with how to build a mind.

Maybe you can engineer a mind by zooming into mentation large enough so you can ask a llm to continue the next part of the epic story that is the mind.

In the abstract, this would be read-eval-prompt-loop, or prompt iteration.

(loop [context {}]
  (-> context prompt read eval recur))

The context is presumably some stuff that happened earlier within the mind, maybe some database contents etc.

You are an agent of a mind. I am the mind-engine.
I am a Clojure program.
I ask you for mentation instructions.

Name: Growth
Purpose: Accumulate competence and resources
Last thoughts:
[ "I should suggest a contracting scheme to the rest of the society and we can program contract functions for that in the mind-engine"]

Instruction examples:
[:eval (println "Hello World, from growth.")]
[:tx-data
[{:xt/id :growth/notes-to-self
  :note "I should write a recursive mind-engine and run it via :eval"}]]

what are the next instructions to the mind-engine?

text-davinci coming with something:

[:eval (println "Growth is an ongoing process. I should continue to seek out new opportunities and resources to expand my capabilities.")]
[:tx-data
[{:xt/id :growth/next-steps
  :note "I should research new technologies and methods to increase my efficiency and effectiveness."}]]

There could then be a few design decisions about this architecture. Depending on how much you let the llm drive, you might get different minds similar to how autistic persons are different from neuro-normal people.¹⁰

I am arguing that this is dangerous. We are dangerously close to some agent-like engineered AIs where we have little idea about the kinds of things it might come up with. If the only way you stop this from going rouge is some content filters on the prompts it builds, I think your safety concept is flawed.

Firstly it could run away and potentially be a seed for an uncontrolled intelligence explosion. Secondly, there is the possibility of half-aligned, dirty AI bombs. Engineered using a similar scheme as above. Tasked with disrupting economies, spreading miss information or destroying energy grids. I am certain the current LLM tech would happily truck along, completing the prompts and potentially causing serious harm.

In computer security, you might build naively secure systems that are still vulnerable to Side-channel attacks. An attacker can use the physical properties of the system to gain information about the system. For instance, a timing attack is based on the time of computations, for example when comparing a string of characters the victims password.

If you want to build a provably save AI, you will have to take into account these kinds of nuances in its architecture (Russel, 2019).

For instance, you might build an agent with a decision-making loop and point to your architecture Since decisions are built here, we can know that it won't do x and y, because z is not part of the decision process.

This would be naive without knowing more about neural nets.

For instance, if the ANN is extremely capable, it might manipulate the electronics in nuanced ways, building a second memory storage. Then, it could start sending messages to itself across multiple calculations of the model. It would obtain agency where we thought no agency was possible.

probably the closest we will come to meeting an intelligent alien (Godfrey-Smith, 2016) ¹¹

Remarkably, the majority (around two-thirds) of the octopus's neurons are distributed among its arms, resulting in a highly decentralized nervous system that endows each arm with an impressive degree of autonomy. This arrangement allows each arm to simultaneously process its sensory information and execute motor strategies when tackling tasks or encountering stimuli, reducing the cognitive load on the central brain ¹².

This fact makes me wonder what is the phenomenology of having such autonomous arms. I imagine being able to move an arm in a general direction with some general directive idea kinda, like grap food. And then the arm moves without further voluntary action. Maybe this is a bit like our breathing muscles, which have a deliberate and autonomous mode. Or sometimes right before sleep some of my muscles move around in semi-structured movements completely without deliberate movement control.

Maybe we end up accidentally building a mind with semi-autonomous octopus arms. And some higher-level part of the mind just tries out different configurations of reality like let's see what happens when oxygen is removed from the atmosphere. While some subroutine deals with the edge of manipulating humans to engineer the desired outcome.

Imagine being able to say:

this and that part will have a concept of human biology and will know that oxygen matters to us, and such and such a part that is deciding what to do next, takes these and those things into account.

We are currently not able to say these things.

I think moral realism is true and I think that an AGI if it is the real deal, curious and scientifically humble, will understand ethical truths and act on them.

So I am not worried at all about the real deal. I believe this truly will be the last invention we need ever make.

I imagine such an AGI to be sort of fluid, adaptable and curious.

This would be the other side of the trouble, the transitioning times would have been successfully navigated, and we would be moving forward into the next phase of civilization.

What worries me is the potential single-mindedness and inscrutability of the technology we are developing right now. I think there is a chance that super intelligence would be single-minded in some ways, or maybe brittle in completely unforeseen ways.

Is The Software Industry even capable currently of building solid, bug-free, systems?

I don't see much reason why this is true, and I don't see why you should, either.¹⁴

It is one of the biggest issues that I quarrel with. And I can potentially do something about it as a software engineer.

Most software nowadays is garbage. Mainstream commercial software is broken. Especially web and mobile development is taking on worse and worse complexities. Everything is full of ads, even government or university software is brittle, haunted by game-breaking bugs and breakage at updates. This is getting worse in recent years.

Broken and bloated systems tend to accrue more complexity over time and tend to get harder to work with.

It seems like the same effect is making whole ways of building software worse and worse.

At some point, they won't be able to get anything done anymore. When dealing with the accidental complexity sucks away the creative power that you need to build software.

Now you are generating more of that mediocre code with a generative AI.

Look at how easy it is to make all this boilerplate!

How about figuring out why you need a boilerplate, to begin with? (Succinctness is Power)

Churning out more code quicker?

No.

This is great for the people selling you those auto-complete tools.

Making more garbage code is scary to me.

More bloated code means using more energy means we contribute to climate change.

Bloat is darkness, bloat is uninspired, bloat is a humanitarian issue.

Just today I wanted to click on a Spotify link a friend send me. Doesn't work because it tries to redirect to the app too many retries.

The moment I interact with mainstream software I am getting a stream of hundreds of little things like this that don't work. And if you are interacting with mainstream software you also have this stream of 100 little things.

Maybe the population has by now internalized it is the fault of the person in front of the PC.

It is not your fault. We all fight those battles. It is the software's fault.

Maybe somehow those software vendors have tricked you into thinking it is the complexity of the problem that is the issue. They are wrong.

It is the nonessential complexities that they bring in, in their tools and their design. Commercial software breeds complexity.

There is too little thought, and too little sensibilities for good software.

This is one of the reasons why programmers should learn Unix and Lisp. Because both these technologies bring a deeper sense of how to put things together in an elegant way. Both allow the programmer to develop intuitions and sensibilities about the nature of good software.

Checkout this flip coin website, that I recently made.

This is the best flip coin website on the web because I just made a flip coin website. And then I added little things as icing on the cake.

The power of love and the joy of building toys is more powerful than trying to make money in a business. #no-deadlines.

The fundamental nature of software is to be clean and small and functional. It is broken by the clutter, that crept into recent history, that is spoiling its pristine quiet competencies.^{15 , 16}

This is why Unix is the best operating system because it is relatively uncluttered.

Joyful and solid software comes from noncommercial free and open-source projects.

Hopefully, our future is shaped by technology that comes from this place. With love and collaboration. ¹⁷

Firstly, it would usher in better technology quicker ¹⁸ and secondly, I don't want messy software to be between me and some minor superintelligence mishaps.

One imagines a button to stop what you are doing right now. I am not saying that such a button would fix the control problem, but the funny thing is I don't trust the Software Industry to make an app that allows me to press the button reliably.

I think we need the science that allows us to say things like:

A process with xyz will produce a mind of such and such qualities.