Imageboard:
https://github.com/ECHibiki/Kotatsu-V
Textboard:
https://gitlab.com/naughtybits/schemebbs

File: (E)LISP.png (507 KB, 1800x1500)

507 KB PNG

>>108459837
https://protesilaos.com/codelog/2024-11-28-basic-emacs-configuration/
https://protesilaos.com/emacs/emacs-lisp-elements
http://xahlee.info/emacs

>>108486038
OBS

>>108486033
ty

Am I even a part of the Emacs Wizards club if I use Doom?
I kinda feel left out.

>>108486685
>his config is not forged through hundreds of minute changes, autistic features and packages you don't even use anymore
Weak

>>108486685
If you write Elisp, you're part of the club.

What's the tiniest "standard" Lisp variant? Is it Scheme R6RS?

>>108486685
Nah you're good, if you're able to adapt Doom to your needs then I dont see how it's different. It's harder to tard wrangle doom but it's still emacs, you can still change whatever the fuck you want.

File: let-completion-showcase.webm (2.88 MB, 1198x982)

2.88 MB WEBM

Alright I'm satisfied with this. All aspects of it can be customized so users can decide what they want to show or how.

Also while recording it occurred to me that I could add a minor mode that filters out any candidate that's not local, good for showcasing the completions without flooding with globals but it might also be useful when you want to focus only on the current scope.

So now there's this minor local-only mode (which im using in the video) and an interactive command that basically:

>enables the mode
>executes completion at point
>disables the mode

So I can bind it to a key and get local scope completion without having to enable and disable the mode manually.

>>108486164
>schemebbs
I miss it.

>>108486131
Is there a LISP but low level, like C or ASM but with S-expression?

>related
>>108487794

File: 6065ed531e366633beb395138(...).png (1.34 MB, 1674x2048)

1.34 MB PNG

>>108487141
r5rs is smoler

>>108488008
Check out cakelisp.
I'm working on one right now too, kind of similar to cakelisp in that it compiles down to C, but with an actual standard library, CLOS-style object system, REPL/eval, etc. It's been a lot of fun.

>>108487554
Nice work anon, please push your changes

>>108488042
cakelisp is interesting, but there's no low level LISP that compiles to machine code or an IR without all of the functional and OOP masturbation? The C of LISP?

Hello anons
I'm currently learning Emacs and I plan to read either HtDP or SICP after I'm done with the basics.
Which do you recommend more? I'm leaning more towards SICP since it seems to have a wider coverage of computer science but I'm definitely slow and barely remember any calculus which is making me hesitant.
I already did some online courses like Systematic Program Design, and Dan Grossman's Programming Languages both from OSSU's CS core programming section.

>>108488099
Maybe you're looking for Forth? Cakelisp is pretty barebones, it's basically just C with sexp. I don't think it has any intellectually masturbatory features, at least not last time I checked. Not sure what you're asking for.
Also machine code and IR are pretty different things, the lang I'm working on compiles to IR and then I just have a backend for C and the interpreter. Do you mean so you add a native backend to one or something?
If you don't want functional or OOP then what are you really looking for, something mostly just procedural without anything else? Have you checked out pre-scheme maybe?

>>108488176 which book is in the OP image?

>>108488008
It's called Common Lisp.

  (define-generic-arith-routine (+ 10)
    (move res x)
    (inst add res y)
    (inst jmp :o BIGNUM)
    (inst clc) (inst ret)
    BIGNUM
    ;; Unbox the overflowed result, recovering the correct sign from
    ;; the carry flag, then re-box as a bignum.
    (inst rcr res 1)
    (when (> n-fixnum-tag-bits 1)   ; don't shift by 0
      (inst sar res (1- n-fixnum-tag-bits)))
    (return-single-word-bignum res rcx res))

SBCL compiles to machine code. You can disassemble any function with the built-in function disassemble.
Having s-exp syntax does not make something a lisp.

>>108488306
>Having s-exp syntax does not make something a lisp.
what does? i find no one can agree on what makes something a lisp

File: 2026-03-30.png (101 KB, 592x1132)

101 KB PNG

>>108488099
Snippets of lisp->assembly compilers have been posted in previous breads

