Thread 106094218

>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 >>106004428)

first for Clojure is the most productive language in existence ATM

>>106070627
>https://github.com/phronmophobic/easel/
>https://www.youtube.com/watch?v=hpjJJqnkqCw
>Integrate anything: web, 2d graphics, 3d graphics, video, plots, widgets, games, terminal, data inspectors, debuggers, etc
Impressive, very nice.

>>106094210
How is it wrong? You can use a list like a set, CL has functions for doing exactly that.

A list is a strict superset of a set, it's literally just a set with ordering.
Also there's multiple entire libraries of purely functional equivalents to all of CLs destructive operations.
Like for example modf, which works exactly like setf and is capable of all it's actions, but which returns a new value and doesn't alter the original.

>>106094288
do lists have the performance characteristics of hash sets? tree sets?
no, they do not.

>>106094446
Depending on what you store in your hash set, it might have worse performance characteristics. CL also has hashtables, which you can use as sets when you use T as a value.

>>106094475
>Depending on what you store in your hash set
no shit, this is literally the entire basis behind having multiple data structures. you optimize how you store your data based on how you access and interact with that data. there are many cases that I have found where you want a tree structure for storing numerous elements, such as sets of jobs with differing priorities, where new jobs may be inserted with whatever priority, and jobs may finish at many moment and thus be removed. you need to be able to query the minimum and maximum priority of any active job at any moment.
anyway, yes, Common Lisp can obviously be used to implement any data structure you need. I'm not here to shit on CL. I'm here to claim that, at this very moment, I can use Clojure and have access to persistent vectors, lists, hash maps, sorted maps, hash sets, and sorted sets. I can trivially use any standardized Java collection, of which all of these categories are met in a mutable fashion for extremely fast performance. I can access any data structure in the vast Java ecosystem for things like roaring bitmaps, directed graphs, etc. see Google's Guava lib, or Apache Commons Collection lib.

>>106094522
Yeah and CL also has all those data structures and can even use all those java libraries too.
I'm not seeing your point.

>new maxima release
https://maxima.sourceforge.io
https://sourceforge.net/p/maxima/code/ci/master/tree/changelogs/ChangeLog-5.48.md
pretty gud
very underrated lisp software

>>106094582
>ABCL
this is true
how good is its Java interop when compared to Clojure?

>>106094241
what about clojure with an dsl implemented in uiua?

>>106094607
>>ABCL
>this is true
>how good is its Java interop when compared to Clojure?

ABCL has extremely easy Java interop. But the idea is that you mainly work in Lisp and occasionally call some java libraries. Not like Clojure where the JVM classes all leak into Clojure data structures, for example.

I have done it, and it's helpful because thanks for the true interactive development of CL, you can load JVM classes at runtime, inspect what is inside, etc etc, without having to recompile anything or restart your project. Very useful, i'd say.

All in all, ABCL is impressive. I don't use it anymore because I prefer compiling CL to native code; it runs much faster, obviously.

>>106094522
>I can trivially use any standardized Java collection

We can do that in Common Lisp too, at least three (3) choices:

a. Use ABCL (open source, free) thus your Lisp code also runs on the JVM. Java interop is extremely easy.

b. Use Allegro CL (commercial license, though), which will mean your Lisp code will be compiled to machine language, executing massively faster than clojure.

This is what it offers, among other stuff:
"Java Tool Suite: Package applications as Java Beans or Servlets, directly call Java methods from Lisp methods and vice versa, and dynamically generate Java byte codes to run on JVMs. With jLinker, application programmers can choose the socket interface or native JNI interface on most platforms"

c. Use LispWorks (commercial and free licenses available), which also can call Java from Lisp and viceversa. Similarly, your Lisp code will be compiled to machine language, executing massively faster than clojure.

(b) and (c) are professional products with extensive success stories and professional support.

>>106094522
>to persistent vectors, lists, hash maps, sorted maps, hash sets, and sorted sets

I can also have access to all of those using CL.

For persistency, serializing almost any Lisp data structure is a piece of cake, only one line of code with cl-conspack.

Furthermore, most likely some of today's often-used data structures were first prototyped in Lisp...

>>106095469
>executing massively faster than clojure
I highly, highly doubt that. the JVM has far more resources put into it than Allegro/LispWorks can afford.

