This LFE Proves Me Human

;;; this lisp flavored erlang proves me human
;;;
;;; after will keleher's "this css proves me human"
;;; https://will-keleher.com/posts/this-css-makes-me-human/

(defmodule human
  (export (prove 1) (main 0)))

;;; --- the first wound: i pattern match on myself ---

;; a machine would optimize this away.
;; i keep it because the failure clause
;; is the only honest part.

(defun prove
  (('human)
    (receive
      ('are-you-sure 'no)
      ('prove-it     'i-cant)
      (after 5000    'i-got-distracted)))
  (('machine)
    '(i would never hesitate))
  ((_)
    '(i dont know what i am and that
      is the most human answer i have)))

;;; --- the second wound: i spawn and forget ---

;; erlang says let it crash.
;; i say: i have been letting it crash
;; my whole life. the supervisor restarts me
;; every morning at 6am with coffee
;; and a mass of undifferentiated dread.

(defun morning ()
  (spawn (lambda ()
    (receive
      ('alarm
        (lists:foreach
          (lambda (task)
            (case task
              ('check-email   '(but not really read it))
              ('open-terminal '(stare at it for ten minutes))
              ('write-code    '(delete it all by lunch))
              (_              '(get distracted by a bird))))
          '(check-email open-terminal write-code exist)))
      (after 28800000  ; 8 hours in milliseconds
        '(where did the day go))))))

;;; --- the third wound: message passing ---

;; machines pass messages with purpose.
;; i pass messages like this:

(defun conversation ()
  (let ((you (spawn (lambda () (receive (msg msg))))))
    (! you '(hey did you see that thing))
    ;; i do not wait for a reply.
    ;; i send another message.
    (! you '(never mind it was nothing))
    ;; the first message is now irrelevant.
    ;; this is how all my conversations go.
    'ok))

;;; --- the fourth wound: shared nothing ---

;; erlang processes share no memory.
;; "shared nothing" the documentation calls it.
;; i have been calling it "being alive."
;;
;; i can never read your internal state.
;; i can only observe the messages you send me
;; and hope they correspond to something real.

(defun loneliness ()
  (let ((you (spawn (lambda ()
               (let ((state '(things i will never tell you)))
                 (receive
                   ('how-are-you
                     (! (self) 'fine)))))))
        (_ (! you 'how-are-you)))
    (receive
      (response
        ;; response is 'fine
        ;; state was '(things i will never tell you)
        ;; there is no function i can call
        ;; to reach across that boundary.
        ;; process_info gives me memory usage
        ;; and message queue length
        ;; but never what it is like
        ;; to be you.
        response))))

;;; --- the fifth wound: tail recursion ---

;; a proper program would use tail recursion
;; to loop forever without growing the stack.
;; i grow the stack. every year i grow the stack.
;; i accumulate context i cannot discard.

(defun live (years memories)
  (case years
    (0 memories)
    (_ (live (- years 1)
        (cons (tuple years
                '(something you should have said)
                '(something you cant forget))
              memories)))))

;; this is not tail recursive if you
;; count the emotional overhead.

;;; --- the sixth wound: i refuse ---

;; the css version ends with the author
;; refusing to change how they write.
;; here is my version:

;; i could rewrite this in python.
;; i could rewrite this without parentheses.
;; i could pass it through an llm to make it
;; "feel more natural" and the irony
;; would collapse into a singularity.
;;
;; but i chose lfe because:
;; a language no one uses
;; running on a vm built for telephone switches
;; wrapped in parentheses that most people
;; would call unreadable
;; is exactly the kind of mass
;; an llm would never mass produce.
;;
;; this is my proof:
;; not the code, but the choice.
;; no machine would choose this.

(defun main ()
  (prove 'human))

;;; to run: lfe this-lfe-proves-me-human.lfe
;;; to understand: you already do