Thread 105819961

>Lisp is a family of programming languages with a long history and a distinctive parenthesized prefix notation. There are many dialects of Lisp, including Common Lisp, Scheme, Clojure and Elisp.

>Emacs is an extensible, customizable, self-documenting free/libre text editor and computing environment, with a Lisp interpreter at its core.

>Emacs Resources
https://gnu.org/s/emacs
https://github.com/emacs-tw/awesome-emacs
https://github.com/systemcrafters/crafted-emacs

>Learning Emacs
C-h t (Interactive Tutorial)
https://emacs.amodernist.com
https://systemcrafters.net/emacs-from-scratch
http://xahlee.info/emacs
https://emacs.tv

>Emacs Distros
https://spacemacs.org
https://doomemacs.org

>Elisp
Docs: C-h f [function] C-h v [variable] C-h k [keybinding] C-h m [mode] M-x ielm [REPL]
https://gnu.org/s/emacs/manual/eintr.html
https://gnu.org/s/emacs/manual/elisp.html
https://github.com/emacs-tw/awesome-elisp

>Common Lisp
https://lispcookbook.github.io/cl-cookbook
https://cs.cmu.edu/~dst/LispBook
https://gigamonkeys.com/book
https://lem-project.github.io
https://stumpwm.github.io
https://nyxt-browser.com
https://awesome-cl.com

>Scheme
https://scheme.org
https://try.scheme.org
https://get.scheme.org
https://books.scheme.org
https://standards.scheme.org
https://go.scheme.org/awesome
https://research.scheme.org/lambda-papers

>Clojure
https://clojure.org
https://tryclojure.org
https://clojure-doc.org
https://www.clojure-toolbox.com
https://mooc.fi/courses/2014/clojure
https://clojure.org/community/resources

>Other
https://github.com/dundalek/awesome-lisp-languages

>Guix
https://guix.gnu.org
https://nonguix.org
https://systemcrafters.net/craft-your-system-with-guix
https://futurile.net/resources/guix
https://github.com/franzos/awesome-guix

>SICP/HtDP
https://web.mit.edu/6.001/6.037/sicp.pdf
https://htdp.org

>More Lisp Resources
https://rentry.org/lispresources

(setq *prev-bread* >>105711980)

M-x bad-apple
https://github.com/y-usuzumi/emacs-bad-apple

>>105820008
https://www.youtube.com/watch?v=XE4U8ieZpU4

Fly me to the Moon!
https://archive.org/details/Schemer

I'm trying to build a dockerfile for a lisp thing and I need to make the SBCL repl usable. How the fuck do I do that, or maybe start a SBCL int he container and access it remotely via sly?

Also fuck this gay earth, ASDF can't find my fucking system.

>>105820566
You are providing very little info anon.

>>105820658
Just bashing my head on the wall against devops and my lack of knowledge on asdf and sbcl. I got it working now, just needed to pepper some (asdf:initialize-source-registry) here and there.

I made a silly testing library and I plan to integrate it into gitlab's unit test thing.

TinyScheme is GREAT! (￣▽￣)b
https://bdash.net.nz/posts/sandboxing-on-macos/
https://chromium.googlesource.com/chromium/src/+/HEAD/sandbox/mac/seatbelt_sandbox_design.md

>>105820888
Check'd
Trips of TRVTH

Okays guys, hear me out — What if, we take Wings3D and rewrite it in LFE, so that we can have a Lisp version of an Erlang version of a Lisp program written in the Erlang version of Lisp?
Fucking meta woah.

Clojure>>>>>>>>>>>>>>>>>>>>>>
Pic related, Average Clojure Dev Team

>>105821488
Based & Clojuredpilled

>>105821385
>3D
Mirai.
https://www.youtube.com/watch?v=bgCgYHNq7_E
https://archive.org/details/nichimen-mirai-1.1a-portable
https://archive.org/details/izware_mirai_1.1sp2

>>105820566
Here's how lem does it.
https://github.com/lem-project/lem/blob/main/Dockerfile

https://clojure.org/reference/lisps
Learn Clojure today!

>>105821806
They just rely on quicklisp then?
I don't really like quicklisp, but it shows me I am on the "right track".
Only thing missing is making my test library spit disgusting junit xml.

I can literally "(format t "shit)" on test-cases and suites "report-test" methods because of how I've built it with clos.

>>105819961 (OP)
which lisp has the best batteries included set? i'm thinking a good GUI library and a better experience for local web applications

>SICP 1.2.2 Tree Recursion
>Exercise 1.11. A function f is defined by the rule that f(n) = n if n<3 and f(n) = f(n-1) + 2f(n-2) + 3f(n-3) if n >= 3.
>Write a procedure that computes f by means of a recursive process.
>Write a procedure that computes f by means of an iterative process.
The first part is simple enough:
(define (f n)
(if (< n 3)
n
(+
(f (- n 1))
(* 2 (f (- n 2)))
(* 3 (f (- n 3))))))

But I'm having a brainlet moment trying to wrap my head around translating this to an iterative process. I get that we're supposed to write a sub-procedure, call it f-iter, that keeps track of state, but I'm confused about exactly what state should be kept.

>>105821745
Yeah I know, Wings3D is a copy of Nendo which is a cut down version of Mirai which is itself a descendant of Symbolics S-Graphics.

Also I used the fuck out of Nendo back in the day (on Windows ME of all things lol).

>>105819961 (OP)
I never visit this general, have been a VIMman all my life, what's actually the point of lisp? I get that SICP was written for it and that it's used for emacs, but what else?

>>105822161
Just store n-1, n-2, and n-3 and update them as you iterate through.

>>105822161
Given n, how many values you need to have?

>>105819961 (OP)
>formerly ZUN's

>>105822218
>>105822227
Figured it out ty
(define (f-iter m m-1 m-2 count)
(if (= count 0)
m
(f-iter
(+ m (* 2 m-1) (* 3 m-2))
m
m-1
(- count 1))))
(define (f n)
(if (< n 3) n (f-iter 2 1 0 (- n 2))))

Post a random elisp function that you use everday but most of the pp wouldn't

>>105822505
you could use named let instead of a helper function
(define (f n)
(if (< n 3)
n
(let f-iter ((m 2)
(m-1 1)
(m-2 0)
(count (- n 2)))
(if (= count 0)
m
(f-iter (+ m (* 2 m-1) (* 3 m-2))
m
m-1
(- count 1))))))

>>105822505
Why is your function calling itself if its supposed to be iterative? Why not use 'do'?

>>105823446
NTA but I think it could be considered both iterative and recursive. The Emacs manual talks about this https://www.gnu.org/software/emacs/manual/html_node/eintr/No-deferment-solution.html#FOOT16

>>105822143
The only lisp I can think of that has a GUI lib in its standard library is Racket.
https://racket-lang.org/
https://docs.racket-lang.org/gui/index.html

>>105818412
I'm this guy, asking about how emacs runs in windows and whether I should run it in windows or in my WSL2 (Ubuntu). I'm also seeing talk about Lem. Is that worth it if I'm new to Lispy languages in general or is emacs a better starting point?

>>105824298
Linux VM, Lem works on windows but the release build is really outdated and it's probably too much of a hassle for a lisp newbie to build on Windows. Should be relatively straightforward on Linux though.
As for emacs/lem, if you're doing CL try lem, otherwise Emacs