>>106095501
persistent data structures do not involve serialization, Anon. also Clojure has EDN for serialization, as well as whatever Java supports (including https://github.com/EsotericSoftware/kryo)

what music do you listen to while cooding Lisp? for me, it's https://www.youtube.com/watch?v=H6r3QAsPI5U

>>106095585
The sexp express https://youtu.be/IpeRShWMdYM

>>106095585
https://www.youtube.com/watch?v=aHk42kDwesM

ONCE AGAIN:
CL when single-threaded performance, native execution, startup times, or C FFI are important, Clojure all other times. It's that simple. You can choose more than one language for a single project too.
now fuck off with your dumb arguments

>>106093626
>>106094006
Thank you for answering, but I'm not quite sure I get it yet.
If the main difference really is only the scope, would it be wrong to set everything with setq-default and only using setq on a case-by-case basis? For example, having the indentation be 4 on everything with setq-default but (for whatever reason) using 8 only on the C major mode with setq?

>>106096132
Finally, I have achieved either satori or brain damage

(setopt debugger-stack-frame-as-list t)


This makes stackframes in Elisp look way better. A lot of times, pieces of the stackframe are almost executable. You might have to add a little quoting, but it's nice to see the actual function call + parameters that caused a bug and then be able to run it.

Anyone who uses eww on pages with large images or org documents with large images should check out ultra-scroll. It makes it so that large images in a buffer can be scrolled smoothly (without the jank).
https://github.com/jdtsmith/ultra-scroll

Attached is a video demonstration of me scrolling down a web page with a lot of images in eww. This was the URL if anyone wants to try it themselves.
https://www.realestate-tokyo.com/rent/monthly-apartments-matsuri-technologies/

>>106097439
Have you tried that package with elfeed? It doesn't work for me. It'd be really nice to use that package as I often use emacs on my phone to read my rss feed and images are really annoying with it.

>>106097742
I'm not currently an elfeed user, so no I haven't tried it out that way yet. Did it work for you in eww at least? (I didn't do any mode-specific config. I feel like it shouldn't matter what mode you're in.)

>>106097742
Also, on my desktop it's only setup to scroll nicely when I use my mouse wheel. Using the keyboard scrolls the original way.

C-M-l (which is mapped to reposition-window) is kinda nice. It's like C-l, but it's aware of functions. It scrolls the window such that the function or definition you're currently in is maximally visible.

>>106096132
>15 years ago
Holy fuck

>>106097439
This is the shell script I used to record the window.
#!/bin/bash
slop=$(slop --nodecorations -f "%x %y %w %h %g %i") || exit 1
read -r X Y W H G ID <<< $slop
ffmpeg -f x11grab -s "$W"x"$H" -i :0.0+$X,$Y $@

Usage:
screen-record video.webm
# Then choose the window to record.
# When you're done, Ctrl-C.

>>106095518
>I highly, highly doubt that. the JVM has far more resources put into it than Allegro/LispWorks can afford.

What part of "direct compilation to machine language" and "no virtual machine behind" is hard to understand here?

>>106099142
The JVM having all those resources put into it only made it minimally acceptable.
It’s fundamentally a stack based VM running on register hardware. At one point IBM has 2400 researchers working on it, and in the 90s IBM donated their fixed point code and algorithms from the 70s that was used on mainframes.
The whole JVM thing was not viable from the get go. Only tesponses posted from the HotJava browser will be accepted.

Single cores are pretty fast now, but it’s clear lispen will really start to shine in multi-core processors, unfortunately for elisp, that ship might have sailed, but there is a chance for some of the other ones that don’t target the JVM.
It’s funny, even when it was clear that processors were on the rise with Sun E10K with 64 of them, they still hadn’t implemented the synchronized keyword. Java and the JVM remain worthless, bloated, slow, slop.

>>106097439
>https://github.com/jdtsmith/ultra-scroll
very nice

>>106097439
What theme is this?

bros how do i tell sbcl to shut the hell up about type comparison notes?

I'm just trying to run this:
https://gist.github.com/matthew-ball/4499300
and have added type declarations on absolutely everything at this point, and it still wont shut up when i try to compile it. it runs fine, it's just xlib type optimization nonsense from the clx/xlib code. i just want it to leave me alone ;-;

>>106101163
never mind, i got it. it was this:
(declaim (sb-ext:muffle-conditions sb-ext:compiler-note))

but for some reason it wasn't working when i tried compiling it with C-c C-c. it only worked once I put it in the repl and then compiled the function. phew, i was going insane

>>106101048
ef-reverie

>>106095585
https://www.youtube.com/watch?v=ed8N141l9FQ&list=RDed8N141l9FQ&start_radio=1

I want to experiment with lisp cffi to make bindings to raylib

>>106101718
https://www.raylib.com/
i like their web site.

>>106101718
Have you tried using
https://github.com/longlene/cl-raylib
?

>>106101762
I know it exists but I am curious to do it by my own. I want to understand how it's done. I don't think I will import everything.

>>106097742
>as I often use emacs on my phone
How? Emacs from fdroid? How do you deal with the lack of keyboard

>>106097439
If you have a pointing device that can send high-precision scrolling events, it's super smooth. I just tried it on my laptop and scrolled using the touchpad, and it is pixel-precise. I never thought I'd see the day Emacs scrolled this smoothly.

My laptop happens to be a Thinkpad, so scrolling with the clit wasn't enough. I had to scroll with the touchpad. They both send <wheel-up> events, but I guess the data from the touchpad is more precise.

>>106097742
>I often use emacs on my phone
I tried emacs on my phone, and I didn't try to put ultra-scroll on it yet, but I did `C-h k` and then tried scrolling to see what event it used -- <touchscreen-scroll>.

Then I looked over in the ultra-scroll repo, and there's no mention of '<touchscreen-scroll>' anywhere. You might have to bind '<touchscreen-scroll>' to #'ultra-scroll yourself.
(keymap-global-set "<touchscreen-scroll>" #'ultra-scroll)

https://benchmarksgame-team.pages.debian.net/benchmarksgame/index.html
^-- Wasn't there a dynamic version of this in the past where you could submit a form to compare two languages against each other? Is it still around anywhere?

>>106101163
It only prints these on optimize level 3 afaik. You must have some global optimize declaration somewhere.

>>106099405
Don't underestimate the JVM.
https://rentry.org/java-vs-sbcl

>>106102980
Data:
https://salsa.debian.org/benchmarksgame-team/benchmarksgame/-/tree/master/public/data
I modified their makemd.py to just print java and sbcl results.

I really like pcase and now pcase-let*. They make Elisp programming more fun for me.
https://www.gnu.org/software/emacs/manual/html_node/elisp/Destructuring-with-pcase-Patterns.html

>>106103325
Sort your tables by execution time, queer

>>106104099
Rude

>>106103273
hmmm if i run this (same way as the muffle-conditions), it still prints them though:
(declaim (optimize (speed 0) (safety 0) (safety 0)))

aspell or hunspell for spell checking in emacs? which one is better?

>>106106181
just do it, alt-shift-4 (i.e. m-$) is great. then if you don't like the suggestions, switch a backend. that's it.

>>106106181
What does Emacs use by default? I've never configured it, but I use ispell-word from time to time. Whatever the default is seems to be enough for me.

>>106106181
jinx
https://github.com/minad/jinx

>>106103738
All of stefan monnier's stuff is great. I extensively use pcase (check out pcase-defmacro, pcase-lambda and pcase-dolist), cl-generic (cl-generic-define-generalizer has allowed me to do some cool things), oclosures, gv, define-inline for easier compiler macros, and other stuff I haven't used yet.

>>106101842
https://www.emacswiki.org/emacs/EmacsOnAndroid

>>106109691
>stefan monnier
I didn't know who he was, but an initial search leads me to believe I should be very grateful for the work he has done in the past for Emacs and Elisp.

>(check out pcase-defmacro, pcase-lambda and pcase-dolist)
I'll get there eventually.
- I started with pcase maybe a month or two ago, and enjoyed getting pattern matching in Elisp.
- I just found pcase-let* last night, and being able to do destructured binding of variables save me a little time (but more importantly, brought a smile to my face). It was very satisfying to use.

>cl-generic
I am a big fan of generic methods. I have used them in Julia and Common Lisp. However, I haven't yet had a chance to use them in Elisp.

hey guys, where can i find a good tutorial or something for CLOS? I always read people glazing it but i don't get it lol maybe i've been too indian'd by python that now i can't conceive anything other than that style of OOP

>>106112945
The only CL reference I keep going back to is:
https://lispcookbook.github.io/cl-cookbook/
The CLOS chapter is pretty good.
https://lispcookbook.github.io/cl-cookbook/clos.html

What's not obvious is how nice defgeneric/defmethod can be. Most languages don't have generic multimethods, so you're not going to have a feel for how to use this feature. An exception to that is Julia where all methods are generic by default, and this feature is used heavily. If you have enough Julia experience, you can "backport" some of the method dispatch experience to Common Lisp where it works similarly.

Another fun feature of CLOS is its ability to to add method modifiers (before, after, and around) a method.
https://lispcookbook.github.io/cl-cookbook/clos.html#method-qualifiers-before-after-around
This feature exists in other languages under various names like "advice". For example, Elisp has advice-add which is similar.

>>106107974
>https://github.com/minad/jinx
nice ty

>>106114730
last time i was using jinx on windows, it didn't exactly work in msys2. because the backend, enchant, failed to find dictionaries. don't know about cygwin and wsl, it probably works there.
jinx does have one nice thing over ispell, that's easy bilingual dictionary setup.

pretty gud
https://clojure.land
https://clojure.org/news/2025/07/28/deref

>>106102042
>If you have a pointing device that can send high-precision scrolling events, it's super smooth.
What kind of mouse do I need to get high precision smooth scrolling? Would a gaming mouse suffice?

>>106107875
/usr/bin/ispell

>>106107974
nice but that's not a backend like aspell or hunspell

Thoughts on https://github.com/moderninterpreters/markup ?

>>106118682
- It's clever.
- I was a bit worried about editor support, but it looks like he has that covered (at least for Emacs).
- I personally like the look of sexps, so I'm gonna stick with spinneret or hsx for my CL html needs.

>>106118682
Why would you want to use XML closing tags mental illness instead of (h1 ,(prog x) (em "world") "!")? Perhaps with reading macros to get rid of string quotations marks.

>>106120187
If you're working with a non-Lisp front end designer person, I could see it being useful. (Maybe)

If you're in the mood for a retro font...
https://github.com/unjordy/LispM-Font

>>106120274
Unfortunately, it doesn't render some unicode punctuation very well.

>>106120187
https://github.com/moderninterpreters/markup?tab=readme-ov-file#motivation

>>106118682
>,(progn x)
why not just ,x?

>>106120285
gnu unifont

>>106121103
Great question

>>106122985
That's silly, just have an LLM generate code and use that code. Too much magic.

>>106123082
>missing the point
git gud anon

Every time I try new editor I notice how smooth the ui compared to Emacs, so I thought I could try to write something to replace the gtk ui and spent a day reading Emacs src/
I don't want to write new ui anymore and I think I should use to another editor
I will check out lem
thank you for reading my blog

ELISP> (pp-to-string (lambda () 42))
"#[nil (42) (t)]
"

ELISP> (funcall #[nil (42) (t)])
42
(#o52, #x2a, ?*)

I accidentally discovered an alternative way to define lambdas in Elisp, but that does the final (t) mean?

How the fuck do you use eglot, pylsp and python venvs?

I do not care about pyenv, venv suits me fine.

>>106125384
heh, pp

>>106125667
such a pain in the ass. jfc, I will just use etags and a dir local file with
((python-mode . ((eval . (push ".venv/bin" exec-path ))
(eval . (push "VIRTUAL_ENV=.venv/bin" exec-path ))
(python-shell-virtualenv-root . ".venv/bin"))))


eglot is CANCER

>>106125384
>but that does the final (t) mean?
This kinda came up in the last bread (>>106008854) where a lambda has 3 parts (params, body, environment), so t is likely the value of lexical-binding at the time the closure was made or something else related to the local environment

>>106125384
There are 2 more slots they can have as well.
https://www.gnu.org/software/emacs/manual/html_node/elisp/Closure-Objects.html

>>106126040
>eglot is CANCER
werks on my machine

>>106127612
share your setup?

>>106124345
What's the point then?

>>105941549
Guise, it didn't even show up in the mcron logs. Was expecting it to run on Friday. Wat do?

>>106128155
learn to unit test

Not wrong, but prone to side effects, specially when so much shit is interconnected in obscure ways. aiming for smaller scope would be more stable or easier to debug.

>>106128241
Teach me, senpai. Onegai. Simply want to run it every other month.

>>106128341
meant for >>106096320

>>106128241
It’s funny, some languages are based on the assumption that no testing is going to be performed. Rust comes to mind.
Testing is usually 80% of the work, even in lisp.

>>106128453
>It’s funny, some languages are based on the assumption that no testing is going to be performed.
>Rust comes to mind.
LE what?

>>106128453
I've written quite a bit of Rust and you absolutely still need to test. Cargo has built-in testing capabilities, and `debug_assert` macros for assertions in debug releases

>>106128359
Not that anon but what lisp is that? Guile?
If that's the case you could lookup srfi-64

I FUCKING LOVE CLOJURE

>>106124831
>Emacs
>UI
wut

I FUCKING LOVE CLOJURE

>>106128790
>>106128873
if i use clojure i will look like this?

>>106128885
Nope
You will look like this

>>106128964
this is me writing Clojure

>>106128964
Billy Kane Billy Kane lookin' kind of lame. I'm going to put you on point and make them mad so they up and quit the game.

https://www.youtube.com/watch?v=NOYVkOFWcP8

>>106125761
This led me to lookup the pp* functions, and I discovered something nice. I KNEW they changed the pp algorithm in 30, because 29's pp was so much nicer. Today, I found out that there's a pp-28 and pp-29 in addition to regular pp AND when I call pp-to-string, I can pass in an optional pp function if I want the older style. This let me fix a minor bug in my init.el.

>>106126229
>>106126379
Thanks for helping me understand.
ELISP> (let ((a 1) (b 2)) (lambda (c) (+ a b c)))
#f(lambda (c) [(b 2) (a 1)] (+ a b c))

ELISP> (setq fn *)
#f(lambda (c) [(b 2) (a 1)] (+ a b c))

ELISP> (pp-to-string fn)
"#[(c) ((+ a b c)) ((b . 2) (a . 1))]
"

>>106130146
he's the old pp enjoyer

>>106130694
Old pp is long and aesthetic.
New pp is short and fat.

>>106131902
Kek'd

>A minimal web framework for CHICKEN Scheme, inspired by Sinatra.
https://github.com/rolandoam/schematra

>>106128873
Too bad it’s a JVM thing.
Too bad Oracle is re-propritarizing it.

>>106134254
Is it possible to use this with another Scheme (like Guile)?

>>106129085
He's smoking a filter

__ Why vend? __

Dependency management in Common Lisp has traditionally centred around [[https://www.quicklisp.org/beta/][Quicklisp]]. A desire for access to more rapid package updates spawned [[https://ultralisp.org/][Ultralisp]]. The need for version pinning and isolation birthed [[https://github.com/fukamachi/qlot][Qlot]]. The want for a better distribution system brought us [[https://github.com/ocicl/ocicl][ocicl]].

But, could there be a simpler paradigm than just /downloading the code and putting it right there/ ?

With =vend= :

- We need not perform bespoke installation scripts to get started.
- We need not wait for Quicklisp to update.
- We need not relegate all our systems to =~/common-lisp/= .
- We need not worry about where ASDF is looking for systems.
- We need not fret over tools performing strange internal overrides.
- We need not manage extra config files or lockfiles.

Plus, =vend= is actually an external tool with extra commands to help you inspect and manage your dependencies.

https://github.com/fosskers/vend

>>106135140
Nice! Someone else posted another manager the other day. Cochlea? Cocli? I don't recall.

>>106135973
That was someone else. I liked that one too.
https://github.com/ocicl/ocicl
I'm not sure which I like better, but I think both are an improvement over the status quo.

- Emacs comes with color.el which provides many functions for working with colors.
- One such function is color-rgb-to-hex.
- However, a complementary color-hex-to-rgb did not exist, so I tried writing one.
(defun color-hex-to-rgb (color)
"Transform a hex encoded COLOR to individual RGB components."
(let* ((_ (string-match (rx "#"
(group (= 2 hex-digit))
(group (= 2 hex-digit))
(group (= 2 hex-digit)))
color))
(r (cl-parse-integer (match-string 1 color) :radix 16))
(g (cl-parse-integer (match-string 2 color) :radix 16))
(b (cl-parse-integer (match-string 3 color) :radix 16)))
(mapcar (lambda (n) (/ n 255.0)) `(,r ,g ,b))))

Here's how it works now.
(color-rgb-to-hex 0.5 0.5 0.5 2)
;; "#7f7f7f"
(color-hex-to-rgb "#7f7f7f")
;; (0.4980392156862745 0.4980392156862745 0.4980392156862745)

- I feel like I should make color-hex-to-rgb not hard-code 2 digits per R G B, but I'm unsure how.
- How should that be handled?

>>106136254
I also don't like that 0.5 turned into 0.498 in the round trip, but I'm not sure what I can do about that.

>>106131902
What theme is this?

>>106136362
gotham
https://depp.brause.cc/gotham-theme/
I've tweaked it a bit though.
(setq my/theme-tweaks
`((gotham
. ,(lambda ()
(my/fringe)
(my/tab-bar-auto :percent 69.0)
(my/org-faces)
(ctsf 'gotham
'(org-block
(:background "#10161c" :inherit unspecified)))
(my/shr-faces)
(my/info-faces)))
))

- I think it provides the foundation for a really good dark theme, but like many older themes, it's missing customization for a few faces like tab-bar-* and fringe.
- Over the past few days, I've come up with a system for customizing themes in a localized way.
- I used to use set-face-attribute to implement little theme tweaks, but the changes made that way are too global and can bleed into other themes which I don't like.

>>106136501
I posted about this in more detail over in the Elisp thread on Lain. It's more code than I'm code than I'm comfortable posting here, and syntax highlighting is better there.

>>106136579
>>106136501
nta.
nice, very nice, anon. i'll even do you a favor and never-ever post on that nice, juicy altchan you've mentioned. and thank you for the ctrf in particular, this may be something i'll take for myself.

>>106112945
>hey guys, where can i find a good tutorial or something for CLOS? I always read people glazing it but i don't get it lol maybe i've been too indian'd by python that now i can't conceive anything other than that style of OOP

Practicel Common Lisp covers it.

>>106134283
>Too bad Oracle is re-propritarizing it.

You mean the JVM? Or Clojure, specifically?

>>106137341
One thing I forgot to mention is that you can run ctsf as much as you want to setup face attributes, but they won't take effect until you do:
(enable-theme 'gotham) ; or whatever theme you were modifying

- You can use ctsf in the same spirit as set-face-attribute.
- Think of it as a safer alternative that keeps the changes theme-specific.
- custom-theme-set-faces (which ctsf wraps) is the same function that actual themes use for face setup, so you're really modifying the actual theme this way.

>>106112945
>>106113488
the Lisp cookbook basically covers some of Keene's book so that would be a more substantial reference
The Art of the Metaobject Protocol is a good book to really get into what CLOS does at a deeper level

>>106135140
>But, could there be a simpler paradigm than just /downloading the code and putting it right there/ ?

Sounds good to me.

Either this or quicklisp. Qlot, as most fukamachi software, is a pain to use.

>LISP was literally originally intended as *the* AI programming language
I wish this would come back and no more gay ass neural nets

>>106137445
It was used in expert systems which are just not a good idea. There are far too many implicit rules we know and it's too hard to explicitly codify intuition and contextual knowledge which makes them untenable. Especially considering how good things like convolutional neural networks are at e.g. diagnosing cancer, there is no reason to expect neural networks to ever go away.

>>106137402
>Keene's book
This one?
https://doc.lagout.org/programmation/Lisp/Object-Oriented%20Programming%20in%20Common%20Lisp_%20A%20Programmer%27s%20Guide%20to%20CLOS%20%5BKeene%201989-01-11%5D.pdf

>>106137603
Yeah, you can tell because the author's last name is Keene and it's a book about the topic we were discussing.

>>106134283
Clojure also runs on Javascript
there is a incomplate C# variant
also Jank is a C++/LLVM variant that is in the works
I would like to see a Go variant too

>>106138056
>Clojure also runs on Javascript

That's not the full Clojure language.

>>106138056
>Jank is a C++/LLVM variant that is in the works

1. Not production quality

2. That would mean dealing with the cancer that is LLVM.

You're stuck in the JVM. Meanwhile Common Lisp compiles down to native code for several different CPU architectures.

Sat, Aug. 9th, 2025, 13:00 UTC
https://clojureverse.org/t/macroexpand-2-connecting-clojure-data-practitioners/11485

>>106136579
I thought lain was dead

>>106137445
At least for programs and other formal stuff symbolic AI will win in the end

>>106135140
Ah, yet another one

>>106137395
The JVM. Everybody that was heavily invested in it (e.g. IBM) from the Sun days has been trying to get off it now for a decade.
The failure of the Sun Pico processor that supposedly ran JVM natively back in the 90s was quite telling. Similar to lisp machines’ hardware.
Java has always been a cpu/memory hog and they were able to turn that into hardware sales for a while, but they’ve finally squeezed the last drops out of that.

>>106141397
source?

I spent the last three days trying to understand why SDDM wouldn't work on Guix, I even wrote a long ass post saying how much of a failure retarded faggot I am for being unable to change display managers. Turns out it's either a linux-libre or VM issue because it worked first try on my laptop.
I think I even got rate limited for a while because I was downloading shit at 16kbps tops (I got mad and kept nuking the VM just in case after some time).

>>106141698
>I think I even got rate limited for a while because I was downloading shit at 16kbps tops
idk these past few days i've been having some trouble reaching the guix servers. i wonder if it's related to this
https://www.fsf.org/bulletin/2025/spring/defending-savannah-from-ddos-attacks

>>106135140
>https://github.com/fosskers/vend/issues/16
Why is no one considering a sexp configuration format?

>>106138090
>That's not the full Clojure language.
ClojureScript implements enough to do this.
https://wizardmasters.io/
https://github.com/ertugrulcetin/wizard-masters
It's far more capable than you give it credit for.

>>106142381
Tell him.

>>106142830
I'm sure there's a reason it hasn't been brought up, I don't want to sound like a brainlet

>>106142381
Sounds like, literally, retardation. That’s why.

>>106142973
nigga just bring it up
even if you did not forsee something, you will only learn in the process
it's not like they are going to be "AHHHHHHH A BRAINLET, GET THE FUCKING M240 AND HUNT THIS MOTHERFUCKER DOWN!!!"

>>106143035
More like, “oh, you smart. You make us go. You help us and give us code”
> comes to your house, abducts you and locks you in a basement with a keyboard, a beige tower and a crt monitor

>>106143114
>comes to your house, abducts you
I would magdump them with 5.56 NATO
I code in Lisp and defend with blicks

>>106139852
It's very slow, but the flip side of that is that I don't have to worry about threads falling off the end of the catalog. If I come up with something memorable, I sometimes post both here and there.

>>106139852
Not so much dead as undead. I monitor like 5 threads and they get a couple posts a month all together, it's still shambling along.

>>106142996
Oh
>>106143035
>it's not like they are going to be
How do YOU know?
>>106143173
>5.56 NATO
For me it's 7.62x39

Right now you can't use a substitute for the full Linux kernel on Guix because there are none available for the latest version?
https://cuirass.nonguix.org/search?query=linux
And the only way to use a substitute would be to pin it to the latest one built?

>>106143286
>How do YOU know?
Why do you care?
Fuck anyone who disrespects you.

>>106143534
I can't fuck THAT many people, anon. Anyways, I don't have a throwaway github account so I'm not posting potentially retarded questions under my real name. That's all there is to it.

Hell is other people's web stack.

>>106137632
kek

>>106145053
What's yours?

>>106145359
I have a few.

static sites:
JSON -> perl scripts -> markdown -> rentry.org
JSON -> perl scripts -> markdown -> pandoc -> pgs.sh
(upcoming) Org -> Elisp -> pgs.sh

dynamic sites:
SQLite -> perl scripts
SQLite -> CL (mito, spinneret, hunchentoot, hunchensocket, htmx)

Some people would think hunchentoot is kind of a pain, and I wouldn't blame them. It's a bit antiquated. The other stuff is too small to be hellish.

Sacha accidentally reposted an Emacs News post from 6 years ago.
https://sachachua.com/blog/2025/07/2019-08-12-emacs-news/

>Lame ass languages like JavaShit and Poothon dominate while infinite computational universes of LISP remain unexplored
We live in a fallen world

>>106145828
women amirite

>>106147248
It's interesting to see what was going on back then, and to see what's changed and what's stayed the same. Not all accidents are bad.

Has anyone ever used Chicken Scheme for something serious? Was going to try and use it for microcontroller stuff but I dunno how viable it is

Smalltalk is as good as lisp.

>>106141397
Don'f know what are you talking about, OpenJDK is FOSS and you can use any build from a decent list of vendors if yoh don't wanna compile, including Eclipse Temurin. Are you talking about GraalVM?

>>106148746
How exactly is smalltalk implemented anyway?
Like what's the compiler/interpreter doing under the hood?
One of the main reasons I like lisp is I actually know what's going on in there and can understand it.
I'd hope it's some sort of elegant "this is what OOP is supposed to be" code, but I fear it's going to be a java saar nightmare forest.

>>106141397
your interpretation may be a couple of decades old, JVM hell is forever

>>106148998
Honestly I don't know. I just started using it and I wanted to talk about smalltalk.

>>106094218 (OP)

You need to add Calva under Clojure... that's the best Clojure extension in the world for VS Code.

https://calva.io/

>>106149409
I'll try. Jeetbrains' Cursive was completely useless it shat itself for 40 mins and couldn't scan a simple Hello World cljfx app, i ended using the command line and solved it in 3 minutes.

>>106128801
emacs is known for being awfully slow when typing (if you compare to other programs)

>>106150345
I've been there many times. Everytime I've tried lem and other emacs like replacements I come back to emacs after a couple days. I hate that there's so much baggage but at the same time I've used emacs for so long and depend too much on its tools. Maybe if there was a simile to org mode I would make the switch to lem. But thats a completely different can of worms, there must be a way of getting 80% of the way to emacs in lem with 20% of the effort.

>>106150509
I mean it's definitely convenient once you're used to it, I'm not denying that. But sometimes I wonder if I should reevaluate my workflow and implement more specific tools, like using Obsidian for notes and so on.
Emacs is only irreplaceable if you insist on having a single place for a bunch of things, which is quite silly when you think about it, you wouldn't be pissed at your car for not making you coffee.

>>106148746
Do you use gtoolkit?
https://gtoolkit.com/

Anyone using org export html to publish a blog here?

https://www.gnu.org/software/emacs/manual/html_node/org/HTML-Export.html

https://www.gnu.org/software/emacs/manual/html_node/org/Publishing.html

>>106151475
I tried but due to the nature of org the css is a nightmare.

>>106151647
How so?

>>106095136
>uiua
I fail to see how a spinning cat can improve the language.

>>106151710
There is just a ton of CSS rules because org text can be many different things. I ended up looking through the org manual, org-bloggers' css, and the ox elisp code. It was just too much. Here are some of the resources I used then:
https://orgmode.org/manual/CSS-support.html
https://gongzhitaao.org/orgcss/
https://github.com/gongzhitaao/orgcss/tree/master/src/css

I was coming from using org to write latex documents which worked beautifully and I was very disappointed by the complexity of ox-html.
If I were to do it all over I would investigate/make something like this: https://github.com/balddotcat/ox-slimhtml

>>106145502
>2025
>Perl

>>106150740
The reason you come back to it is because your entire OS should work that way. The reason it feels slow/bad is because you're trying to do that with a text editor.

>>106152510
perl is good. Much better than pretty much anything else you could pick for that job/web shit. Everything else is slower and can't do as much as easily. I miss the days when perl was what everyone suggest you learn first over python (and php for web shit). perl is a much better language when you factor in working with shell scripts and CLI.

>>106153967
nigga, Emacs is single threaded

>>106154398
Yeah no shit. Doesn't change anything I said.

>>106148746
it is, it's an excellent environment.
I am actually trying to replicate some of the smalltalk environment inside lisp.
I figure if I can have a mix of lisp and smalltalk, I can have my ideal programming environment.

>>106148998
>One of the main reasons I like lisp is I actually know what's going on in there and can understand it.
Smalltalk is fully introspectable.

Kino
https://www.youtube.com/watch?v=ckOpWQYpKjo

>>106155700
>Smalltalk is fully introspectable.

Smalltalk is great too. But Lisp is a bit more flexible if you want to do low level stuff or hi-perf stuff. Plus, i prefer CLOS OOP to message-passing OOP.

>>106150345
> emacs known to be slow
Visual Studio… when they started writing it in .Net was one of the slowest things I’d used. Noticeable typing lag. It reminded me of the Java based Corel Suite before they dropped Java forever in ’97.
Then, some years later, I tried visual studio code. It was absolutely unusably slow. A pull down menu would take over a second to draw each menu item.
This was the same system I used and developed on with emacs on daily, some office dell thing.
I won’t include eclipse in this for obvious reasons.
Yes, these probably run better if I buy a new 64-core threadripper 3d max with 128 Gb of ram, and a 4090 Ti Founder’s edition gaming pc every year, but that’s not what we get at work.

t-thanks anon

>>106158255
Not sure that overkill is something you could ever accuse sexps of, it’s the epitome of minimal, necessary and sufficient,

>>106158290
Agreed, especially in terms of implementation. Reading a sexp list of cons pairs is easier than reading lines and splitting them by a space.

>>106158349
you can't just do eval on a config if it isn't trusted
see Clojure's dedicated EDN format

>>106158498
Why would you eval a config? You just read it

I just read a few pdfs about the smalltalk interpreter and it's implementations.
I'd say I like a lot of how it works, but I'd change several things borrowing from lisp.
First the whole multi-word operator thing is ridiculous and weird, just go to regular function syntax with parens.
Second I'm no a huge fan of how processes and memory management are handled, there need to be more control and more separation of both to allow for at least the possibility of security or sandboxing.

Biggest feature that puts lisp and all other languages to shame is definitely the focus from the very start of graphics, sound, and UI. Just being able to natively write the entire editor, browser, and renderer directly in the base language without importing any libraries make it Emacs++.
And that's impressive now, let alone when this shit was designed, it's absolutely criminal how shitty the current state of GUIs is when this shit was running a full web browser back in the era of dotmatrix terminals.

What is this menu? How do I invoke it? Where do I read more about it?
Thanks a lot

>>106158672
that's just an LSP thing, it wants to know the project directory so it can scan it

>>106158764
I think I have kinda figured it out now.
It was giving me problems because I'm just learning how to work with Makefiles, and then, a little later, I was not understanding why was I able to compile my project, but clangd wouldn't find where the .h files were located.
So I started trying out a lot of stuff, like generating compile_commands.json with bear, with no success, and at one point, I tried to move the directory to some other place, and that little menu popped out, I pressed 'i' and clangd managed to find the .h files.

Then I learned that I can do M-x lsp-workspace-folders-remove to remove the top directory where all my projects live, open a project, and that little menu will pop up again.
It seems like a lot of work but at least it's a workaround.

Thanks for replying.

bro why did no one tell me about registers? this shit is good

>>106159195
Emacs is full of goodies, yes.

>>106159195
>registers
?

>>106160754
Ask emacs.
C-h a register RET

>>106155700
Does smalltalk have macros? How does metaprogramming work? I assume it has it but i've not found much about the details.

>>106157374
Soon

what are you guys working on today?

>>106162800
yeah good morning team, so yesterday I worked on my story, and i'll just be continuing on that today. no blockers.

>>106162800
finishing my auth lib (and, in the process, my other lib that wraps NextJDBC and HoneySQL)
I am in permanent nicotine withdrawal and it SUCKS!

>>106163522
I have an automatic retry mechanism for my serializable transactions (when serialization failures occur)

>>106163578
as well as my own migration tooling
my database interaction is very weird in that I abuse the fuck out of Postgres schemas to represent database subsets for libs. kind of like microservices but without separate DBs

>>106162800
also, I was working on this port from my old Elixir code, but got distracted and it is in an unfinished state
this algorithm allows for the encoding of a sequence of numbers in base X to a sequence of numbers in base Y. it makes generic things like base64 or hexadecimal encoding.

New Helix Plugin
https://github.com/Ciflire/helix-discord-rpc
It's more rust than scheme, though.

>>106165751
https://github.com/helix-editor/helix/pull/8675#issuecomment-3161096232

>>106165751
>>106165763
Interesting. I wonder if Helix+Steel will be able to integrate with IRC and Matrix as Emacs does.

>>106166298
I'm sure it'll be possible, but there's a lot of infrastructure that needs to be built out first.

>>106166298
BTW, my favorite feature of ERC is how it makes Emacs-related text clickable.
- Quoted symbols like `cl-remove-if-not' will go to help.
- (info "(erc) Modules") will open an info page.

I also like that I can leverage all of Emacs' window and frame management to setup windows to various channels. I don't think most terminal irc clients would allow me to do what Emacs lets me do with relative ease.

>>106166444
Nice trips.
I hope so. Helix+Steel is very promising.

I miss that person who would post with "Scheme!"

>>106169736
He did a good job keeping the thread alive when it was in a lull.

But why?

>>106170049
I wished I saved the gif he used to continue his legacy

Java!

>>106170659
holy shit

>>106094218 (OP)
why is emacs this way on Mac

https://xlii.space/eng/emacs-the-macos-bug/

>>106094218 (OP)
Who’s this cutie in the OP?

>>106170728
>itoddleros
who cares

>>106170576
>But why?
For fun, but...

../.----./-- .../--- -/../.-././-..
---/..-. -/..../../... .--/---/.-./.-../-..
..-./..-/.-../.-.. ---/..-. .-../.././.../.-.-.-

>>106170576
> .-././.--./.-../-.-- -/--- -/..../../... .--./---/.../- ---/.-.
> -.--/---/..-/.-. --/---/-/...././.-. .--/../.-../.-.. -../../. ../-.
> ...././.-. .../.-../././.--./.-.-.-
I tried to use tesseract to OCR the image, but it failed. I then manually transcribed this. It's really taxing on the right pinky to input morse code.

>>106170814
>>106170848
Sorry bwos it was the first thing that came to mind...

>>106170848
I need to learn how to use my right pinky when typing. For whatever reason it's the ONLY finger I don't use

>>106170912
How do you hit RET?

>>106170912
I don't think anyone uses it other than hitting enter.

>>106170924
Slam it with my index finger and exclaim "I'm in"
>>106170928
You're right, I didnt even notice I do use it

- Emacs daemons should NOT be started as a system service.
- Emacs daemons should be started and stopped as easily as one starts and stops tmux sessions.
- Sometimes, having process isolation is a good way to work around some of Emacs' weaknesses, and this is one way to achieve that.
- When you're sufficiently proficient in managing multiple Emacs daemons, you don't even need tmux anymore, even on servers.
- The only issue is the ergonomics of emacsclient.
- It needs to be wrapped with functions or aliases to make this workflow feel good.
- Adding keybindings to your window manager to call emacsclient in useful ways helps too.

Another Helix plugin has been released.
https://github.com/gerblesh/modeline.hx

This is "modeline" in the vim sense where a magical string at the end of a file can be used to provide buffer-local settings.
# vim:ts=4 ft=py

The Emacs equivalent is called a file variable or a file local variable.
https://www.gnu.org/software/emacs/manual/html_node/emacs/Specifying-File-Variables.html
;; -*- mode: Lisp; fill-column: 75; comment-column: 50; -*-

This extension supports Emacs-styled file local variables too.

>>106172013
https://github.com/helix-editor/helix/pull/8675#issuecomment-3162576669
This one is pure Scheme, but it currently requires the author's nonstandard fork of Helix to run (so like a fork of a fork).

>>106170576
| <r> | <l> | <r> | <l> |
| Letter | Morse | Letter | Morse |
|--------+-------+--------+--------|
| A | .- | U | ..- |
| B | -... | V | ...- |
| C | -.-. | W | .-- |
| D | -.. | X | -..- |
| E | . | Y | -.-- |
| F | ..-. | Z | --.. |
| G | --. | 0 | ----- |
| H | .... | 1 | .---- |
| I | .. | 2 | ..--- |
| J | .--- | 3 | ...-- |
| K | -.- | 4 | ....- |
| L | .-.. | 5 | ..... |
| M | -- | 6 | -.... |
| N | -. | 7 | --... |
| O | --- | 8 | ---.. |
| P | .--. | 9 | ----. |
| Q | --.- | , | --..-- |
| R | .-. | . | .-.-.- |
| S | ... | ? | ..--.. |
| T | - | | nil |
|--------+-------+--------+--------|
#+TBLFM: $2='(cdr (assoc (downcase (substring $1)) morse-code))
#+TBLFM: $4='(cdr (assoc (downcase (substring $3)) morse-code))

>>106172102
credit: https://www.reddit.com/r/emacs/comments/fa5wwd/comment/fiwryfa/

(I just added a missing closing paren and made column alignment explicit.)

>>106161342
Wait until he learns about mark and point

Is helix's aim to replace Emacs? So we'll have emacs, lem and helix to pick in the future?

>>106158527
> eval a config
In the 90s, what we now call “json” was banned through firewalls because intellectual midgets were using the fast javascript parser written in C to read data with it. It had the side effect of executing any code in there unless it was time consumingly sanitized in JS thus defeating the speed of native evaluation.

It seems that, as a minimum, —and since they astonishingly deviated from XML anyway—for CSS they could have used sexps.

However, I’m not sure I’d want web troglodytes’ input on the next scheme standard after the R6 debacle that necessitated calling Sussman back in (out if retirement) to re-educate the current generation.

>>106172192
Helix has attracted more former vim users than anyone else. I've said this before, but an unconfigured helix feels like well-configured vim. It doesn't "feel" like Emacs at all. Even with the addition of Scheme as an extension language, I'm a little concerned about their documentation. I would love for them to take all the things that Emacs and Elisp did right and incorporate them into their Scheme-based extension system. It's not quite there, and I don't know to what extent they want to make helix self-documenting in the way Emacs is.

>>106158255
What is this? A forum?

>>106173416
Look at the screenshot.
It has so many clues.
Think.

I think it may be some sort of hub.. For git projects.

>>106170576
Why not? (￣︶￣)

>maybe we should keep 4chan links to nil... also it doesn't add anything to this conversation other than some bad language and attitudes....
He's right, quit shitting up that isuue

>And yes, if 4chan wants to participate, they can do so directly in here themselves.
This is NOT an invitation for an attack btw. Stay respectful to fellow Lispers, even if they also use Rust and look like pic related

>>106176431
gigachad aryan lisper

>>106176376
>no not le heckin 4chan in my github issue reee
ꜱoydev plebbitors are such faggots

>>106176932
>he says in his echo chamber
Attach your real name to that, pussy ass faggot

>>106176972
go back to >>>/r/eddit nigger

Another day with lisp, another day of happiness.

>client hiring me to build a custom CMS
>they dont have technical staff so I basically have free reign over tech choices
I'm going to propose writing it in Common Lisp. Fun + vendor lock in? Yes please

>>106177100
good luck. I would give serious consideration to Clojure instead, simply due to the astronomical amount of tooling that exists on the JVM.

I want to do something like:

((MyFunc 1 2 3) 1 2 3)


Where before the outer form is evaluated, MyFunc is called and returns another function like MyFunc2, so then this form is evaluated as

(MyFunc2 1 2 3)


I know it's trivial to do this with macros and funcall, but I want to be able to write code exactly like this and it works at runtime. Are there any lisps or schemes that allow this out of the box? I'm explicitly interested in not having to do a song and dance, and just having this syntax at my fingertips as a default evaluation capability. Particularly in a compiled sexpr lang where this mechanism is blessed and can be heavily optimized by the compiler.

>>106177173
If Clojure had reader macros and the tooling wasn't so god-awful, I would be learning it seriously. But until then, Common Lisp will be my go-to Lisp.
>>106177223
I thought all Schemes/Lisp-1s can do that?

So, which one of you made a Lisp dedicated to GPU programming?

>>106177309
guess I'll finally try scheme then

>>106177223
this is literally default scheme behavior
screenshot is Clojure

>>106177309
what is terrible about Clojure's tooling? the Java CLI arguments?
CL's Quicklisp doesn't even have version numbers bro

>>106177223
this is called a combinator, combining functions.
you can have myfunc return a partially evaluated function, or a lambda, then the return will evaluate the next parameter.

>>106177223
what's the usecase for this behavior, ironically speaking?

>>106177796
my db migrations are just maps of published time to maps with up/down keys, referencing values that are functions

>>106177733
>the Java CLI arguments
This and lack of reader macros were definitely some of the pain points I had when I tried it out, I don't quite recall the others. But it felt like it just takes way too long to get a project going.
My ideal language is somewhere between Common Lisp and Clojure, honestly.

Are lisp 3d game engines actually viable? Which parts of it would be the hardest to implement? Something like networking?
I just found that there are some games/engines written fully in lisp like Jak and Daxter and Ratchet & Clank for the PS2 and I found this project on github https://github.com/Shirakumo/trial
I don't know much about lisp, but I've always seen it as a language with a lot of overhead but then I've found out that some dialects like SBCL (or GOAL/GOOL for the PS2 games) seem to be quite performant.

Howdy frens, I'm completely ignorant about Lisp. I don't know how to code, except for basic Python scripts. But I'd like to start learning a programming language, both for intellectual exercise and to work on projects.

I find Lisp very interesting, but I'm not sure where to start. I think starting with Scheme would be easier, but I also think Clojure is both more powerful and more widely used in real-world contexts, both professional and personal, and its interoperability with Java gives it more possibilities, I think.

Would you advise starting with Scheme and then maybe moving on to Clojure, or jumping straight into Clojure ?

>>106180763
Clojure has horrible documentation, especially for beginners. it's written in a manner that expect you to know what you are doing. I think Clojure is a great language, but if you are a noob, I would start with Elixir. Elixir's documentation is wonderful, and if you learn it, much of the skills will transfer over to Clojure.

>>106180036
>Are lisp 3d game engines actually viable?
>I just found that there are some games/engines written fully in lisp like Jak and Daxter and Ratchet & Clank for the PS2
>I don't know much about lisp, but I've always seen it as a language with a lot of overhead but then I've found out that some dialects like SBCL (or GOAL/GOOL for the PS2 games) seem to be quite performant.
Naughty Dog also used lisp for TLOU on PS3 so it seems viable

>>106180846
I'm looking into Elixir, and yeh they have the same philosophy and paradigm from what I can see. It looks interesting. As a total programming noob, I'll look into Elixir and try to learn it. Thank you. And then I'll look into Clojure

I just found out one of the main Guile devs has been working on a new garbage collection library
https://wingolog.org/archives/2025/05/15/guile-on-whippet-waypoint-goodbye-bdw-gc

>>106181011
Why is there a need for a new one?

>>106181163
Probably so you can choose between different collectors and not just BDW
https://github.com/wingo/whippet/blob/main/doc/collectors.md

>>106180763
sex with silence suzuka

>>106180846
I'm planning on learning Lisp by doing SICP (I'm used to Emacs already), is Scheme not a good first language? Should I learn Elixir before doing SICP?

>>106181771
no, Scheme is fine. SICP will walk you through it. it is Clojure in particular that is not easy to learn.

>>106181771
>is Scheme not a good first language?
It was the introductory language of choice for mit students since the 80s, you're good

How come it's so easy to break pdf-info? I love it because it's the best pdf viewer but I swear it's so fragile. Can't even set custom key bindings with :bind without it throwing a ton of symbol errors.

>>106181887
you mean pdf-view? and what are you trying to do exactly?

>>106181011
> new garbage collector
There’s literally thousands of new garbage collectors for java and other things, it’s a common master’s thesis topic and undergrad course assignment.

It’s the equivalent announcement that someone write a new “todo list application” in python/tk

>>106181887
>Can't even set custom key bindings with :bind without it throwing a ton of symbol errors.
Don't know if this helps but apparently :bind defers loading until you type one of the bindings, adding :demand loads it first

>>106182071
>>106181963
I already fixed it with (define-key). I just hate that pdf-tools is so fragile. Update poppler? Have to manually go into ~/.emacs.d/, delete everything under /pdf-tools<date>/ then nuke the directory. Then reload emacs. Otherwise, symbol errors. Try to configure it as stated in use-package part of the docs? symbol errors and pdfs no longer render. Look at it funny? Symbol errors.

It's the most troublesome part of my init for sure.

>>106182128
Yeah it must initialize itself in an unusual way compared to other packages (so symbols aren't exported yet), gj on fixing it tho

>>106182128
i have this problem when pdf tools just demand recompilation of epdinfo server because i've compiled emacs myself outside of msys2 (no wsl2 setup). and it doesn't recognize the server it compiles at all. and no, setting a var i no longer remember which's responsible for this doesn't work.
meanwhile nov.el, which also deals with a fancy archive with text and images, isn't nearly this finicky.
pdf is a nigger format.

>>106182071
>>106182128
Also I'm not sure if this is why but when installing/using pdf-tools with use-package you have to do :config then (pdf-tools-init) or whatever they call it. This makes doing things normally like with anything else through the expected syntax a huge pain in the ass.

I tried to do the exact same bindings with nov.el and it worked just fine as described in the docs using :bind (:map (something). All I wanted was to make hjkl work in modes where all I'm doing was reading documented the way it works pretty much everywhere else in my work flow. I don't use vim style bindings beyond hjkl for scrolling in documents I won't edit/type in. I know it's kind of retarded but it's how I run my web browser so I wanted it to carry over so I didn't have to reach for ctrl+n/p or the arrow keys. I don't care about the emacs style bindings when I am typing because I hate reaching for ESC and switching between modes too.

>>106182344
It's a big piece of shit. If there was any better pdf viewer I would use it instead. But they're all massive piles of shit (I've tried them all). At least emacs is tolerable and I can use it with org-mode.

To add insult to injury I'm on an OS that doesn't use a GNU userland. So I have to unfuck a bunch of other stuff to make it work correctly with BSD style userland. At least it isn't Windows or Mac those are much much worse. But at this point half my init.el is just setting things based on what platform I'm on.

I really wish I could extend mg instead. I love emacs but it has a lot of legacy cruft and stuff I'll never use inside. I often worry about it being a massive exploit waiting to happen into the rest of my system. But I've been married to it for so long now I don't see myself switching to anything else ever.

>>106181808
So Clojure is like the weird one in the family ?

>>106182399
>>106182344
Long shot; Any of you happen to know how to use pdf-tools in dark reader mode without it ruining the embedded images? Seems like the author is totally retarded/lazy because it shouldn't be messing with the images in the first place. I understand pdf is a bastard file format but this must be possible to do, right?

>>106182444
Clojure is technically adopted; kinda but not really part of the family.

>>106182467
I don't use pdf-tools but if you just want to render pdfs (without writing to storage like their github says) you could write an elisp wrapper around
mutool draw -w [width] -o /tmp/tmp.png [file.pdf] [page]
and track the current page in a buffer-local variable. Adding -I inverts the colors, or you can add tints/adjust page gamma with -G to your liking for dark mode

>>106182527
What makes Clojure so hard to learn ?
And adopted from where ?

>>106182467
a. there's now noverify install command. it wasn't there when i was last using pdf tools on windows.
b. no, i don't know. there's an option to use imagemagick for rendering, but i highly doubt it'll change anything; and pdf-view-midnight-invert. i can't exactly check myself its effect as i have no pds atm on my linux box.

>>106182444
no, Clojure is a proper Lisp-1 (like Scheme) that runs on the Java Virtual Machine (also in Javascript via Clojurescript, as well as a form of shell scripting with Babashka). it's just annoying to learn for most programmers because
(1) it's a Lisp (which confuses people used to Python or C style syntaxes),
(2) it's a functional language with immutable data structures (this will trip up programmers used to being able to mutate whatever, whenever---I remember it being annoying as fuck for my first week learning Elixir),
(3) it requires you to know Java as well (for example, your date/time handling will be done using Java's facilities for it),
(4) it proposes many abstractions over its data structures (for example, the sequence abstraction allows for iteration over any collection, the association abstraction allows for association/dissociation (applies to hash maps, sorted maps, and vectors, where your "key" is the index), and the abstraction that supports "conj"), making identification of what exactly you are doing difficult to grasp initially,
(5) and its documentation is written by people that have been programming for a very long time, and do not care to explain things in a way that is useful for noobs.
it's an excellent language. it has software transactional memory. it has the ability to "watch" values for when they change. you can toy around with metadata on objects. it is the most terse language I have come across, and allows you to trivially tear apart/assemble data structures with zero ceremony. it has the ability to have maps where keys are namespaced, which is something that I have never seen done before. it provides trivial access to the entire Java ecosystem, which is gargantuan.
there's just a lot to learn, and not much documentation to help you do so.

>>106182839
Thank you for taking the time to explain. It really does sound fascinating and powerful

>>106182736
>>106182839
Even as a somewhat experienced lisp programmer Clojure threw me for a loop for a while. There were things I wanted to do, like basic shit, and I couldn't find any documentation anywhere, no libraries, not even any forum posts. And then I figured out it's part of the Java standard library and everyone just expected you to automatically know that and just use the java interop. Also debugging was hell since it can drop down into the java debugger.

Basically you need to know Java to actually use it beyond a toy level, and so most of your time is actually going to be spent browsing java references and basically programming in java using lisp syntax.

But you also need to know lisp to understand all the abstract syntax and macros and shit they throw around. And there's not traditionally much overlap between the type of person who's enthusiastic about lisp and enterprise java.

>>106182736
>And adopted from where ?
The JVM, ie. Hell. It's hellspawn disguising as a Lisp.

>>106182071
I've had to use `:demand t` a few times. If you ever feel like the :config block isn't running, it's probably this.
https://github.com/jwiegley/use-package/issues/505

>>106182839
On the documentation front, I always thought:
- clojuredocs did a good job on documenting the standard library.
- https://clojuredocs.org/
- clojars did a good job of presenting docs for 3rd party libraries in a consistent way.
- https://clojars.org/ -- Every library has cljdocs link, so you can always find docs for a library in a consistent and sane way.

I think they did a great job as a community on the documentation front.

>>106183873
Agreed, Clojure is obviously a tool for the JVM world, expecting people to know Java is obvious and introducing Java would be redundant and extremely complex to maintain.
There are loads of Java books and references for people to use for this purpose. so, it's complete on its own domain, which is what matters.

>>106185508
You make no sense.

>>106180763
git gud (￣▽￣)b
https://tryclojure.org
https://clojure-doc.org/articles/tutorials/introduction/

>>106170659
good morning jvm sir
http://xahlee.info/java-a-day/java.html

This is Janet -> WASM doing web audio.
https://lisp.trane.studio/
Alt-Enter will start the demo.
# Hello
# Trane is a music playground
# It's written in Janet, a lisp-like language

# To execute the code below, press Alt+Enter. (+Enter on Mac)

(chain
(sample :hello-sample :url "samples/Cmin 7th 3.wav" :pitch :c3)
#(biquad :hello-filter :filter_type "lowpass")
:out
)

(live_loop :player
(play (pick 12 24 36) :hello-sample :dur 64)
#(target :hello-filter :frequency (rand 50 10000) 10)
(sleep 6)
)
# All those samples playing at once might cause some clipping. Try to adjust the level with the gain knob on the right.
# try uncommenting both the lines above.

# Have a look at the about page for more info: https://lisp.trane.studio/about.html

How many of you would be interested in a semi-regular Lisp meetup event (not organised through 4chan)? Please include your country.

>>106189012
Does Janet implement a condition system or OOP similar to common lisp?

>>106189133
I literally do not interact with other humans

>>106106181
https://github.com/mhayashi1120/Emacs-langtool
I already had the service running for LibreOffice.

>>106189260
>condition system
https://janet-lang.org/docs/fibers/error_handling.html
exception system built on top of fibers

>OOP
https://janet-lang.org/docs/object_oriented.html
Self-styled prototypes

>>106179193
>Common Lisp and Clojure
https://github.com/ruricolist/cloture

>>106191214
Very cute. Neat little toy language.

>>106177733
>CL's Quicklisp doesn't even have version numbers bro

Quicklisp "just works".

And, you are not forced to use Quicklisp, anyways. There are alternatives.

>>106180763
>but I also think Clojure is both more powerful

A belief, not a fact.

>and more widely used in real-world contexts, both professional and personal

It is CL which has a long history of success stories in professional contexts, for at least 40 years till today.

>and its interoperability with Java gives it more possibilities

You can also get very easy interoperability in Java using Common Lisp, there are at least three alternatives, the easiest one is to use ABCL, a Lisp implementation that runs on the JVM.

>>106181771
>is Scheme not a good first language?

It is a great first language.

>>106182444
>So Clojure is like the weird one in the family ?

Totally.

The worst part is that the JVM leaks through Clojure. That is, there is no abstraction or "wall" between, for example, JVM types and some basic Clojure types.

This means that it is tied to the JVM and your code will not necessarily work on Clojure implementations that don't target the JVM.

When you run Lisp under the JVM (using ABCL - Armed Bear Common Lisp), you can execute any Lisp code, which you could also compile to machine language using any of the other awesome implementations of CL like SBCL, CCL, LispWorks, and AllegroCL.

Or compile it to C using ECL.

>>106182839
>it's an excellent language. it has software transactional memory. it has the ability to "watch" values for when they change. you can toy around with metadata on objects. it is the most terse language I have come across, and allows you to trivially tear apart/assemble data structures with zero ceremony. it has the ability to have maps where keys are namespaced, which is something that I have never seen done before. it provides trivial access to the entire Java ecosystem

All the features listed here are also available in Common Lisp, just import the relevant libraries. Except for "watch values when they change", unless you mean "executing code when data accesors are called", which can trivially be done in Lisp too.

le new bread
>>106191893
>>106191893
>>106191893
>>106191893