>>108488316
A conservative definition is that it must be able to run most Lisp code with few to no modifications for everything called Lisp from McCarthy to Common Lisp. This applies to Common Lisp. Naturally this excludes Scheme and Clojure.
A more liberal definition includes languages like Dylan, and McCarthy's version of Lisp before switching to s-exps.
There's a shitcoin called Chia that uses an s-exp syntax for smart contracts, and web assembly's WAT uses s-exps, neither are lisps.
My personal most liberal criteria for what makes something a lisp is whether it has runtime interactivity or not. If I can't modify the program while it's running in any way I please, then sorry, you're not even in the running, regardless of what surface-level syntax you might have.

>>108488419
That's kind of the issue though, everyone has their own opinions of what a lisp is. I guess the real answer is who gives a shit, it's a label for a family language that is irrelevant nowadays. I personally think homoiconicity and sexp syntax + metaprogramming/first-class macro system are more central to what a lisp is than runtime interactivity, otherwise stuff like Smalltalk would count as a lisp.

>>108488419
>>108488451
maybe the real lisp was the friends we made along the way

>>108488070
Done: https://github.com/gggion/let-completion.el

>>108488451
>Smalltalk would count as a lisp.
Now you're getting it.
Another way to look at this is whether you really have a programming system rather than just a language. The language paradigms and system paradigms are incommensurate. Lisps have historically been more on the system side and when people struggle with them it's usually because they can't cross the gap to thinking in systems.

>>108488497
I agree with you, I just think there should be another term than "Lisp" for the type of environment you're describing. You're describing more of a feature than a language of families. There's a reason it's called Lisp, it's an abbreviation of LISt Processing. If you make a language identical to MacLisp or Common Lisp, but you have no runtime features, I would still call that a lisp. It's not lispy to not have runtime features, but it's definitely a dialect of lisp in my opinion. Who cares though.

>>108488513
> language of families.
family of languages*

>>108488419
>McCarthy's version of Lisp before switching to s-exps
It had sexps from the start. The end goal was M-exps which inspired the Wolfram language syntax.
>If I can't modify the program while it's running in any way I please
Even modern C runtimes have support for this.

>>108488513
Yeah, it doesn't really matter, other than it's annoying when idiots call everything with s-exp syntax a lisp, even if it doesn't have macro support or lambdas, and miss out on all the other elements of Common Lisp that are inherited from a rich tradition of older Lisps.
>>108488551
>Even modern C runtimes have support for this.
Not really. Show me a modern C tutorial that shows this up front like Lisp tutorials do. The approximations I've seen always have severe limitations. Usually it's a form of plugin architecture which requires fully unloading and reloading things rather than redefinition, and the things must conform to a static API.
Every video game engine ever wants this sort of functionality, they all eventually get something approximating it with many, many caveats and limitations. Tomorrow Corporation's tech demo is probably the best version I've seen of this but required them to make their own editor on top of everything else.
Another criteria is if the language has support for OOP, does it also have something like change-class? Such a function is a sign of system thinking, not language thinking.

File: 1774905114701067.png (66 KB, 320x320)

66 KB PNG

>>108488483
Thanks anon

>>108488618
Is it really just image-based development then for you? Or if you have a lisp with interactive development but it's not image based, would that still count?

>>108488483
Have you look into how elisp--local-variables works? It seems like it would be a lot easier to deal with everything as an sexp rather than as text in the buffer. It concatenates everything from the outermost open paren upto to point, appends elisp--witness--lisp and enough closing parens to balance the expression and read-from-string's it. Then it recursively walks the sexp keeping track of variables in scope until it finds elisp--witness--lisp and returns the variables currently in scope. I ended up reusing most of the body of elisp--local-variables-1 as the base method of a generic function and wrote methods specializing on the heads of the sexp which would do manual macro expansion by transforming that level of the sexp into something that could be processed. It would also be possible to define methods for safe macros that just macroexpands them. For example