>Land of Lisp
>Common Lisp Recipes
>Practical Common Lisp
>Programming Algorithms in Lisp
>The Common Lisp Condition System
Currently deciding which to buy. Which of these are worth reading? I have the fundamentals from other lisps, but I really wanna dive into CL and CLOS. Thinking of just buying them all but I'm sure there's lots of overlap, and I'd rather not waste $225.

>>105823446
i haven't gotten that far yet chillax brah brah

>>105824960
they are all free on libgen

What are the steps to install Common Lisp on a Windows system? Lem, SBCL, Quicklisp, Sly etc. Kindly share the installation guidelines.

>>105823446
Responding to myself, I looked up solutions seems everyone does "iterative recursion" I guess since I only deal with CL I just consider tail recursive functions to still be recursion not iteration, even though they "unroll" to iterative functions and that's why they're efficient. In any case what you did seems to be what the book wanted anyway.
I should really read SICP one of these days lol.

>>105825304
I just figured if the problem is asking for an iterative solution that they'd introduced iteration primitives.

>>105825830
No shit. I need physical books.

I can't be the first person to make this joke.

>>105824298
WSL is good enough.

>>105825943
You can get anything in Docker these days.

>>105822760
>Post a random elisp function that you use everday but most of the pp wouldn't
(defun ips-patch (buffer address data)
(with-current-buffer buffer
(hexl-goto-hex-address address)
(hexl-insert-hex-string data 1)))

; add 1 gold each frame
; 001ffac0:
; 303c 0001 move.w #$0001, d0
; 4eb9 0001 0328 jsr AddGold
; 4e75 rts

(ips-patch
"a.bin"
"1ffac0"
"303c 0001 \
4eb9 0002 0328 \
4e75")
I don't think most people mess with game roms in emac

>>105825943
>What are the steps to install Common Lisp on a Windows system?
winget install sbcl


In Emacs, you'll want to do this:
(setopt inferior-lisp-program "\"c:/Program Files/Steel Bank Common Lisp/sbcl.exe\"")

Can someone PLEASE explain to me how to import the raygui package from this project?
https://github.com/bohonghuang/claw-raylib

>>105829541
Isn't it just :raygui? I think there's three packages, :rlgl, :raylib, and :raygui.

>>105829675
(unless (find-package :claw-raylib)
(ql:quickload :claw-raylib))

(defpackage :my-game
(:use :cl :alexandria :cffi :cffi-ops :claw-raylib))

(in-package :my-game)

(find-package :raylib)
; => #

(find-package :raygui)
; => NIL


What am I doing wrong then? The raylib package works just fine.

>>105829873
(cffi:define-foreign-library libraygui-adapter
(:unix "libraygui-adapter.so")
(t (:default "libraygui-adapter")))
(progn
(cffi:use-foreign-library libraygui)
(cffi:use-foreign-library libraygui-adapter)
(push :raygui *features*))
(cffi:load-foreign-library-error ()
(when-let ((package (find-package '#:raygui)))
(delete-package package))))


Maybe something's going wrong in setup that's deleting the package. A while back they made raygui optional so it's probably that logic causing it to not load.

>>105829910
Yeah I was poking around and saw that, but loading it from the REPL works fine.
CL-USER> (cffi:load-foreign-library "~/quicklisp/local-projects/claw-raylib/lib/libraygui-adapter.so")
#

I'm a complete beginner to CL so any ideas on how to debug this?

>>105829980
That code runs whenever you quickload it. So for starters, go into your ~/quicklisp/local-projects and just get rid of the error handling bit altogether. Then it'll try loading raygui for sure and if it has an error you're at least gonna see it.

>>105830018
Thanks, I see what's going on now. It's loading libraylib.so from my /usr folder(which was installed by DNF), and I manually installed the raygui.h file into my includes, but not the compiled library file. Sorry for retard

>>105830169
That makes sense, glad you figured it out

One thing I'm struggling with while writing elisp is literally how to type it. I have a bit of trouble keeping track of my nesting level, and as a result, while I'm writing a function or whatever, I have the closing paren of a large expression be on its own line until I'm finished, so something like this:

(defun foo ()
"Docstring"
(interactive)
(goto-char (point-min))
(let ((blah "blah")
)
(bloh blah)
)
)


Once I'm done I move the closing parens back
(defun foo ()
"Docstring"
(interactive)
(goto-char (point-min))
(let ((blah "blah"))
(bloh blah)))

The problem is that this feels awkward and reminds me of how retarded I am, is this just a thing that gets easier with practice or am I missing something?
I'm just glad I found the package that makes parentheses get entered in pairs, counting the nesting by hand was even worse.

>>105830356
I don't remember having this issue in the beginning but it might be one of those things that you quickly get used to. Definitely don't do what you're doing of writing in the other form first and then refactoring, just get used to the plain way of doing it. There are only a couple of types of indentation so shouldn't take too long to get used to. Also enable rainbow parens if you don't have them, helps in the beginning.

>>105830545
I have rainbow parens, thankfully, I think part of my issue is being used to C syntax where I can have braces wrapping the nesting.

>>105830559
I came from C as well, takes a little bit. Just keep it up

Tell me about kill-sexp, mapped to C-M-k by default. Its use is obvious in Lisp, but what about plain text or Markdown?

>>105830599
I use it all the time, it's like a more intelligent kill word. So you can clear out stuff that's quoted, a word with hyphens in it, etc.

>>105824960
>>Land of Lisp
no
>>Practical Common Lisp
maybe

>>105830356
>>105830559
Uninstall rainbow parens and install paredit.

>>105830356
You rarely need to manually format stuff, electric-pair-mode handles paired parens
Also if the cursor is on the first paren in this expression
(let ((x 1)
(y 2))
(+ x y))
C-M-d C-M-d moves down to ((x 1) (y 2)), where C-M-f and C-M-b moves forwards and backwards across the let bindings
C-M-t (transpose-sexp) on the opening paren of (y 2) swaps them
(let ((y 2)
(x 1))
(+ x y))
C-M-u moves up from the let bindings, then moving forwards and down to x in (+ x y) and doing M-x raise-sexp does
(let ((y 2)
(x 1))
x)
(this is just default emacs btw)

wolfram im rite
>Wolframite: Bring computational intelligence to Clojure (by Jakub Holý and Thomas Clark) - London Clojurians (https://youtu.be/rQ1hpYZSjuY + https://github.com/scicloj/wolframite)
https://clojure.org/news/2025/07/06/deref

>>105821745
https://s-graphics.neocities.org

I love Lisp!

>>105830356
> )
(bloh blah)
)
)

>>105834161
>S-Graphics was one of the first commercially available 3d graphics and animation packages, and the first integrated 2d/3d system.
Interesting

Had to take a break from SICP. I realized around exercise 2.32 that I wasn't absorbing enough from prior sections. Decided to step back and spend a week or so building and transforming lists and trees using only cons where possible and, in the spirit of the pedagogy, doing everything statelessly and purely functionally. I'm currently trying to implement a generalized function
(map-f-n tree f n)
Which traverses the tree and builds a new tree where for every value x at depth y of the original tree, there are n instances of f(x) at depth y... without doing a postprocessing pass. I'm finding it incredibly hard but I feel that if I can implement this, I'll come out the other end with a very strong computational command of tree/list/general cons operations. Wish me luck bros.

>>105821745
>>105834161
I feel like a birb

>>105837546
I feel like a man with a stone

Apply, immediately!

The Lispy Gopher Show
https://anonradio.net/
https://time.is/compare/0000_9_July_2025_in_UTC
It'll start in about 8 hours from time of posting.

Hosted by @screwlisp
https://gamerplus.org/@screwlisp

