#sbcl — Public Fediverse posts

i just wanna give an update on this.

i have looked into hunchentoot, ningle, caveman, and i want to thank everyone for their considered and, frankly, perfectly helpful suggestions and responses.

i now know exactly how to get started writing a common lisp web app.

except i'm not going to do that.

i am going to write a little common lisp script that sits some directory and i am going to record my thoughts into that.

nothing is ever wasted, and i have recorded all of your links.

#lisp #sbcl

Just wanna bounce this idea off someone/anyone--

I want to make a little thought journal program.

I want to have metadata tags and a nice way of searching information.

I realise that pen and paper, and that orgmode exists.

I want to write this in a Lisp, and maybe have it as a simple web page accessible by CGI.

Last I checked there existed frameworks like hunchentoot and caveman2.

Does this make sense? Would anyone recommend any resources or avenues of exploration?

#askfedi #lisp #sbcl

Hmm. I realized that this was just initial step and I need to read, learn and practice more to gain the eligibility of entering into some real life example. So, now I am going through the very famous book "Practical Common Lisp" by Peter Seibel.

Actually I selected this book only before I came to find the "Gentle Introduction..." book. But some topics and presentation went from top of my head! Haha.

Now I am confident enough to complete Seibel's book.

#sbcl

Just completed the book "Common Lisp: A Gentle Introduction to Symbolic Computation" 1990 editon!

Recently, 3 months ago I started learning the basic of Lisp (inspired by reading Free As in Freedom 2.0), installed Emacs, Slime, SBCL and continued learning whenever I got some time.

Although my choice of book/stuff may be obsolete however I feel the learning is quite meaningful. Hoping for implementing/experimenting it further to some practical recognizable task.

#sbcl #commonlisp #faif #lisp

How it's going on the #sbcl mailing list

Have a look at the acronym I made for #Lisp just for philosophical fun!

List Interactive Sapient Parenthesis

List Interpreted Smart Parenthesis

Btw, It's only two months I started learning / experimenting Common-Lisp (inspired by reading #faif )

Did you like it? Or share yours!

#sbcl

SBCL Fibers – Lightweight Cooperative Threads

https://atgreen.github.io/repl-yell/posts/sbcl-fibers/

#HackerNews #SBCL #Fibers #Lightweight #Cooperative #Threads #Technology #Innovation #Programming #Languages

SBCL: A Sanely-Bootstrappable Common Lisp (2008) [pdf]

https://research.gold.ac.uk/id/eprint/2336/1/sbcl.pdf

#HackerNews #SBCL #CommonLisp #Bootstrapping #LispProgramming #PDF

SBCL: A Sanely-Bootstrappable Common Lisp (2008) [pdf]

https://research.gold.ac.uk/id/eprint/2336/1/sbcl.pdf

#HackerNews #SBCL #CommonLisp #Bootstrapping #LispProgramming #PDF

SBCL: A Sanely-Bootstrappable Common Lisp (2008) [pdf]

https://research.gold.ac.uk/id/eprint/2336/1/sbcl.pdf

#HackerNews #SBCL #CommonLisp #Bootstrapping #LispProgramming #PDF

SBCL: A Sanely-Bootstrappable Common Lisp (2008) [pdf]

https://research.gold.ac.uk/id/eprint/2336/1/sbcl.pdf

#HackerNews #SBCL #CommonLisp #Bootstrapping #LispProgramming #PDF

SBCL: A Sanely-Bootstrappable Common Lisp (2008) [pdf]

https://research.gold.ac.uk/id/eprint/2336/1/sbcl.pdf

#HackerNews #SBCL #CommonLisp #Bootstrapping #LispProgramming #PDF

BTW, SBCLs "(sb-posix:stat-ctime (sb-posix:stat filename))" somehow returns wrong ctime — I got 1956 as a file creation year, while IRL it is equal to 2026 :drgn_flat_sob:

#CommonLisp #SBCL

I very sourly remember my own attempt at contributing to sbcl and getting shut down by Christophe, so I don't really care to get myself involved again -- I don't have the energy to be confrontational about it.

If course can be reversed on this, that would be very nice, but I neither have the "project clout" nor the mind to get into a bunch of fights and make myself even less popular to try and steer this ship into a more reasonable direction again.

For now, I guess a preliminary RIP to #sbcl.

So it looks like the #sbcl project is getting sloppified. Very, very saddening to see. It feels like something is slipping through my fingers, so I thought I should say something publicly.

Evidently Christophe is not interested in shutting this crap down, and when I read his email about it, I pretty much gave up on saying something myself. His stance is hopelessly naïve, and this is only being shown now.

As soon as you get these idiots a gap, they'll wedge it open, and it's already happened.