(cl-defmethod let-completion--local-variables-1 (vars
                                                 (sexp (head cl-defmethod)))
  (pop sexp)
  (while (cl-generic--method-qualifier-p (car sexp))
    (pop sexp))
  (let-completion--local-variables-1
   (nconc (cdr (cl--generic-split-args (pop sexp)))
          vars)
   `(progn ,@sexp)))

>>108488419
There are two senses of the word Lisp. One is as you describe, the other is a short hand for a language using s-expressions. If you call something without quotes a Lisp, nobody is going to be confused or care.

Anyone know how to get the leader key defined by general to work in the *Messages* buffer? I've tried the following snippet, and it works after it gets evaluated, but not on startup, regardless of where I put it in my config file:

(with-eval-after-load 'evil
  (general-add-hook 'after-init-hook
                    (lambda (&rest _)
                      (when-let ((messages-buffer (get-buffer "*Messages*")))
                        (with-current-buffer messages-buffer
                          (evil-normalize-keymaps))))
                    nil
                    nil
                    t))

>>108488618
I think you're overestimating how many features the C runtime has.
>modify the program while it's running in any way I please
Means replacing a function definition at any time. Sure, you can't freely redefine C structs but you can't do that with CL structs or Scheme record types either.
In the C ecosystem this is generally called hotpatching and Win32 has supported it natively for at least two decades.
https://devblogs.microsoft.com/oldnewthing/20110921-00/?p=9583
Windows uses this to live patch security updates.
>modern
If by "modern" you mean contains code snippets that still work as is then sure.
https://aegisknight.org/2009/03/disabling-functions/
Theres also a few libraries that build around features like this
https://github.com/EasyHook/EasyHook
https://github.com/Microsoft/Detours
Its a fair bit harder on *nixtard but the best solution is typically using detours.
For example https://journal.lunar.sh/2022/linux-detours.html
Both of these techniques use indirection to essentially replace the body of the old function with a call to the new function and the result is really quite similar to the general lisp case which uses runtime indirection via symbol lookup.
>Every video game engine ever wants this sort of functionality
Game engines have a lot more to worry about than just loading some new function definitions and a lot of the big ones actually do support reloading models and scripting but its always low on the priority list because it doesn't actually make the game better.

My point is that using an implementation feature like muh redefinition is a very bad way to define a language (family). The typical lisp implementation family (which is not exclusive to lisp-like languages) is regularly conflated with the language family (which is also not exclusive to "lisp-like" implementations, a prominent example of this would be STALIN).

>>108489419
I was aware of the classic win32 hotpatching. I think you are probably aware that it has many more limitations than you are suggesting besides just being appropriate for function patching, e.g. that the function replacements must share the same signature, number of arguments, and calling convention. You'll find no beginner C tutorials that use these types of tricks because it's not standard practice, unlike Lisp. The use of these tricks is not typically to enable interactive development but to enable dynamic instrumentation, typically for logging or extra debug info (especially of third party code you can't simply recompile).
It's disingenuous to compare the many limitations of these hotpatch approaches to the CL standard's exceptional "The consequences of redefining a defstruct structure are undefined." (This does not prevent an implementation like SBCL from defining its own consequences -- indeed, you can freely redefine structs in SBCL. When the redefinition is incompatible, you get thrown into the debugger and presented some options.)
>Game engines have a lot more to worry about than just loading some new function definitions and a lot of the big ones actually do support reloading models and scripting but its always low on the priority list because it doesn't actually make the game better.
Yes, thanks for agreeing, though these features are desirable not because they directly make a game better, but because they contribute to better and faster development of a game, which leads to more time to make a game better.
>an implementation feature like muh redefinition is a very bad way to define a language (family)
It is much better than surface level syntax, otherwise almost every other language is just an algol.
Mostly I'm sick of idiots posting their "look I made a lisp!" and you look inside and it doesn't even have the features of McCarthy's Lisp.
The "Build Your Own Lisp" book is a bad offender of this but a lot of people don't even go that far.

>>108488945
Yeah my initial approach was exactly that, but after checking the code in elisp-mode.el
>https://github.com/emacs-mirror/emacs/blob/master/lisp/progmodes/elisp-mode.el#L844-L845
I decided to purposely avoid any macroexp. There's a lot of discussion in there about the safety concerns of evaluating arbitrary lisp code to get completions (hence the talk about defining a list of safe macros, the trusted-content-p gate, etc)

I don't necessarily agree with this limitation, but I figured from a 'provider' POV it would be better if I left that decision to the user instead of assuming they wanted to do it. And I could gain much more freedom to develop and showcase the package if I killed any talk about safety and side-effects from the root

Still, to my surprise once I started going through the manuals and documenting the signatures of every binding form I could find, it turned out that the vast majority of them fall into like 4 structural patterns. 40 out of 46 registered forms are handled by those 4 extractors, you just tell the registry "bindings are at index 1, they're shaped like a list, scope is body" and it works.
Like 80% of work was from the 6 custom forms and having do deal with complex shit like defmethod and letf, but registering a new standard macro or function is a one-liner, and you can even register symbols that aren't loaded, it simply defines a symbol property so no errors if you register a binding from an external package. So the coverage came almost for free once the patterns were identified.

Also to my surprise this approach still benefits from adding files to the 'trusted' list, there's some cool synergy where if you enable macroexpansion for completions in a file you'll see more values in the middle column, so you can still benefit from the original --local-variables approach

imo the extractor approach came out on top, it works in untrusted buffers, it works before the macro is loaded and it works with incomplete forms mid-edit.

Lisp community never building anything actually useful is why this language is pozzed

>>108488672
Being technically image-based or not is an implementation detail I don't care about. Clojure isn't image-based but still supports a high level of interactive development, I'm fine with calling it a lisp even if it's no more capable of running 40+ year old code with little or no changes than Python.

>>108489841
I am not macroexpanding anything. I just read the sexp so I can walk a list instead of unstructured text. syntax-ppss gives you enough information to construct a readable string from a partial form.

(let* ((ppss (syntax-ppss))
       (txt (buffer-substring-no-properties (or (car (nth 9 ppss)) (point))
                                            (or (nth 8 ppss) (point))))
       (closer ()))
  (dolist (p (nth 9 ppss))
    (push (cdr (syntax-after p)) closer))
  (setq closer (apply #'string closer))
  (condition-case nil
      (car (read-from-string
            (concat txt "elisp--witness--lisp" closer)))
    ((invalid-read-syntax end-of-file) nil)))

File: GNU_Compiler_Collection_logo.png (257 KB, 1920x2265)

257 KB PNG

>>108488008
>C or ASM but with S-expression
Interestingly enough, even GCC uses S-expressions.
>RTL is inspired by Lisp lists
https://gcc.gnu.org/onlinedocs/gccint/RTL.html

>>108489699
>that the function replacements must share the same signature, number of arguments, and calling convention
Sure, to ensure a correct program after a single patch they do but there is nothing stopping you from changing these aside from the consequences when it gets called incorrectly. If you're going to change any of those then you'll also need to rewrite/recompile all the callers and you don't need hotpatching then. The only thing lisps do to aid this process is by confirming the lambda lists match.
It would also be fairly trivial to introduce an argument conversion in the Win32 patch style.
>because it's not standard practice
>The use of these tricks is not typically to enable interactive development
They also have a very different mindset about how development should be done. These techniques are widely used to apply security fixes at runtime but isn't applied more widely because those developers would typically rather force a restart.
Anyway, it would be complete ass no matter the runtime support without dynamic typing and a REPL.

>>108489847
you'll come to realise lisp is the only useful thing, and it's already made

>>108489290
I figured it out. You just need to actually run the code in the lambda at some point after loading in general:

(use-package general
...
:config
(general-evil-setup)
...
(when-let ((messages-buffer (get-buffer "*Messages*")))
    (with-current-buffer messages-buffer
      (evil-normalize-keymaps)))
)

File: Crash_Bandicoot_Cover.png (174 KB, 300x298)

174 KB PNG

>>108488008
The only thing that came to my mind was GOAL
https://en.wikipedia.org/wiki/Game_Oriented_Assembly_Lisp
https://opengoal.dev/
No idea if this is what you meant or if it's good for what you intend to use it for.

In Common Lisp, is there a way to print the type tree of a type? For example, suppose I were using quri and wanted to see all subtypes of quri:uri. How could I do that?
https://github.com/fukamachi/quri

>>108486131
https://protesilaos.com/politics/2025-06-19-america-interventionism-destiny/
>Israel is winning the battle of impressions with its subterfuge and sabotage tactics combined with its friendly media machinery across the West, yet it needs America (and other Western allies) to prevail in a total war against Iran. The Israeli government’s gambit, if not well informed expectation, is that its fait accompli will pull the Americans into the conflict, despite President Trump’s personal branding as an anti-war president. The goal is to topple the Iranian regime and replace it with a puppet of their choosing. All in the name of liberating people, of course.

What did prot mean by this?

>>108491924
MOP lets you do this, (class-precedence-list (find-class 'anon-class))

>>108492868
based cypriot monk

File: file.png (45 KB, 1504x402)

45 KB PNG

>>108489933
Ah yeah I see what you mean, regarding read, i did use it in the first version of the package, but I encountered some edge cases which were unsolvable, like dealing with broken contents inside the parens even if they're balanced.

(condition-case err
    (read-from-string "(let ((a 1) (b #<broken>) (c 3)) witness)")
  (invalid-read-syntax (list 'FAILED (cadr err))))

it wasn't a complete dealbreaker but I also plan to add support for other Lisps in the future, plus by moving through the buffer you could also collect other stuff like text properties, overlays or anything currently living inside of it. Your approach is superior structurally I think notwithstanding those small edge cases, but it's too late for me to turn back.

>>108493073
>(class-precedence-list (find-class 'anon-class))

It kind of goes in the opposite direction than what I wanted. It goes from a leaf node to the root instead of recursing from the root to the leaf nodes. I can still work with this though. Thanks.

DS2> (c2mop:class-precedence-list (find-class 'uri-https))
(#<STRUCTURE-CLASS QURI.URI.HTTP:URI-HTTPS>
 #<STRUCTURE-CLASS QURI.URI.HTTP:URI-HTTP> #<STRUCTURE-CLASS QURI.URI:URI>
 #<STRUCTURE-CLASS COMMON-LISP:STRUCTURE-OBJECT>
 #<SB-PCL::SLOT-CLASS SB-PCL::SLOT-OBJECT> #<SB-PCL:SYSTEM-CLASS COMMON-LISP:T>)

>>108493257
Not sure if related but I remember slime-help doing some stuff related to finding classes:

https://github.com/mmontone/cl-def-properties/blob/8c4d833749ecfdc9dbc6d08f47db7db63d73678e/def-properties.lisp

how can xach be forced to update quicklisp packages once a month like he used to

>>108493435
Quicklisp remains my only gripe with Common Lisp. I always get tangled up when trying to set dependencies, I wish there was a way of pinning libraries or pointing to a specific repository url, unless that already existss in qlot,vend ultralist or whatever the fuck it's available, I haven't been able to find an exact answer in any of these.

>>108493488
I never had big issues with quicklisp itself, just the delays in distribution updates make my ~/quicklisp/local-projects/ folder expand and then I forget about what's in there and don't update, and it encourages others to not even bother making the GH issue to include their package at all because it won't happen until 6-18 months later anyway.
qlot supported pinning on repo url and commit id and maybe hash, or quicklisp distribution month as an alternative, but I haven't touched it in years.
I think part of vend's existence is to support pinning. ocicl probably supports it too. I just hate having external tools for package management after getting used to quicklisp.
Things were nice when quicklisp distributions updated more frequently. Most packages could update without problems, culturally people try not to break things.

File: zbuffer-before.png (265 KB, 468x374)

265 KB PNG

>>108490586
Great project.
https://opengoal.dev/blog/progress-report-q4-2025

(bump)

>>108493488
CLPM?

File: 6d1d2fa2c74f812dbb06bebd0(...).jpg (191 KB, 1575x1575)

191 KB JPG

Is switching to Emacs actually worth it? My entire workflow currently lives in the terminal and browser, using Neovim for coding, config editing, and note-taking. However, I’ve heard Org-mode is more powerful than any other tool available. How steep is the learning curve to migrate my entire setup? I tend to be pretty dense, so learning configs might be a problem, though i dont have problem learning elisp if necessary.

>>108497661
Org mode is seriously fucking bonkers if you go the extra mile and learn elisp. You can pretty much make whatever the fuck you want.

>How steep is the learning curve to migrate my entire setup
Depends on your current setup. Honestly you could probably use Doom Emacs and get 90% of the way there without much effort.

What do you usually do? what kind of notes?

>>108497677
I "tried" Doom Emacs, but I felt uncomfortable, i like setups where I know what plugins (packages I think) I'm using, a full configuration feels overwhelming.
>What do you usually do?
Aside from programming, i use vim to make documents with typst or just anime backlogs and stuff in plain text. I also use typst to take notes that i can then print or share.
I dont need much, just solid autocompletion, a way to manage files within Emacs, and a built-in shell, everything else is just for toying.

>>108497661
You can completely externalise your executive functioning to org mode + the beorg app as a client on your phone, it's great for the common in tech disease adhd .

>>108497757
Makes sense, well in that case if you want a quick setup I recommend: https://github.com/ashton314/emacs-bedrock
It's not a 'framework' like doom, it's simply a config for multiple solid packages that you're meant to simply check for what fits your usecase and either copy it or simply check for reference.
You can get a solid baseline with:
- vertico + corfu + orderless + marginalia
- consult + embark
- evil + evil collection
- org obviously
I know I just threw like 10 things at you with that list but honestly if you're looking to make your own config piece by piece (which is the sane way to do it honestly), I recommend you check out bedrock and see how those packages are configured.
Another starter I like for reference is minimal-emacs.d, don't recommend it if you want to make your own config, but it does have some good defaults to copy from like bedrock.

On org-mode, I love it for writing technical documents, its absolutely worth it on that side, I've even made packages for it to expand my set of tools for job related stuff, but I know there are some who use it for actual academic/fiction writing. From that side you can get reference from Emacs Writing Studio (https://github.com/pprevos/emacs-writing-studio) which is another place where you can get stuff to copy/adapt from, the configuration found there are more geared towards writing and around org-mode.

>>108497844
whoops that's the stale github mirror link.
correct link for bedrock: https://codeberg.org/ashton314/emacs-bedrock

>>108497844
I've heard of some of those, and yeah, I just needed a list like that, guess I'll check them one by one while learning/getting used to Emacs commands.
Thank you mr. wizard

>>108497757
>typst
My condolences

https://itch.io/jam/spring-lisp-game-jam-2026
>You may use existing libraries, third-party or self-created, as long as they have an open-source license.
>You may use existing assets, including but not limited to artwork, music, and sound effects, as long as they are free for others to use as well. You must disclose what you used, and give proper credit where it is due. See Open Game Art for a great collection of freely-licensed assets.
>Code and assets generated by so-called "artificial intelligence" (like a large language model) are not permitted.
What's this guy's problem

>>108498309
lol
>Hosted by technomancy
Ah that makes complete sense. He's one of the most anti AI people I've ever talked with. Not an hypocrite by any stretch of the imagsination though, he seems to be on a steady path towards becoming completely self reliant and free of anything related to AI/Bigtech or non-free software.

Testing out futur. Goddamn async is a fucking chore to do even with this. It's considerably better than raw async though, surprisingly intuitive API. But no panacea, Emacs is still the main issue, I keep getting segmentation faults or emacs getting stuck due to random shit like pressing M-x while the async process was running.

>>108498417
>Testing out futa
I wish

File: ayumu-kasuga.png (126 KB, 332x433)

126 KB PNG

alist vs plist

Which do you prefer?

>>108498785
Giant cocks aside.
It really is a great package, I think I'll start working on a repo to track use cases/how-to

>>108500703
depends on use case.
I think plists would be better if you could actually get completion for them while writing elisp.
I do like to use pcase and pcase-exaustive for setting up cases.
alist for almost everything else where I just need to push and nreverse to assemble something quickly.

How do I use mit-scheme for SICP?
I need emacs and then I need to do what?
I don't get i.

>>108500813
Are you already using Emacs? are you familiar with installing packages and configuring and all that shit?
Regardless, first you need to install mit-scheme:
>https://www.gnu.org/software/mit-scheme/
Then you have a couple options on how to do the excercises. My prefered approach was setting up a mit-scheme repl with geiser and then use org-mode with mit-sch source blocks to keep notes and executable blocks of code.

There's an org-mode version of SICP too: https://github.com/jabl/scip-slides
The absolute quickest way of getting setup is using doom emacs and enabling this in init.el

(scheme +mit)

and that's it. People like to talk shit about doom but it's easy as fuck to get started.

>>108500966
Shit, wrong link to the org-mode version of SCIP, it's this one.
>https://github.com/ilmotta/sicp-org

>>108500966
thanks I guess I get doom emacs

OH fuck this shitty ass book

>>108501139
lol, which? SCIP?

>>108501210
yeah why the fuck do I have to use this shitty lisp mit-scheme emacs for it