Live Chat
https://lambda.moo.mud.org/
(What's a good MUD client for Emacs?)

This feels like the place to ask. I've run into a problem with lisp/scheme DSLs where they're always an order of magnitude slower than the stuff that SBCL or Chez has built-in. I feel like it's a skill issue with how I'm writing my macros, but I haven't really been able to make much progress figuring out how to un-retard myself, and I can't find any resources to help either. Anybody got any tips on making complex macro-emitted code work faster without writing my own optimizer pass? Just some kind of "design guidelines", my naive approach has gotten me nowhere.

>>105819961 (OP)
>Sneed's Feed & Seed
>Chuck's Pluck & Truck
Pretty funny they had to change the name because most people are infantile in their thinking.

>>105839028
What do you mean by slow? Like they take a long time to compile?

>>105839028
Show us an example of a suboptimal DSL implementation.

>>105839028
Hard to say for sure without seeing what you're working on, but a quick general tip is to be very wary of poorly optimized list operations. Many Lisps implement all data structures as linked lists and accessing an array index sometimes isn't a simple O(1) memory-address lookup. They can get very expensive. Just something to look out for, if that helps.

>>105839028
That's strange, macros should compile down into the same code as usual. In theory there should be no difference between using a DSL and manually writing the code.

I love tramp and eshell.

>>105839321
>Show us an example of a suboptimal
>DICK
>SUCKING
>LIPS
>implementation

>>105839720
> eshell
On contract I was working on a completely locked down windows box, detects cmd.exe is is running and kills it, etc. had to edit in “word”
Found I could send my self programs and run them.
Sent myself the self-contained emacs build.
Ran eshell. Env now no different from home, everything works again.

I feel that the plan 9 shell, rc, should have been something closer to eshell.

Started writing tests and test cases in it.
Blew the minds of the government employees.

What's the usecase for syntactical purity?

>>105840034
Mostly convenience. Macros are easy to write, better extensibility, consistency/predictability, etc.
In my case even if the former wasn't true I just honestly like how it reads and feels to type, it's surprising how much you don't need a rich/bloated language syntax coming from other languages.
Also love being able to use it for both implementation/configuration, though that's not necessarily due to syntactical purity.

>>105837546
Someone should come up with a processor or coprocessor, or maybe an ARM instruction extension for lisp so it basically runs in hardware.

Or maybe a GPU-like thing. An ‘LPU’ if you will with 8192 LCUs.

We used to have transputers, what the hell happened?

>>105840120
I've thought of doing this with FPGAs but haven't had time or an excuse really lol

trying out clojure and it's quite comfy bros, ngl
made a utility for postgres->postgres database migration with non-trivial field transforms and selective export to .xml for a project at work, and quite liked the approach to datastructures it has and the convenience built up around maps and vectors
almost makes me want to build a set of reader macros to have the same tooling in CL for a personal project, that's how nice it was
oh and lisp1 > lisp2 any fucken day, separate namespaces are annoying as hell

>>105840493
>oh and lisp1 > lisp2 any fucken day, separate namespaces are annoying as hell
I've never understood this, besides not needing funcall how does lisp2 negatively impact you? I still prefer it, especially if I'm using CLOS a lot

>>105840547
>besides not needing funcall how does lisp2 negatively impact you?
hurts my feelings

>>105840007
>Sent myself the self-contained emacs build.
Can you detail this more? its been a almost 7 years without touching windows and I fear I will be in your same situation very soon.

i want the rest of my books
NOW
O
W

>>105840547
it's the funcalls being fugly, and making function symbols different from every other kinda symbol places undue stress on my small brain

>>105841140
I actually didn't like that book desu

>>105841196
Why not?

>>105839720
>>105840007
I've never been convinced. I tried to use it for PowerShell on Linux and it totally failed.

>>105830627
Oh my fucking god it works on XML.

>>105839720
lately i've been using eshell more and more. i just wrote a little command for dired that's useful when i'm running multiple instances of eshell
(defun dired-eshell ()
"Start eshell in current subdirectory. If an eshell buffer already
exists with the subdirectory as its working directory, switch to it or
select its window."
(interactive)
(let ((dired-directory (dired-current-directory))
(eshell-buffers (match-buffers '(major-mode . eshell-mode)
(buffer-list))))
(when eshell-buffers
(setq subdir dired-directory)
(setq eshell-buffers
(cl-remove-if-not
(lambda (b)
(with-current-buffer b
(equal (expand-file-name default-directory) subdir)))
eshell-buffers)))
(cond ((and eshell-buffers
(get-buffer-window (car eshell-buffers)))
(pop-to-buffer (car eshell-buffers)))
(eshell-buffers (switch-to-buffer (car eshell-buffers)))
(t (let ((default-directory dired-directory))
(eshell t))))))

(keymap-set dired-mode-map "z" #'dired-eshell)

How can I fix ido mode's aggressiveness? Sometimes it just goes to a random fucking thing after one char.

>>105841218
Bad Lisp style

>>105840547
don't need 10 different let forms anymore.
don't need seperate defun/defvar

I wish there was a decent implementation of first class macros out there to get rid of that seperate form too, and also the inconvieniently impossible (apply or ).

I feel like cluade is quite good at making lisp

>>105845557
How? I've felt it was terrible.

>>105845581
Package level shit was developed at once, and it just works

>>105845557
I've found that chatGPT can produce functional lisp for the most part but for algorithms requiring an even slightly novel and nontrivial solution, it shits the bed. Stateless, functional solutions are very much hit or miss and mostly misses. It's good at boilerplate, mostly-imperative kinda "why are you doing this in Lisp" things.

>>105845935
Claude is way better for lisp in my experience

>>105845581
>>105845888
I mean, cuz elisp has long history, many kind of package codes could have been trained. Many fancy new frameworks based on rust or some other languages can't be understood by llm easily

>>105845935
>It's good at boilerplate, mostly-imperative kinda "why are you doing this in Lisp" things.
That's exactly what I think as well. They both write Lisp as if it's Python and if you're going to write like that then why bother?

PSA:
>TL;DR: The best way to advertise your favorite programming language is by writing programs. The more useful the program is to a wider audience, the better advertisement it will be.
https://www.stylewarning.com/posts/write-programs/

>>105846836
While I agree with the main point, I wonder why he considers compilers "not useful."

>>105838850
I've missed this 3 weeks in a row. I seem to get sleepy around the time this show rolls around and take a nap only to wake up a few minutes after the show ended.
https://archives.anonradio.net/202507090000_screwtape.mp3

>>105847127
My guess is that "useful" has an implicit "(to normal people)" attached to it. For example, yt-dlp is useful to normal people who are not programmers.

Is it possible to "print" what asdf is doing when it links everything? The requires, loads etc.

>>105849743
>Function: compile-system system &rest keys &key force force-not verbose version &allow-other-keys
>Function: load-system system &rest keys &key force force-not verbose version &allow-other-keys
Does the :verbose key print stuff? Not sure if this is what you mean by link time

Holy fuck bros, im gonna start my journey towards becoming a lisp wizard in a few hours!

>>105849980
I feel smarter already

>anon making a big deal about scheme being better than common lisp because it's "simpler and more elegant" and common lisp has a "large specification document"
>common lisp reference pdf: 56 pages
>guile scheme reference pdf: NINE HUNDRED EIGHTY ONE PAGES

>>105850496
based GNU verbosity

>>105850496
Reference =/= manual
good morning sar

>>105850279
I did not like "Programming Algorithms in Lisp" the author does not write/teach well and relies on some ghetto third party library to pointlessly change syntax.

>>105850887
Yes you told me yesterday. I will shoot it if I don't like it

>>105850915
Different anon

>>105850915
Did I? I don't remember posting that, maybe someone else felt the same lol.

>>105837546
Old graphics demos from the 90s and turn of the century are max comfy.

>>105850279
Personally I would have recommended any of:
A Gentle Introduction to Symbolic Computation
Lisp 3rd edition
ANSI Common Lisp
On Lisp

But also just pirate all of the books and sort if out for yourself.

>>105851055
>>105851069
My bad. Since 2 of y'all are hating, I'm gonna skim through it first and return it if it's shit. Thanks frens
>>105851128
Any specific reason you'd choose those books over the r*ddit recommendations?
>pirate all of the books
Call me a retard but I can't read books on a screen without zoning out.

The CL reference that I use the most is:
https://lispcookbook.github.io/cl-cookbook/
It's free and its content is very practical.

>>105851480
that's not a book

>>105851501
the nerdfag arbitrary obsession with books must be studied

>>105851522
>obsession with books
>arbitrary
ok retard

>>105851522
come say that to my face while im reading a lisp book in between sets of curling your mom

>>105851616
>>105851629
>if my knowledge doesn't come in paperback form, I don't want it!
I bet you take your books out in public and look around while "reading" to see if anyone noticed that you're reading

>>105851480
is there an info version? i'm so used to just hitting C-h i to check the docs when i'm writing elisp or guile

>>105851645
The closest I get to "out in public" is my pond or pasture, where basically only my wife and other animals would see me

>>105851671
The source is mostly markdown.
https://github.com/LispCookbook/cl-cookbook
Someone could maybe figure out a way to get pandoc to consume this markdown and emit texinfo.

>>105851736
His build scripts already merge all the markdown documents into one gigantic markdown document.
https://github.com/LispCookbook/cl-cookbook/blob/master/make-cookbook.lisp#L88-L93
He uses this to big markdown file as the source for his epub and pdf outputs. A texinfo output could easily be added to this.

>>105851779
Loading up sly,
compiling make-cookbook.lisp with C-c C-k,
and then running:
(build-full-source)

worked.
Then I ran:
pandoc --from gfm --to texinfo full.md -o full.texi

and that worked too.

However, the texinfo that was generated by pandoc was giving the GNU tools for generating info files indigestion.
# I tried to force it, but it refused to generate output, because too many errors were found in the source document.
texi2any --info --force full.texi -o cl-cookbook.info

>>105852074
I was able to do one file at a time, but that's not very useful.
pandoc --from gfm --to texinfo index.md -o index.texi
texi2any --info --force index.texi -o index.info

Then, in Emacs, `C-u C-h i` and then select index.info.

>>105851779
>A texinfo output could easily be added to this.
Not so easy after all.

>>105851184
>Any specific reason you'd choose those books over the r*ddit recommendations?
Because I find them to be higher quality and better written (seems to be the case generally, literacy and competency has been on a long decline and it's extremely noticeable in the scientific literature, the farther back you go the better written and more well thought out things tend to be (granted it could also just be that no one bothers to read the shitty old papers but I've still found it to be generally true despite just digging up random, obscure old papers)). They're old (mostly from the 80s) but (most) of what they cover hasn't really changed. Granted if you want to do anything "modern" you're better off checking the Common Lisp Cookbook for a run down of current libraries and such.
To be fair I haven't read your other books (Common Lisp Recipes or The Common Lisp Condition System). Nothing against PCL it's a fine book, but reads more like a reference and doesn't have exercises.

>Call me a retard but I can't read books on a screen without zoning out
Even if you've got Emacs up next to a PDF trying things out as you read? I feel like I may have had that issue in the past but at some point got over it, probably just as a matter of conditioning since I almost always pirate books, if I am able.

>>105851671
I wish I could get every lisp book or other useful document in info format. It would be so convenient.

>>105852254
Prot's Emacs Lisp Elements has an info version. However, I think the best version is the org version. Org is nice, because the code blocks are syntax highlighted and exectuable via `C-c C-c`.
https://github.com/protesilaos/emacs-lisp-elements

>>105852293
Org vs Info

>>105852343
One of these days I should figure out org mode.

>>105852381
The basics of org are simple. It's an outliner where you organize text under headings.
M-RET is how you create a heading.
M-arrowkey will move the headings around.
You can start with just that. Just play with it.

Here's an abbreviated version of my org setup in case you're curious.
https://pastebin.com/sb12cEmx
The full version rices it out more for looks, but I didn't want to overwhelm you with that. The part I included makes it look decent enough and behave well with regard to code blocks. (I don't like the default settings which do some retarded things with indentation.)