Steel Bank Common Lisp

https://www.sbcl.org/

#HackerNews #SteelBankCommonLisp #SBCL #Lisp #Programming #Language #OpenSource #Software #Development

I've been a #DoomEmacs user for some time, now, even having curated my own literate config out of their "static" files - along with all the extra stuff one adds to such a thing.

As one does, in the past I've also attempted to do my own #emacs config from scratch, usually falling into the "let's recreate doom!" hole, whether I wanted to or not (thus the reason I just went the route I did).

Over the past couple of months I've decided to - slowly - do the emacs bankruptcy declaration. Now, just to make things even more interesting I have decided against the use-package macro. Why? Because why not!

I've been using my scratch build for a month or so, haven't even opened my doom config up. It's been a great process, learning process, more understand of the process. It helps that I've been on a learn lisp quest for the past couple of years, too (#CommonLisp, #sbcl, #clojure, #elisp of course).

The large emacs distros are great an an excellent way to find curated packages. Doom is even a really nice framework. Sometimes you just want to do your own thing.

@seancorfield @oantolin

in #SBCL

CL-USER[4]: (= 0.2 1/5)
NIL
CL-USER[5]: (eq 0.2 1/5)
NIL
CL-USER[6]: (equal 0.2 1/5)
NIL
CL-USER[7]: (= 0.2 2/10)
NIL
CL-USER[8]: (= 1/5 2/10)
T
CL-USER[9]: (eq 1/5 2/10)
NIL
CL-USER[10]: (equal 1/5 2/10)
T
CL-USER[11]: (= 0.75 3/4)
T
CL-USER[12]: (eq 0.75 3/4)
NIL
CL-USER[13]: (equal 0.75 3/4)
NIL

The fact that 0.75 is seen as `=` to 3/4 but 0.2 is not `=` to 1/5 seems to me just buggy and inconsistent.

Should

(= 3/4 0.75)

return true (or 't)? You'd think so.
#SBCL 2.5.2 does think so.
MIT/GNU Scheme also thinks so.
#Interlisp Medley agrees.

I think this is correct behaviour.

#Clojure 1.12.1 disagrees; and I can understand why, since conversion between rationals and IEEE 754 floats is not necessarily sufficiently precise.

I'm just working on implementing this functionality on my own #Lisp, and wondering whether to do it be converting the arguments to floats or to rationals.

@glitzersachen By the way, #Lisp is not retro, it's metro!

(subst 'metro 'retro '(retro computing by LISP))

I recently started learning common Lisp (partially inspired by Free as in Freedom 2.0) and now feeling very enthusiastic to learn and experiment more and more!

#commonlisp #faif #philosophy #SBCL

I updated my "is #guile fast?" page with the new r7rs #benchmarks data and anchored Guile and #Chez in the benchmarksgame:

#Scheme benchmarks: https://www.draketo.de/software/guile-fast#other-schemes
Compared to other languages: https://www.draketo.de/software/guile-fast#other-languages

Chez is roughly factor 7 slower than C,
Guile roughly factor 18
(#Java 3.5, #SBCL 5, #Racket 12, #Ruby 60 and #Python 70)

I have to tell you that I'm falling in love with Common Lisp and SBCL. Awesome!

#commonlisp #lisp #sbcl

Heads up for those of you who like to build #benben from source: you may run into issues with SBCL 2.5.11 and SBCL 2.6.0. If you do, update your copies of named-readtables and possibly FXML, to the latest git checkouts. It builds fine after that. I think named-readtables had some breakage due to changing #sbcl internals that they were using.

I updated the AppImage build script since, which will exist for a bit longer, just until I finish my build tool. Then no more AppImages.

@ArneBab just because I was playing around a bit with the benchmarksgame and #SBCL yesterday (in particular the nbody benchmark): if the C implementation used for comparison is the fastest on the lists it's basically just handwritten SIMD assembly instructions with a little C wrapper, so not really a fair comparison when comparing with implementations/compilers that don't utilize SIMD instructions.

For "fun" I changed the SBCL implementation slightly to use SIMD instructions (using the sb-simd package which is part of SBCL), without doing all of the optimizations of the C version, and this gets the time down to around 2.5x that of the C code (on my laptop at least). I'm sure it could be even better with some more optimizations because it will be essentially the same machine code that GCC produces.

That's just a comment because the language doesn't make a program fast or slow in most cases, it's usually just about how smart the (human or non-human) compiler is.

Here is my simple and naiv approach to #web #authentication

https://code.metalisp.dev/marcuskammer/dev.metalisp.webauth

#commonlisp #lisp #sbcl

In light of recent events, I've decided that this is an excellent time to distract myself by actually learning CommonLisp instead of just setting up SBCL and slime and then getting distracted. So, I am working my way through Practical Common Lisp and doing some Huntress CTF challenges on the side.
:heart_cybre: :nerdcat:

#CommonLisp
#SBCL
#ctf
#HuntressCTF

@Regenaxer @borkdude @vindarel Thanks! Right, so my comparable in-REPL times for iterative factorial 1000 are

#PicoLisp: (bench (apply * (range 1 1000)))
0.000 sec
#Clojure: user=> (time (apply *' (range 1 1000)))
"Elapsed time: 2.428199 msecs"
#SBCL: CL-USER[1]: (time (apply #'* (alexandria:iota 1000 :step 1)))
Evaluation took:
0.000 seconds of real time
0.000015 seconds of total run time (0.000000 user, 0.000015 system)
100.00% CPU
45,990 processor cycles
0 bytes consed

#Lisp

#adventofcode #adventofcode2024 Day 1 #CommonLisp

#Symbolics #Genera, #SBCL and #LispWorks on the new Mac mini

https://toobnix.org/w/2Zhf4QM4uJvNDg6iXM71dw
Edit: Forgot link
13-something minute #video #howTo #clim hot-recompiling lisp interface design #commonLisp #lisp #emacs #sbcl .

Just kinda freewheeling about as I think of things, sticking new panels to it, shuffling them about. #interactiveProgramming

Feedback sought.

For #lafs -> https://lispy-gopher-show.itch.io/lisp-game-soft-cons

#sbcl #lisp #commonLisp #asdf #executable #gui #build #tutorial #clim #mcclim #example I wrote for @theruran a while ago.

You could basically submit this with literally any modification as a game for the #springlispgamejam2024 and it will be pretty similar to mine. I think it's a great approach to featureful interactive user interfaces for games.

https://lispy-gopher-show.itch.io/logos-lisp-legend/devlog/735998/sbcl-lisp-executable-clim-gui-game-build

https://itch.io/jam/spring-lisp-game-jam-2024

Tested with #SBCL, #ECL, #CCL and #ABCL.

Calling just `version` use the following defaults:

```
(version :version '(or version-file-line-0 system-version)
:pre-release '(or version-file-line-1 (when git-non-main-branch (and git-current-branch git-current-commit)))
:build-metadata '(git-current-branch git-current-commit current-time))
```

It tries to locate your system based on the package you're in, but you can specify directly by passing a `:root` argument.

Released an updated version (0.3.1) of sijo-doctest, a #doctest library for
#CommonLisp.

This includes some quality of life features, bugfixes and support for #SBCL, #ECL, #CCL and #ABCL.

https://github.com/simendsjo/sijo-doctest

I just found a very interesting #CommonLisp project which shows how to extend the LOOP macro: https://github.com/Gleefre/loop-continue

It was added to Ultralisp.org recently.

This code should work on #SBCL, #CLASP, #ALLEGRO, #ABCL and #ECL implementations.

TIL: every run of #SBCL has the same initial `*random-state*`, so sequences of pseudo-random numbers are not so random. The solution is super simple: `(setf *random-state* (make-random-state t))`.
It makes sense considering what a #Lisp image is... but it's still pretty surprising compared to other programming languages. (And doesn't happen in #ECL or #clisp 😅)

#CommonLisp

@freakazoid

Regarding the publications of #HenryGBaker on #Lisp and related topics — have you had a look around here?

🧷 https://www.plover.com/~mjd/misc/hbaker-archive/home.html

🌺

🦎 https://telegram.me/FamilyOfLisp
🦎 https://matrix.to/#/#family-of-lisp:magdeburg.jetzt

🏷️ #Scheme #CommonLisp #ELSConf #Clojure #DylanLang #CLHS #Lisp #FamilyOfLisp #Racket #AMOP #CLOS #CLtL2 #Clozure #SBCL #CLISP #Emacs #AutoLisp

On #Friendica and #Telegram:

›Call for Papers — 16th European #Lisp Symposium — #ELSConf —#Amsterdam — 2023-04-24/25‹

🔗 Friendica: https://libranet.de/display/0b6b25a8-1763-a88a-e526-72b275177682

🦎 Telegram: https://t.me/FamilyOfLisp/309

🌺

🏷️ #CommonLisp #Scheme #EmacsLisp #Clojure #Racket #ACL2 #AutoLisp #ISLISP #DylanLang #SKILL #Hy #Shen #Carp #Janet #Jank #uLisp #Picolisp #Gamelisp #TXR #FunctionalProgramming #AMOP #SICP #CLOS #PAIP #CLtL2 #AIMA #Emacs #VIM #LispWorks #AllegroCommonLisp #ACL #CLISP #SBCL #MetaObject #MetaObjectSystem