>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

(reset! prev-bread >>105917285)

>>105992030
Also Clobber (Clojure)
https://youtu.be/kRd4JYIiWb0
https://github.com/phronmophobic/clobber

>>105992246
>https://wiki.call-cc.org/eggref/5/edward
Ed, man! !man ed
https://www.gnu.org/fun/jokes/ed-msg.html

>>106004502
How do you run clobber?

I'm going back to Clojure after fucking around with Elixir, Rust, and a bunch of other shit. I'm so done with the bullshit man.
Give me my JVM hog, I love that pig. It snorts at me as I paint it with immutable symbology.
Anyway, to get into the spirit, and to "solidify" this decision (I REALLY need to embrace one language and just build shit with it), I am going to switch from Neovim (used for over a decade) to Doom Emacs and set up REPL integration.
Thanks for reading my blog post.
BTW here is a screenshot of an experimental hash map I wrote in Rust. It outperforms Swiss Table in some cases but got BTFO by a certain key arrangement.

>>106004931
CIDER is great.
https://cider.mx

I'm about a hundred pages into Practical Common Lisp, and I gotta say, the equality functions and their naming conventions are shit. Really the only issue I have with the language so far.

finally a new guix mirror 4 russia
https://lists.gnu.org/archive/html/guix-devel/2025-07/msg00129.html
https://mirror.yandex.ru/mirrors/guix

>>106005368
Is Guix still slow as fuck?

>>106005368
Good.
https://libreplanet.org/wiki/Group:Guix/Mirrors

>>106005388
It's OK for me (Thinkpad + SSD)

>>106005368
Nice.
But for me it's PantherX!
https://www.pantherx.org

>>106005262
>install Doom Emacs
>long lines do not wrap
>go to `config.el`, try to change `(setq display-line-numbers-type t)` to `(setq display-line-numbers-type 'relative)`
>put cursor over the t
>press s to substitute, like in Vim
>does nothing
>s is not bound to substitute by default
bruh, who the fuck thought it would be a good idea to rebind a very common Vim keybinding

>>106005368
>yandex.ru
i'm paranoid about these guys, manually checking hashes for iso files might be necessary
still this happening is a good thing, for a variety of reasons.

>>106005882
>long lines do not wrap
I recently learned about visual-wrap-prefix-mode. It'll wrap lines while also respecting indentation. It's like line wrap for programming modes.

>>106005322
Yeah it took me some time to get accustomed as well but I think this distinction is important. When you say that two things are 'same' it can actually mean completely different things depending on context.
That both objects live in the same memory region?(Eq)
That both objects have the same byte representation?(Eql)
That both numbers are same regardless of internal representation? (=)
That both lists have the same structure even if they inhibit different regions of memory? (Tree-equal)

why would i use lisp when lua and C exist?

>>106006042
The only thing of value from lua is luajit.
The language is pretty terrible.

C is a wonderful bootstrapper into lisp and scheme.

>>106006042
C doesn't even have namespaces. Lua doesn't even have macros.
Common Lisp has a full numeric tower, powerful macro system (that allows for endless language extension, see the Coalton project that puts Haskell 98 types into Common Lisp via the macro system), the Common Lisp Object System (that implements an object system that is a superset of even Java, an "object oriented" language, btw was initially implemented as an extension to Common Lisp), conditions (a superset of exceptions in other languages, allowing for correction of errors without unwinding of the callstack), and a first class REPL.
C and Lua are jokes to the liveness of Common Lisp.

>>106006042
>Dennis Ritchie: I have to admire languages like Lisp
http://www.gotw.ca/publications/c_family_interview.htm

>>106006099
based dmr

>>106006084
i don't see how most of the things you list are even remotely helpful. the lack of a C repl is sad, but other than that why do i need "powerful" macros, numeric towers, OOP, and whatnot? i think a lot of modern languages (like lua) have taken all the best bits from various lisps. we're not in the 70's anymore, anon. C and lua are, in my opinion, all you really need anymore with most programming.

>>106004428 (OP)
NAKAD4SHITANIA SEXO AND IMPREGNATE, LITERAL NAKAD4SHI QUEEN

>>106006472
why even ask questions like these if you think you are correct? you should really sit down and ask yourself why you think that you know more than someone with over a decade of experience programming.
tl;dr: write more code

Has anyone been able to build extempore on Guix? It keeps failing in my machine.

>>106006752
i'm not the one simping for (((lisp)))

>>106005322
Honestly, we should have eq and equal with the latter being a generic function. Everything else is just redundant.

https://fukamachi.hashnode.dev/

>>106007373
absolute chad