>>105852518
Oh, and TAB toggles heading visibility.
S-TAB will close everything.
The basics are easy.

>>105852381
Look at how Prot writes his org documents. He sets a good example (as usual). I've used org for a long time, but I'm learning new things from his example too.

After having read a lot of web discussions about LISPs, I come to the conclusion that the only remotely viable LISPs are Clojure and SBCL. (And Emacs Lisp for customizing Emacs) Am I wrong?

>>105855001
>Am I wrong?
Not really. SBCL is an implementation though, CL is the language. ECL/CCL/LW/etc. can be viable too as part of CL.

>>105855001
Oh, and also Julia. I forgot that Julia is also a LISP.

>>105855001
viable for what?

>>105855133
Like, actually useful pairs of (language interpreter) which let you create good software.

I got fed up with vim and switched to emacs and spent the last 6 hours making it work with tmux because they weren't getting along
given that my goal is to spend my time as unproductively as possible, so far I give emacs a 9/10 but will be revising that as I work

>>105855001
>the only remotely viable LISPs are Clojure and SBCL
TinyScheme mogs both, see >>105820888
>Sandbox policies are written in a dialect of Scheme known as SBPL. The policies are interpreted via an interpreter within libsandbox, based on TinyScheme, which generates a compiled representation of the policy that it passes to the Sandbox kernel extension.
>much of the implementation and resulting behavior are shared with Apple's other platforms (iOS, iPadOS, tvOS, etc)

>>105855127
> julia
Doubt.

>>105855582
> Viable
I used david betz’s xscheme for some real world stuff back in the day, must have been in the 80s.

>>105855563
>tmux
why limit yourself to the terminal? emacs is better as a graphical editor

>>105855563
I like elisp/emacs, but sometimes I feel it’s a little bit slow to be doing the kinds of things it’s being asked to handle.

If it were me, I’d drop some of the C implementation and speed up some critical points with some x64 assembly.
…not drop the C implementation, just override on some architectures. Maybe there’s a SIMD instruction that can implement cadar in one clock cycle.

New Helix plugin written in Steel (Scheme) just dropped
https://github.com/helix-editor/helix/pull/8675#issuecomment-3049527924

>>105856141
https://github.com/thomasschafer/scooter.hx

>>105819961 (OP)
>http://xahlee.info/emacs
Has he had sex yet?

>>105856176
SEXP with 2hu grills? Yes, zoomer faakhead.
http://xahlee.org/wordy/chinese/phantasmagoria_of_flower_view.html

>>105856176
He's married. He has been a regular sex-haver for quite some while now. He's not one of us.

>>105846836
trvke

>>105856146
kino visuals

>>105855563
With enough emacs skill, `emacs --daemon` can be used instead of tmux. Not a lot of people do this, but I've setup my shell to run and manage multiple emacs daemons easily, and it has a similar feel to having multiple tmux sessions. What's nice is that you're not limited to a terminal. You can use the graphical version and the terminal version in the same session at the same time.

>>105856141
Helix has a chance to do a lot of things right. I'm wishing them well.

>>105856141
It just occurred to me that Helix plugins can use real OS threads if they want to. They get full access to the Rust ecosystem too.

Thinking back to
>>105846836
I think helix can onboard a lot of people on to both Scheme and Rust.

>>105856141
There are just 3 helix plugins.
https://github.com/npupko/awesome-helix?tab=readme-ov-file#editor-extensions

>>105857420
why go with "steel" scheme instead of guile? schemers stop dividing themselves up challenge (it is impossible)

I build helix+steel from source and installed scooter.hx. There were a few minor hiccups, but it wasn't too bad.

>>105856025
>Maybe there’s a SIMD instruction that can implement cadar in one clock cycle.
How? It's all nonsequential on the heap. The only way around that seems to be allocating cons cells contiguously a la conventional arrays and turning cxr into a kind of obfuscated access by index. Maybe I'm far outside my lane here but I am curious what your ideas are.

I have determined after much fuckery that it isn't guile's fault the process control and system call functions are a pain in the ass, that's just how UNIX works.
It's just a horrible system that's both very obsessed with security to the point of being a huge overcomplicated pain, and then simultaneously has zero restrictions so you can do fucking anything, even bricking your entire computer, even by accident, easily. It's a total shitshow.

>>105857915
Just guessing, but maybe interop with Rust was easier this way.

>>105859091
I won’t disagree, unix came from having many users on a single machine over serial terminals.
Nowadays, a lot of companies run everything in containers and VMs on to of all that!

>>105855978
> Xscheme on DOS
This was probably pretty fast for it’s time. Explains how >>105837546 lisp machines could be so good.

>>105858950
Something like that, yes…
I was actually thinking of allocating on the code page and interleaving cons cells with instructions to improve locality and being more into the cache-line/L1 tagged areas and using IP-relative addressing. Working sets in the 32 KB neighbourhood seem reasonable for the slow “key algorithmic” parts of any program (tree transformation, searching, etc.)
I think the benefits far outweigh any potential pipeline stalls since it’s not that compute intensive on the fxu usage that full pipelines benefit.

>>105857063
The only thing I really miss about emacs in non-graphical mode under tmux is the alt key in org mode.
I was stuck once, then I realized ESC is meta, too, in tmux.
I use graphical mode inserting metapost diagrams and whatnot. I think there’s three potential ways around it:
- use a font for graphics. I think this is what the tex picture environment does, but using the line drawing characters might work ok to give a representation.
- use the block characters and render minecraft-like pixels
- tmux has a patch for sixel. I actually think sixel would be better implemented in terminal/shell graphical emacs mode (and then use that instead of tmux)

>>105857910
Yeah, helix is not implemented in steel enough, it’s more of an ex-post -facto bolt-on.

We're going to fall off

>>105857915
>Both Guile and Chibi were considered because they implement the r7rs spec and are intended for embedding. Guile would be preferred but there are no complete bindings for it in Rust and I've seen that there's some issues with it breaking rust's destructors (https://github.com/ysimonson/guile-sys).
https://github.com/helix-editor/helix/pull/2949#issuecomment-1186159322

>>105862994
Thanks for finding this. I looked around last night for some kind of explanation, but couldn't find one. I did come across this interesting old HN thread though.
https://news.ycombinator.com/item?id=38508779
You can search for "mattparas" to find comments from the author of Steel.

If you have any connection to Perl, you can also search for "mst" to see an unexpected interaction from the late Matt Trout.
https://www.shadowcat.co.uk/2025/07/09/ripples-they-cause-in-the-world/
https://togetherweremember.com/timelines/qn/view

>>105855127
Julia is not a Lisp, but I wish there were a thread like this where I could talk about it sometimes.

Does anyone know how to get ts-fold working? I followed the readme and even read through the issues, but when I activate c-ts-mode, it says 'no language registered' and it's pissing me off

>>105863640
It's shit. I'd sooner pick R.

so what the hell can i actually do with lisp besides jerking myself off ive had enough of that recently, can i make vidya are there any engines or would i have to roll my own game

>>105851055
>>105851069
I was hesitant about what yall were saying and was going to ask for examples, but I'm going to return it just because of pic related.
>>105852234
I see. Unfortunately it looks like those books are pretty expensive nowadays, so I'm going to stick to what I got. Soubt I'm missing out on much. Also, I typically don't do the written exercises in programming books unless I genuinely don't understand the concept being discussed, I'll just develop a program as I'm reading to book and immediately integrate concepts into new functionality.
>>105852234
>Even if you've got Emacs up next to a PDF trying things out as you read?
Yeah. I need to lock in on the book for a chapter, then lock in on my IDE as I make sense of what I read and implement it, and only take quick peeks at the book as needed. Part of it is that when I read very dense texts(ie. books), I tend to skip ahead a little and then lose my position. I need my fingers to mark what I'm reading. I'm stupid

>>105864761
Amazon gave me a refund for it without having to return the boom, so I guess I'll read it as some point in the future.

Just got my AR glasses. Installed termux-x11 on my phone, and currently setting up doom emacs. SBCL is available on termux. I can now write CL with the same exact setup as my desktop on the go while completely offline. Only issue is the battery drain.

>>105865786
>AR
Based