>>106003763
>it's strange how many developers there are that are completely resistant to different looking languages
>you'd think those kinds of people would be underrepresented considering how many different things they have to learn on a regular basis if they're a half decent dev
Even among Lisp programmers, lots of people are like this. Remember, Lisp is simple and elegant, but APL is alien and unreadable.
>the ones that claim it's too many parens are the most idiotic. it's literally the same amount of parens
It's not, especially if you compare with infix notation. While foo(arg) and (foo arg) are the same, in Lisp-like languages you also use parens all the time for control structures and that's where sexps become particularly unreadable, IMHO. Compare pattern matching in Scheme or ELisp with pattern matching in Haskell or OCaml, the readability difference is massive (though you can kinda get used to parsing (match (foo bar) (() (baz)) ((a . d) (quux a d))), it's still bad).
S-expressions are verbose and very uniform, without any visual clues. I think this should be an admitted problem (and ppl should experiment with various solutions), but Lisp community mostly sweeps it under the rug and fears any kind of criticism of their beloved parentheses.

>>106006042
dwarf fortress recently added lua scripting. mods go brrrrrrrrrrrrrrrrr

>>106007643
even though it does not matter for the reader, indentation matters for the human reader. Try reading ocaml without identation too.

>>106007643
It is not sweeping anything under the rug. I simply cannot understand your difficulty and don't share it, so I cannot admit to there being any problem. I think most people who spend serious time with Lisp also learn to see "through" the parentheses. IDEs will also highlight pairs for you nowadays, making the problem largely irrelevant, and the syntax of things like Clojure is worse for having square brackets and so on.

>>106007643
lisp pattern matchers are all macros, and sufficiently developed macros all have conditional functionality based on the fact what you're giving them. Specifically, (my-match z (case-a case-b ...)) will behave differently not only based on the base type of a case (is it a symbol or a list?), but also based on the structure of a case if it's a list as well as the type and structure of its elements. This nested matching has no visual clues, and flycheck will not save you from making mistakes from sheer confusion.
>>106006042
>lua
awesomewm is unironically everything stumpwm wishes to be, except lua makes tinkering with the configuration a pain. well, i, at least, have the problem. i would have preferred to take a bunch of parentheses and infix notation that the sheer retardation of overnested curly braces with commas up my ass.
but i have to give it to lua, i didn't even need to check out the docs to use the language, and outside of list nesting it's fine.
>c
no one avoid C anyway, so your wish is fulfilled.

>>106004931
Babashka is decent for CI tasks.

>>106006042
you could use the superior lua version instead https://fennel-lang.org/

>>106004188
>Can someone explain lexical scoping? I've implemented my own lisp, but it uses dynamic scope, and I don't quite understand how lexical scope works on the level of implementation.
;; a lambda like
(lambda (x y) x)

;; is represented internally as a closure (the parameter list, body list, and current environment)
(((x y) (x)) environment)

;; which is really (at toplevel, where the environment only contains a lambda primitive)
(((x y) (x)) ((lambda . #<procedure>)))

;; let's evaluate this application
((lambda (x y) x) 1 2)

;; during apply the current environment is extended using
(cons (map cons (x y) (1 2)) environment)

;; producing a new environment (if we had another closure in the body list, this is the environment that would get captured the same way as before)
(((x . 1) (y . 2))
((lambda . #<procedure>) ...))

;; the body list (x) is then evaluated in the new environment
(last (map eval (x) (((x . 1) (y . 2)) ((lambda . #<procedure>) ...))))

>>106007373
>>106007493
The Lisper Samurai

eng ver when for us dekinais

>>106010519
https://github.com/zick/Magical-Language-Lyrical-Lisp

Babashka + HTMX
https://clojure.org/news/2025/07/20/deref
>Clojure, Babashka, and Web CGI (https://blog.nundrum.net/posts-output/2025-07-09-clojure-cgi/)

>>106010954
It doesn't work...

>>106011490
Okay that error was because of the 1000x folded nippon code that only works with the JP locale, but I tried creating the nscript with both the .exe tool, compiling the c code on windows and on linux and it still doesn't work...

>>106010954
Wait a second... that repo doesn't have the translations at ALL why did you lie to me??

>>106007643
>without any visual clues
I'm glad Rich Hickey introduced [ ] and { }. That was a step in the right direction.

>>106011831
it was not, this is worse for macros and is only "good" because he did not give Clojure reader macros
it is compromise at best

>>106011994
He had his reasons.
https://groups.google.com/g/clojure/c/8RSLNWno0nU

Can someone spoonfeed me how to configure, whatever is autoformatting, so that it doesn't autosort the includes in C++ files?

I'm on doom emacs and I have enabled:
(format +onsave) ; automated prettiness

>>106013971
>I'm on doom emacs
Who knows. I don't use a massive pile of hacky lisp code in my config. I actually understand what's going on in mine because I built it myself.

>>106014068
yeah... thanks

>>106011831
>I'm glad Rich Hickey introduced [ ] and { }. That was a step in the right direction.

No.

On Common Lisp you can use whichever reader macros you like, thus, you can select which meaning will [] and {} have in the SPECIFIC file where you need to use/enable them.

Rich Hickey basically fucked up this functionality. And as a side effect, code looks even uglier.

One of the many ill decisions by Rich. I will concede, though, that centering on immutable data was a good decision.

>>106005322
>I'm about a hundred pages into Practical Common Lisp, and I gotta say, the equality functions and their naming conventions are shit.

They appear "shit" but then you realize that comparison is not so simple. There are many ways to compare two things. Thus the need for eq, eql, equal, etc.

Quite the opposite, on other languages, whenever i use something like "==", i have to go back and read the lang reference to make sure exactly how this operator would behave.

>>106004931
>I'm going back to Clojure after fucking around with Elixir, Rust, and a bunch of other shit. I'm so done with the bullshit man.

Try Erlang instead of Elixir.

Try OCaml instead of Rust.

>Give me my JVM hog, I love that pig. It snorts at me as I paint it with immutable symbology.

Ok, then use Scala3, in my opinion right now is the best mainstream language available for the JVM.

>BTW here is a screenshot of an experimental hash map I wrote in Rust

This is a Lisp thread. Lispers, generally, consider Rust users to be pathetic braindead losers.

>>106014250
snide comments aside it's hard for us to help because emacs "distros" have their own complete layer of complexity wrapped around "normal" emacs. most of us still use homegrown configs so we don't know how the hell doom works.

>>106006084
>C doesn't even have namespaces. Lua doesn't even have macros.
>Common Lisp has a full numeric tower, powerful macro system (that allows for endless language extension, see the Coalton project that puts Haskell 98 types into Common Lisp via the macro system), the Common Lisp Object System (that implements an object system that is a superset of even Java, an "object oriented" language, btw was initially implemented as an extension to Common Lisp), conditions (a superset of exceptions in other languages, allowing for correction of errors without unwinding of the callstack), and a first class REPL.

Not to mention CL also allows you to execute code at read time, compile time, and runtime.

>the Common Lisp Object System

The absolutely superior OOP system , even right now in 2025.

>C and Lua are jokes to the liveness of Common Lisp.

Based.
Only Smalltalk can compete in this regard, except that CL executes at lighning speed compared to Smalltalk.

>>106014860
I fully understand. I solved it temporarily by adding a .clang-format file with the contents:

# .clang-format
BasedOnStyle: LLVM
SortInclude: Never

it activated some other weird stuff like 2 spaces indentation, even if I included a line like
IndentWidth: 4

but whatever, I left it like this for now

>>106006042
C is good

lua is garbage only good for embedded scripting in game modifications

>>106014920
>C is good
lmfao

>>106014920
>C is good

Good for bootstrapping Lisp. And then, the best Lisp implementations contain no C code.

>>106014826
You're right, having more options isn't bad. I'm mostly complaining about the fact that I will have to memorize what each comparison function does and in what cases to use them instead of the naming being more intuitive.

How does one host a Guix package mirror? How much storage/bandwidth is required? I have a server with 3TB redundant NVMe storage and 10Gbps uplink I can dedicate to it if it's enough. I don't personally use Guix btw

>>106015006
https://www.futurile.net/2023/05/01/guix-publish-caching-substitution-server/

>>106014841
>Lispers, generally, consider Rust users to be pathetic braindead losers.
Nah. Rust actually takes a lot of good things from Lisp:
>Scheme: hygienic macros
https://doc.rust-lang.org/reference/influences.html
Also, Helix + Steel (Scheme) looks very promising.
https://github.com/mattwparas/steel
https://github.com/helix-editor/helix/pull/8675

>>106015130
Is there any additional setup necessary for hosting a public server? Other than firewall setup obviously

>>106014969
lisp vms should be implemented in assembly rather than C.
>>106014866
>The absolutely superior OOP system , even right now in 2025.
Indeed, now that the OOP hype is long behind us, the score seems to be forever settled.

good evening sirs!
what's the best way to write a gui program with lisp? I'm partial to CL but if clojure or something has better libraries I'll check it out

>>106016052
CL has https://github.com/rabbibotton/clog
Clojure can use Java Swing or JavaFX (never forget that Clojure can trivially use ANY Java lib)
you can always just deploy a local webserver (this has the advantage that you can throw the program onto a server and then access it remotely)

>>106016052
Clojure has bindings for JavaFX and you also have Clojuredart. Or just anything with imgui or SDL bindings.

>>106008802
>https://fennel-lang.org
Interesting

>tfw lisp project is getting me interviews

>>106016052
racket has basic ui capabilities out of the box sir