Is it possible to make imenu work with info manuals in Emacs. I think it could improve info manual navigation a lot if such a thing were possible. If not, maybe a function like consult-info-section could be written such that you could jump to any node in the current info document via consult (if you're a consult user).

>>105856141
Is there a way to open a Steel REPL while running hx (similar in spirit to Emacs' `M-x ielm`)?

New Elisp from Prot:
https://protesilaos.com/codelog/2025-07-07-emacs-mct-1-1-0/

>>105869071
Maybe
https://mattwparas.github.io/steel/book/start/standalone.html

>>105855127
>>105863640
Julia is very lispy desu
>The Julia parser is a small lisp program written in femtolisp, the source-code for which is distributed inside Julia in src/flisp.
https://docs.julialang.org/en/v1/devdocs/eval/#dev-parsing
https://github.com/JeffBezanson/femtolisp
>The strongest legacy of Lisp in the Julia language is its metaprogramming support. Like Lisp, Julia represents its own code as a data structure of the language itself.
https://docs.julialang.org/en/v1/manual/metaprogramming/
Also, great emacs support: https://github.com/gcv/julia-snail

>>105869071
I searched through the source of his helix fork, and I found no mention of a REPL. Maybe someone has to take the example from:
>>105872668
https://mattwparas.github.io/steel/book/start/embedded.html#embedding-the-steel-repl
...and write a Steel REPL plugin.

>>105873858
It's lispy but it's not a lisp, its syntax is essentially python and the code you write itself isn't homoiconic. No one is gonna look at Julia and think "that's a lisp". It's a neat language otherwise though.

>>105873858
Julia's REPL has a lot of Emacsisms in it, too, like a kill ring.
https://docs.julialang.org/en/v1/stdlib/REPL/#Key-bindings

>>105874375
>its syntax is essentially python
So is Rhombus: https://rhombus-lang.org
Or alternatively, OpenDylan: https://opendylan.org
Still LISPs.

>>105874530
I think you stop being a lisp when you ditch s-expressions.

damn i didn't realize emacs came with an oop library

>>105873858
If juilia is a lisp than so is javascript because of json.

You just have to glance at it to know it’s not a lisp.

>>105874564
>I think you stop being a lisp when you ditch s-expressions.
Most LISP dialects indeed use S-expressions, but some deviate from this. For example, the original LISP 1.5 used M-expressions.
https://www.softwarepreservation.org/projects/LISP/book/LISP%201.5%20Programmers%20Manual.pdf

>>105874530
Also Logo
https://en.wikipedia.org/wiki/Logo_(programming_language)

>>105874530
It's like the one-drop rule.
You might have some lisp DNA, but you're still a nigger.

>>105869071
It's not quite a REPL, but it's better than nothing.
https://github.com/mattwparas/helix/blob/steel-event-system/STEEL.md#writing-a-plugin
:evalp will let you evaluate an expression
:eval-buffer will evaluate the current buffer

The instructions for enabling these commands are slightly wrong. The way I got it to work was putting this in init.scm.
(require (only-in "helix/ext.scm" evalp eval-buffer))

Note the extra ".scm" that's not currently in the instructions in STEEL.md.

To use :evalp, be in normal mode and then:
:evalp RET
(+ 1 1) RET

To use :eval-buffer, be in a buffer containing Scheme code and:
:eval-buffer RET


I wanted to hit M-x while in insert mode so many times.

>>105874375
Julia might superficially look like Python at first glance, but it's quite different once you get into it.
- white space is NOT significant. (Indent however you want.)
- It has real lambdas.
- You can specify types for function parameters, struct slots, variables, etc.
- It has a macro system.
- It can feel like an interpreted language when used from the REPL, but it's actually compiled under the hood. The compilation happens automatically though.

>>105875498 >>105874822 >>105874639 >>105874530
sirs do not redeem the julia
https://gist.github.com/digikar99/24decb414ddfa15a220b27f6748165d7

>>105875556
That's one guy. Here's someone who switched from CL to Julia and stayed.
https://www.tamaspapp.eu/post/common-lisp-to-julia/
https://juliapackages.com/u/tpapp

He's the original author of cl-data-frame.
https://github.com/Lisp-Stat/data-frame
https://github.com/tpapp/cl-data-frame

(I like both CL and Julia. I know and appreciate that Julia's method dispatch style comes from CL's defgeneric/defmethod.)

https://sachachua.com/blog/2025/07/emacs-open-urls-or-search-the-web-plus-browse-url-handlers/

https://sachachua.com/blog/2025/07/emacs-open-urls-or-search-the-web-plus-browse-url-handlers/2025-07-11_17.07.10.webm

>>105822199
The point of Lisp is being both very simple and very expressive.

Does emacs have anything good for prolog?

>>105876417
https://www.swi-prolog.org/IDE.html

>>105876203
>https://sachachua.com/blog/2025/07/emacs-open-urls-or-search-the-web-plus-browse-url-handlers/
pretty nice

>>105822199
The point is to be able to write complex programs as functions of abstract, generalizeable procedures very quickly. Because functions are first-class citizens, you can very quickly and naturally write compositions of those functions themselves. Because any Lisp program is itself data, Lisp has full self-reflection capabilities.

The cost is an incredibly steep learning cliff which requires (unless you're Dijkstra reincarnate) intense effort over prolonged time.

>>105876203
I know the guy she helped. He wants so much from Emacs, but he won't level up his own Elisp. She is a saint for doing all that.

Apparently glowies are still using CL:
https://www.youtube.com/watch?v=of92m4XNgrM
>you must be eligible for a clearance
>you must move to the united SSnakeSS of AmeriKKKa

>>105862622
>fall off
why
elaborate it

>>105880391
The thread was probably on page 10 of the catalog.

>>105880144
That has nothing to do with glowies, all sorts of shit requires a clearance.

>>105880484
This. Any other reading is wrong because we've already fallen off as hard as is possible. Imperative won. The only FP remaining in the mass market is gestural rather than structural.

i don't get org mode
you just take notes
wow you can make them into TODOs
i can... le schedule things??
cargo cult says I

>>105881353
I only use it when my document need the results of code embedded. For everything else, Markdown is enough for me. The scheduling aspects of Org Mode are probably valuable, but my schedule has never been more complicated than what a calendar and a to-do list can manage. I will likely care more about Org Mode after I have read the Getting Things Done book.

Is there anyway to be able to load McClim from inside Emacs with SLIME?
I get some error about different versions of swank conflicting or some shit. Found a post on reddit but it's not very helpful just says to not have two different conflicting versions of swank. But I don't know why I have two different conflicting version or how to fix it.

I can of course run SBCL and load McClim separately and connect slime to it but it's annoying to have to do that.

>>105881661
I ran it with sly with no problems. I started with this code:
(defpackage "APP"
(:use :clim :clim-lisp)
(:export "APP-MAIN"))

(in-package :app)

(define-application-frame superapp ()
()
(:panes
(int :interactor :height 400 :width 600))
(:layouts
(default int)))

(defun app-main ()
(run-frame-top-level (make-application-frame 'superapp)))

Then in Emacs, I did `M-x sly`, compiled the source with `C-c C-k` and typed the following into the REPL:
(ql:quickload :mcclim)
(in-package :app)
(app-main)

Slime should be able to do that too. Can you post the relevant parts of the error message you received?

>>105881947
https://mcclim.common-lisp.dev/

>>105881947
Well I figured it out, sort of. Running (ql:use-only-quicklisp-systems) first fixed it. Apparently quicklisp was going into my ~/common-lisp/ folder where I've got a clim version of lem, and going into it's qlot folder where there's a whole bunch of shit and loading a version of swank from there for some reason.

Anyway to fix such retarded behavior? I never expected quicklisp would go rifling through random projects to find packages before loading its own version.

On another note, if you have multiple dists in quicklisp and multiple of them have the same system is there a way to specify which to get it from? quicklisp's "manual" leaves a lot to be desired.

I have an idea I want to run past your bros. Imagine a minimal lisp where each value can fit into a register, so (f x y) means
f:
mov eax, [esp + 4]
mov ebx, [esp + 8]
...
ie the functions compile directly to machine code and there is no need to statically declare the types of variables as everyone is the same type already. This lisp has a built in function called compile, (compile f) will compile the sexpr given to it but it will also recursively step into f and expand any macros. The compiler itself is a runtime with a stdlib etc, you can use a mathematica style algorithm in which you continously run macro's on a expr until it's reached a final form. I think something like that could be a really powerful C alternative, Rust etc are just C++ alternatives which try to do zero overhead abstractions. There isn't actually anything I would call a C alternative, languages with predictable assembly output.

>>105853950
Very nice
https://protesilaos.com/codelog/2025-07-05-emacs-doric-themes-0-2-0/

So I was thinking, my emacs config is kind of a janky pile of shit and stuff that probably conflicts because I don't really know what I'm doing, despite trying to keep it simple and lightweight, and I've already got chemacs setup.
Is it worth it to make a different setup for different purposes? Like one tailored to being a C or C++ IDE, another for Lisp dev, and so on, so as to not load useless shit (all the C and C++ crap) if I don't need it.
What are the potential downsides of this?

>>105884630
>as to not load useless shit (all the C and C++ crap) if I don't need it.
you can just use with-eval-after-load to eval the entire configuration of a specific mode only once that mode is loaded by emacs. like this:
(with-eval-after-load 'sly
(setq inferior-lisp-program "/usr/bin/sbcl"
sly-mrepl-history-file-name "~/.emacs.d/.sly-mrepl-history")
;; etc.
)

>>105880870
Haskell found its way to all languages, from Common Lisp to Rust.
FP won BIGLY.

>>105884829
Nice, thanks.

>>105877987
thats not emacs

>>105882861
>languages with predictable.assembly output
think slightly bigger anon, think languages that can predictably and efficiently output to specific bytecode.
assembly is not an entirely simple mapping to bytecode, that depends on the assembly dialect. much complexity left hidden if not arbitrary binaries as goal. it should even be able to compile to jpeg and mp4.

>>105884630
Ever since Emacs got --init-directory, setting up multiple configs has been easier than ever. I say go for it.

>>105882861
>Imagine a minimal lisp where each value can fit into a register
Well car and cdr used to fit into a single register

>>105856141
I feel like this would be a good candidate for a first plugin.
https://github.com/helix-editor/helix/issues/1125
Someone could write the helix equivalent of auto-revert-mode that'll automatically :reload a buffer if it changes on disk, and the people who like that behavior can use it.

This issue if 4 years old. Scheme can be the hero if it can satisfy the people who want automatic reload of externally modified buffers.

I like to move items from one comma separated list to another. Are there any good Emacs tricks for this? Zap-to-char is the best that I've found. I wish that kill-sexp would recognise commas.

My lists are like this. What's the quickest way to move your mother to done?
>To do: Your mother, find love, eat healthy
>Done: Foo, bar, baz

>>105886066
jesus christ just use org-mode

>>105886066
In evil-mode, I would do:
- dt, to copy "Your mother"
- 2dt, to copy "Your mother, find love" or
- D to copy "Your mother, find love, eat healthy".
- If you only deleted one or two things, go ahead and delete the stray comma and space.
- Then, I'd put my cursor on the F and hit M-y which is bound to consult-yank-pop for me and paste in the text I want.
- Don't forget to add a comma after pasting.

>>105886180
Why? My entire list is two fucking lines.

>>105886272
The stray comma and space is also where I struggle.

>>105886180
Yeah, this is also a great chance to give org-mode a try. It has great UX for simple TODO list management.
- S-left and S-right to change TODO states
- M-up and M-down to move items up and down.

https://bpa.st/RKLQ
* TODO your mother
* TODO find love
* TODO eat healthy
* DONE foo
CLOSED: [2025-07-12 Sat 15:51]
* DONE bar
CLOSED: [2025-07-12 Sat 15:51]
* DONE baz
CLOSED: [2025-07-12 Sat 15:51]

>>105886310
It's just 2 characters. DEL DEL

>>105886299
It's may be 2 lines, but it's also 6 discrete items that you're having trouble isolating.

>>105886350
Such a waste of vertical space.

>>105886439
Disagree. I think it's a great use of vertical space.

>>105885121
been thinkgen about using this to make a little mini-config for terminal emacs like mg on steroids. making syntax highlighting just werk in terminals is annoying though

>>105886439
You can try follow-mode to convert some vertical space into horizontal space

>>105886450
I've made a text mode oriented config before. It seems to work decently in wezterm. It even gives me CSS colors in html-mode.

>>105886439
You can hit S-TAB to collapse all the headings. TAB will cycle the current heading.

>>105886482
The only terminal-specific thing I have in my config was the addition of corfu-terminal.
https://codeberg.org/akib/emacs-corfu-terminal
I feel like I didn't have to do anything else special to get it to work well in a terminal. Some themes work better than others, but that's just trial-and-error.

>>105886482
How do you live with this font.
I bet you wear velcro shoes.

>>105887474
That's prot's old Iosevka Comfy!
How rude.

Any emacs live streamer except for the Xah-Lee?

>>105824960
I bought Practical Common Lisp and it served me well. It explains the language well and gives, as the title implies, many practical examples. If I was you, I would go on Anna's Archive and download each of these books before buying, although you can read Practical Common Lisp for free on their webpage.

>>105888091
System Crafters

>>105888091
https://emacs.tv

>>105890063
I didn't know there was an emacs package for it.
https://github.com/emacstv/emacstv.github.io?tab=readme-ov-file#watch-videos-on-emacs---emacstvel

>>105890801
It should declare its dependency on mpv.el. I had to add another use-package for mpv before it would work.

So now that the dust has settled, is this officially vaporware? What do you think?
https://jank-lang.org/blog/2025-07-11-jank-is-cpp/
>>105821488
>>105821967
Babashka is fine, fairly productive for CLI wrappers.
>>105822143
Racket or Chez/Chicken w/ Raylib.

So now that the dust has settled, is this officially vaporware? What do you think?
https://project-mage.org/

>>105891226
His last commit was 1 year and 7 months ago.
https://sr.ht/~project-mage/
Vaporware confirmed.

>>105884969
Did you not see the link to:
https://eshelyaron.com/sweep.html

This might be useful if you want lispy CI/CD.
https://bass-lang.org/
https://github.com/vito/bass
https://github.com/vito/bass-loop
This guy has an interesting site design in that he uses a different background color for each page.

>>105891226
>first and last blog post are five days apart

4 later
https://emacs-tree-sitter.github.io/getting-started/
https://www.masteringemacs.org/article/how-to-get-started-tree-sitter

Could it happen in emacs

https://securelist.com/open-source-package-for-cursor-ai-turned-into-a-crypto-heist/116908/

>>105894319
already does

t. writes infected emacs packages

>>105857910
New Site
https://helix-plugins.com/
https://github.com/helix-editor/helix/pull/8675#issuecomment-3067314296

>>105891822
>>105894235
I have been out for a while, can't these be added to the wiki?

Quicklisp works in sbcl through the terminal but sly doesn't seem to find it. Installed normally via the quicklisp.lisp file..
What is going on?

>>105897092
What wiki are you talking about?

>>105885584
>I feel like this would be a good candidate for a first plugin.
There's no need. It's already been done.
https://github.com/mattwparas/helix-file-watcher

Install:
forge pkg install --git https://github.com/mattwparas/helix-file-watcher.git


Config:
;; Put this in ~/.config/helix/init.scm .
(require "helix-file-watcher/file-watcher.scm")
(spawn-watcher)

>>105897126
Does your ~/.sbclrc contain the following?
;;; The following lines added by ql:add-to-init-file:
#-quicklisp
(let ((quicklisp-init (merge-pathnames "quicklisp/setup.lisp"
(user-homedir-pathname))))
(when (probe-file quicklisp-init)
(load quicklisp-init)))

Maybe try running that in sly.

Is it fair to say that every Scheme implementation is a little different? It seems like the authors will often pick a standard to implement and then add a little extra flair of their own. Different implementations also seem to do packaging their own way. Is it even possible to package Scheme code in a portable way?

>>105897729
>every Scheme implementation is a little different
yes
>Is it even possible to package Scheme code in a portable way?
yes but it's difficult, snow fort has portable r7rs libraries for example
you will need cond-expand and you'll eventually get so frustrated reading 7 different languages retarded implementations of 'system' that you'd rather shoot yourself than write portable scheme
r5rs would have been better for portability, but there was no namespacing in the standard

>>105895647
Very nice.
>>105897515
M-x sneed-mode

>>105897441
nope. forgot to initialize it. thenks

My logging library has a default "log-event" method, but for convenience I want to create several log-info log-debug, log-error, etc like in other languages:
(defparameter *default-levels*
(let ((ht (make-hash-table :test 'equal))
(levels '("debug" "info" "warning" "error" "critical-error"))
(level-values '(1 2 3 4 5)))
(loop for k in levels
for v in level-values
do (setf (gethash k ht) v))
ht))

(defmacro create-default-log-methods ()
`(progn
,@(loop for level being the hash-keys of *default-levels*
collect
`(defmethod ,(intern (string-upcase (format nil "log-~a" level)) :log) ((logger logger) msg &rest rst)
(apply #'log-event logger ,level msg rst)))))

(create-default-log-methods)
Good morning sirs!

ELISP> (emacs-uptime)
"8 days, 17 hours, 14 minutes, 12 seconds"

>>105897729
>Is it even possible to package Scheme code in a portable way?
Yes, an example is https://github.com/ashinn/irregex

irregex.scm is written in a portable subset of r4-7rs, while irregex-chicken.scm, irregex-gambit.scm, irregex.sld (chibi), irregex-guile.scm, and irregex.chezscheme.sls interface with each respective scheme implementation

>>105901904
Could this be simplified to the following?
(loop for level in '("debug" "info" "warning" "error" "critical-error")
do (eval `(defmethod ,(intern (string-upcase (format nil "log-~a" level)) :log) ((logger logger) msg &rest rst)
(apply #'log-event logger ,level msg rst))))


Why create a macro if you're only going to use it once?

>>105903295
I'm afraid of using eval

>>105904010
Why?

What is the 'proper' way to format long/nested manually written cons cells?
I've seen people break before the period, but I want to be certain I'm doing it right.

>>105904563
if you're making a fucked up data structure kinda deal for a one-time use then no "proper" formatting is needed, just vibe it
otherwise, consider doing the constructor/selector thing from SICP to have the ugly abstracted away and named something meaningful and pretty

>>105902687
I kill and start my emac every time I am done with the small task I'm doing. This way I have plenty of opportunity to get irrationally angry if my config takes longer than a second to load and optimize the fuck out of it, my buffer spaghetti is kept clean, and I don't leave things unfinished.

>>105904563
(pretty-print '((a . 1) (b . 2)) #:width 1)

((a .
1)
(b .
2))

>>105905020
what the fuck anon that is the ugliest thing i've ever seen

>>105905031
I've occasionally seen it in pretty-printed parsed json like
(key .
[some array])[/code[

>>105885584
The helixfags are ignoring the Scheme solution to their 4 year old problem.

>>105906563
cute
https://github.com/SophieBosio/south

>>105901904
TANGENT: Although Java is known for its excessive verbosity, the Android logging API was surprisingly terse with its single letter method names. When I did Android development a few lifetimes ago, this API was a pleasant surprise.
https://source.android.com/docs/core/tests/debug/understanding-logging#log-standards
Log.wtf
Log.e
Log.w
Log.i
Log.d
Log.v

>>105906985
mine essentially works like that sir.
CL-USER> (log-critical-error *logger* "aaaaa")
[CRITICAL-ERROR] 2025-07-14T18:22:53.047673-03:00 aaaaa


I'm not really sure how to implement those complex logging hierarchies java and python have because I don't really understand them (I program in python for years and never really understood the logger)

>>105907367
You can pass argument to the string.
(log-critical-error *logger* "This will print the arg: ~a" 'argument)

I'm still thinking if I should try and make it threadsafe.

>>105904563
I don't know if it's proper, but I like to vertically align the periods in the middle of a cons cell.
(org-babel-do-load-languages
'org-babel-load-languages '((emacs-lisp . t)
(jq . t)
(julia . t)
(lisp . t)
(perl . t)
(shell . t)))

>>105891226
Too ambitious?

>>105856141
>Helix + Scheme
RMS was right again.
>But in particular, we do not want to have extension languages other than Lisp. Emacs Lisp is the variant of Lisp that we've always supported, which has evolved along with Emacs. We can conceivably have Scheme as well, if we can sufficiently solve the problems, the technical problems of making Scheme and Emacs Lisp interoperate. We did some design work, I think that was with Tom Lord, whom the community will greatly miss. In the 1990s, there are challenges that remain; maybe it can be done. But a non-Lispy language would be a mistake. It would divert our development focus into areas that we don't need, languages that are less powerful, less beautiful, and less desirable for the purpose.
https://emacsconf.org/2022/talks/rms/
Guile-Emacs really needs to become a reality if Emacs desires to remain competitive in the future.
https://www.emacswiki.org/emacs/GuileEmacs
https://codeberg.org/lyrra/guilemacs

SICP exercise 2.65 done. Im getting bored of SICP a bit. It’s pretty interesting but the ratio of exercises to text is so large.

>>105911828
>Guile-Emacs really needs to become a reality if Emacs desires to remain competitive in the future.
Every time I think about this I'm just reminded of Lem. If people are putting in this effort because Guile is more performant than Elisp, then why not go all the way and just do CL?

>>105912412
because rms is extremely fussy about languages and he doesn't like common lisp that much

>>105912412
Guile = GNU Ubiquitous Intelligent Language for Extensions.
Also, GNU Guix.

Is there something that allows me to use/see or couple emacs with tide tables?

>>105856141
https://github.com/helix-editor/helix/pull/8675#pullrequestreview-3018763923
One step closer to getting the Steel branch merged into Helix

Out of curiosity, is there anything like Common Lisp's lparallel for Scheme?

https://github.com/sharplispers/lparallel
https://g-gundam.github.io/lparallel/

>>105914764
racket has a bunch of shit
https://docs.racket-lang.org/guide/parallelism.html
guile has ice-9 threads.

>>105912412
Has anyone done benchmarks of Guile versus Elisp recently? With native compilation, I'm not sure Elisp is that much slower than Guile anymore.

>>105914808
>ice-9
This is such a mysterious name. Even when I search for an explanation, I'm left even more confused.
https://lists.gnu.org/archive/html/guile-user/2003-12/msg00057.html

What is ice-9? A library? What does it do?

>>105914931
I also have no idea why they chose that name but Ice-9 are the built-in modules for guile.

>>105914931
https://github.com/skangas/guile/tree/master/module/ice-9

>>105914250
My first thought is to find a free API for tide data and then write an org document that pulls in this data and displays it in an org table. A little bit of org-babel with your favorite language could make it happen.

>>105915027
shame the autistic calendar jew man did not write a tide data plugin.

>>105912412
>>105913912
>>105914865
I'm surprised they haven't made Guile a thing on Emacs, it'd be a very important use case to make the lang reach some of the masses.

>>105914993
This link is more up-to-date for ice-9.
https://cgit.git.savannah.gnu.org/cgit/guile.git/tree/module/ice-9

>>105914931
ice-9 is guile-specific libraries
reference to Kurt Vonnegut's cats cradle, any scheme code that touches ice-9 becomes guile

>>105912412
>Common Lisp is extremely complicated and ugly. When I wrote GNU Emacs I had just finished implementing Common Lisp, and I did not like it much. It would bloat Emacs terribly, and documenting it would be hard too.
>Scheme is elegant, and it is a better direction to move in.
>Since we have our own Scheme implementation, we should use that one. If it has a serious disadvantage, we should do something about that. There are various things that might be right to do, but simply disregarding it in the case of Emacs cannot be right.
https://lists.gnu.org/archive/html//emacs-devel/2010-04/msg00612.html

Guy L. Steele
Guile Steel

>>105911828
>Tom Lord, whom the community will greatly miss
https://berkeleydailyplanet.com/issue/2022-06-26/article/49837

>>105915931
Guy L. Steele

Guy Java

>>105824960
Practical Common Lisp.

>>105916027
https://news.ycombinator.com/item?id=1266032

new bread
>>105917285
>>105917285
>>105917285
>>105917285