#ecl — Public Fediverse posts

https://www.walknews.com/1312230/ パレスをECL優勝へ導く決勝弾！　フランス代表FWマテタ「やり遂げた！最高の気分だ」 | サッカーキング #ECL #France #カンファレンスリーグ #サッカー #スポーツ #フットボール #フランス

https://www.walknews.com/1312230/ パレスをECL優勝へ導く決勝弾！　フランス代表FWマテタ「やり遂げた！最高の気分だ」 | サッカーキング #ECL #France #カンファレンスリーグ #サッカー #スポーツ #フットボール #フランス

https://www.walknews.com/1312230/ パレスをECL優勝へ導く決勝弾！　フランス代表FWマテタ「やり遂げた！最高の気分だ」 | サッカーキング #ECL #France #カンファレンスリーグ #サッカー #スポーツ #フットボール #フランス

A milestone! Fast GF dispatch compares to the baseline #ecl method (compare ECL BASE vs ECL FAST/4) - that's assuming a warm cache, and there is plenty of room for optimizations going forward.

#lisp

Screenshot from the live system -- dispatch profile for the generic function %present

#mcclim #ecl

@marcoxa

That's a good question. I've picked up work on Fast Generic Function Dispatch (as proposed by Robert Strandh) for #ecl. ECL is known to be slow with dispatching generic functions, so reducing the discriminating function to do only a few fixnum comparisons should speed things up greatly. And this is exactly this, the implementation of the algorithm (still wip, hence no benchmarks).

The pane on the right visualizes the dispatch expansion (both graphically, including bisecting ranges) and in a form of the code.

And what is working is the generic function that uses this discriminating function (with real ECL machinery, opposite to simulations I've done before I've shelved this work due to lack of time).

Dusting off some wip work for #ecl

#mcclim #lisp

Dusting off some wip work for #ecl

#mcclim #lisp

Dusting off some wip work for #ecl

#mcclim #lisp

Dusting off some wip work for #ecl

#mcclim #lisp

Dusting off some wip work for #ecl

#mcclim #lisp

@screwlisp @jackdaniel also available on yt: https://www.youtube.com/watch?v=c4pM9cjpeLc #clim #commonlisp #ecl #els #gui #mcclim #lisp

@screwlisp @jackdaniel also available on yt: https://www.youtube.com/watch?v=c4pM9cjpeLc #clim #commonlisp #ecl #els #gui #mcclim #lisp

@screwlisp @jackdaniel also available on yt: https://www.youtube.com/watch?v=c4pM9cjpeLc #clim #commonlisp #ecl #els #gui #mcclim #lisp

@screwlisp @jackdaniel also available on yt: https://www.youtube.com/watch?v=c4pM9cjpeLc #clim #commonlisp #ecl #els #gui #mcclim #lisp

@screwlisp @jackdaniel also available on yt: https://www.youtube.com/watch?v=c4pM9cjpeLc #clim #commonlisp #ecl #els #gui #mcclim #lisp

If you are interested in my talks about #McCLIM and #ECL at #elsconf this year and couldn't attend, they are available in the second day's recording of the conference:

https://www.twitch.tv/videos/2770056923

#lisp

@kf @reiddragon

POSIX api gives you dlopen[*], so you may load the shared object from inside a running process. #ecl for example uses this to load FASL files.

[*] other systems have similar interfaces.

⚽ #FediFC #Soccer #Football #ECL @[email protected] Both of the remaining matches in Rome are in a rain delay - Staodubtseva and Waltert have left the court so that could be it for the day - so I thought I'd catch up with this incident in your match ...

RE: https://bsky.app/profile/did:plc:4vziktoq7p6jd3i5l3wtmfab/post/3ml7hzb23ak2b

#ecl 26.5.5 bugfix release :

https://ecl.common-lisp.dev/posts/ECL-2655-release.html

Enjoy!

#lisp

Shit, I want to end my blogpost about my usage of Dired in Emacs, write another blogpost about cheatsheets for not-every-day-used Emacs keybindings, write simple AF program for plain-text accounting for myself (with a very limited subset of ledger syntax) in a Common Lisp with the help of #ecl and Natural Intelligence (since almost all software for plaintext accounting are proudly slopware nowadays and I can't rely on it and can't trust my accounting to such slopware), countinue drilling case for my NAS, write another blogpost about low-cost selfhosting on Intel Atoms, reverse-engineer PDBs for some default programs on my #Palm PDA (can't find time and muse for it in 4 years :drgn_sigh: ), setup Emacs on Android to use it for everything and avoid use of K9-Mail, ConnectBot and other slopware, and write another blogpost about using Palm in 2022^W2023^W2024^W2025^W2026 — but I didn't sleep well and need to have a good sleep now, FUCK! :drgn_hide:

:drgn_sleep: :drgn_sleep: :drgn_sleep: :drgn_sleep: :drgn_sleep: :drgn_sleep: :drgn_sleep:

Shit, I want to end my blogpost about my usage of Dired in Emacs, write another blogpost about cheatsheets for not-every-day-used Emacs keybindings, write simple AF program for plain-text accounting for myself (with a very limited subset of ledger syntax) in a Common Lisp with the help of #ecl and Natural Intelligence (since almost all software for plaintext accounting are proudly slopware nowadays and I can't rely on it and can't trust my accounting to such slopware), countinue drilling case for my NAS, write another blogpost about low-cost selfhosting on Intel Atoms, reverse-engineer PDBs for some default programs on my #Palm PDA (can't find time and muse for it in 4 years :drgn_sigh: ), setup Emacs on Android to use it for everything and avoid use of K9-Mail, ConnectBot and other slopware, and write another blogpost about using Palm in 2022^W2023^W2024^W2025^W2026 — but I didn't sleep well and need to have a good sleep now, FUCK! :drgn_hide:

:drgn_sleep: :drgn_sleep: :drgn_sleep: :drgn_sleep: :drgn_sleep: :drgn_sleep: :drgn_sleep:

Shit, I want to end my blogpost about my usage of Dired in Emacs, write another blogpost about cheatsheets for not-every-day-used Emacs keybindings, write simple AF program for plain-text accounting for myself (with a very limited subset of ledger syntax) in a Common Lisp with the help of #ecl and Natural Intelligence (since almost all software for plaintext accounting are proudly slopware nowadays and I can't rely on it and can't trust my accounting to such slopware), countinue drilling case for my NAS, write another blogpost about low-cost selfhosting on Intel Atoms, reverse-engineer PDBs for some default programs on my #Palm PDA (can't find time and muse for it in 4 years :drgn_sigh: ), setup Emacs on Android to use it for everything and avoid use of K9-Mail, ConnectBot and other slopware, and write another blogpost about using Palm in 2022^W2023^W2024^W2025^W2026 — but I didn't sleep well and need to have a good sleep now, FUCK! :drgn_hide:

:drgn_sleep: :drgn_sleep: :drgn_sleep: :drgn_sleep: :drgn_sleep: :drgn_sleep: :drgn_sleep:

Shit, I want to end my blogpost about my usage of Dired in Emacs, write another blogpost about cheatsheets for not-every-day-used Emacs keybindings, write simple AF program for plain-text accounting for myself (with a very limited subset of ledger syntax) in a Common Lisp with the help of #ecl and Natural Intelligence (since almost all software for plaintext accounting are proudly slopware nowadays and I can't rely on it and can't trust my accounting to such slopware), countinue drilling case for my NAS, write another blogpost about low-cost selfhosting on Intel Atoms, reverse-engineer PDBs for some default programs on my #Palm PDA (can't find time and muse for it in 4 years :drgn_sigh: ), setup Emacs on Android to use it for everything and avoid use of K9-Mail, ConnectBot and other slopware, and write another blogpost about using Palm in 2022^W2023^W2024^W2025^W2026 — but I didn't sleep well and need to have a good sleep now, FUCK! :drgn_hide:

:drgn_sleep: :drgn_sleep: :drgn_sleep: :drgn_sleep: :drgn_sleep: :drgn_sleep: :drgn_sleep:

Shit, I want to end my blogpost about my usage of Dired in Emacs, write another blogpost about cheatsheets for not-every-day-used Emacs keybindings, write simple AF program for plain-text accounting for myself (with a very limited subset of ledger syntax) in a Common Lisp with the help of #ecl and Natural Intelligence (since almost all software for plaintext accounting are proudly slopware nowadays and I can't rely on it and can't trust my accounting to such slopware), countinue drilling case for my NAS, write another blogpost about low-cost selfhosting on Intel Atoms, reverse-engineer PDBs for some default programs on my #Palm PDA (can't find time and muse for it in 4 years :drgn_sigh: ), setup Emacs on Android to use it for everything and avoid use of K9-Mail, ConnectBot and other slopware, and write another blogpost about using Palm in 2022^W2023^W2024^W2025^W2026 — but I didn't sleep well and need to have a good sleep now, FUCK! :drgn_hide:

:drgn_sleep: :drgn_sleep: :drgn_sleep: :drgn_sleep: :drgn_sleep: :drgn_sleep: :drgn_sleep:

So #ecl project also reached a conclusion what to do with LLM contributions:

https://gitlab.com/embeddable-common-lisp/ecl/-/work_items/826

Long story short: no LLM code in the codebase whatsoever until a legislative consensus is reached (and then we may reevaluate it).

#lisp

Need help from Lisp wizards — looks like I'm missing something simple and obvious (but not so obvious for beginner). I'm trying to build (with ECL) the simple program, which uses ql:quickload to load parse-number, then prints "Hello world". It builds without errors, but resulting binary could not be executed — it prints error message about unknown "ql:quickload" function.

QuickLisp was installed like described in the official documentation. It works in SBCL, it works in ECL REPL and it has the necessary lines in the ~/.eclrc:

;;; The following lines added by ql:add-to-init-file:
#-quicklisp
(let ((quicklisp-init (merge-pathnames "quicklisp/setup.lisp"
(user-homedir-pathname))))
(when (probe-file quicklisp-init)
(load quicklisp-init)))
(ql:quickload '(:slite) :silent t)

The program, itself, runs successfully if I just evaluate the next code in the REPL:

(ql:quickload '(:parse-number) :silent t)

(defpackage :test
(:use :cl))

(in-package :test)

(defun toplevel ()
(print "Hello world"))

(progn
(toplevel)
(ext:quit))

And it compiles:

ecl --eval '(progn (compile-file "test.lisp" :system-p t) (c:build-program "test" :lisp-files '"'"'("test.o")) (quit))'
;;; Loading #P"/home/drag0n/quicklisp/setup.lisp"
;;; Loading #P"/usr/local/lib/ecl-24.5.10/asdf.fas"
;;;
;;; Compiling test.lisp.
;;; OPTIMIZE levels: Safety=2, Space=0, Speed=3, Debug=0
;;;
;;; Finished compiling test.lisp.
;;;

But doesn't print "Hello world":

./test

Condition of type: UNDEFINED-FUNCTION
The function QUICKLISP-CLIENT::QUICKLOAD is undefined.
No restarts available.

Top level in: #<process TOP-LEVEL 0x8295a3f80>.
>

#AskFedi #CommonLisp #ECL #QuickLisp

Need help from Lisp wizards — looks like I'm missing something simple and obvious (but not so obvious for beginner). I'm trying to build (with ECL) the simple program, which uses ql:quickload to load parse-number, then prints "Hello world". It builds without errors, but resulting binary could not be executed — it prints error message about unknown "ql:quickload" function.

QuickLisp was installed like described in the official documentation. It works in SBCL, it works in ECL REPL and it has the necessary lines in the ~/.eclrc:

;;; The following lines added by ql:add-to-init-file:
#-quicklisp
(let ((quicklisp-init (merge-pathnames "quicklisp/setup.lisp"
(user-homedir-pathname))))
(when (probe-file quicklisp-init)
(load quicklisp-init)))
(ql:quickload '(:slite) :silent t)

The program, itself, runs successfully if I just evaluate the next code in the REPL:

(ql:quickload '(:parse-number) :silent t)

(defpackage :test
(:use :cl))

(in-package :test)

(defun toplevel ()
(print "Hello world"))

(progn
(toplevel)
(ext:quit))

And it compiles:

ecl --eval '(progn (compile-file "test.lisp" :system-p t) (c:build-program "test" :lisp-files '"'"'("test.o")) (quit))'
;;; Loading #P"/home/drag0n/quicklisp/setup.lisp"
;;; Loading #P"/usr/local/lib/ecl-24.5.10/asdf.fas"
;;;
;;; Compiling test.lisp.
;;; OPTIMIZE levels: Safety=2, Space=0, Speed=3, Debug=0
;;;
;;; Finished compiling test.lisp.
;;;

But doesn't print "Hello world":

./test

Condition of type: UNDEFINED-FUNCTION
The function QUICKLISP-CLIENT::QUICKLOAD is undefined.
No restarts available.

Top level in: #<process TOP-LEVEL 0x8295a3f80>.
>

#AskFedi #CommonLisp #ECL #QuickLisp

Need help from Lisp wizards — looks like I'm missing something simple and obvious (but not so obvious for beginner). I'm trying to build (with ECL) the simple program, which uses ql:quickload to load parse-number, then prints "Hello world". It builds without errors, but resulting binary could not be executed — it prints error message about unknown "ql:quickload" function.

QuickLisp was installed like described in the official documentation. It works in SBCL, it works in ECL REPL and it has the necessary lines in the ~/.eclrc:

;;; The following lines added by ql:add-to-init-file:
#-quicklisp
(let ((quicklisp-init (merge-pathnames "quicklisp/setup.lisp"
(user-homedir-pathname))))
(when (probe-file quicklisp-init)
(load quicklisp-init)))
(ql:quickload '(:slite) :silent t)

The program, itself, runs successfully if I just evaluate the next code in the REPL:

(ql:quickload '(:parse-number) :silent t)

(defpackage :test
(:use :cl))

(in-package :test)

(defun toplevel ()
(print "Hello world"))

(progn
(toplevel)
(ext:quit))

And it compiles:

ecl --eval '(progn (compile-file "test.lisp" :system-p t) (c:build-program "test" :lisp-files '"'"'("test.o")) (quit))'
;;; Loading #P"/home/drag0n/quicklisp/setup.lisp"
;;; Loading #P"/usr/local/lib/ecl-24.5.10/asdf.fas"
;;;
;;; Compiling test.lisp.
;;; OPTIMIZE levels: Safety=2, Space=0, Speed=3, Debug=0
;;;
;;; Finished compiling test.lisp.
;;;

But doesn't print "Hello world":

./test

Condition of type: UNDEFINED-FUNCTION
The function QUICKLISP-CLIENT::QUICKLOAD is undefined.
No restarts available.

Top level in: #<process TOP-LEVEL 0x8295a3f80>.
>

#AskFedi #CommonLisp #ECL #QuickLisp

Need help from Lisp wizards — looks like I'm missing something simple and obvious (but not so obvious for beginner). I'm trying to build (with ECL) the simple program, which uses ql:quickload to load parse-number, then prints "Hello world". It builds without errors, but resulting binary could not be executed — it prints error message about unknown "ql:quickload" function.

QuickLisp was installed like described in the official documentation. It works in SBCL, it works in ECL REPL and it has the necessary lines in the ~/.eclrc:

;;; The following lines added by ql:add-to-init-file:
#-quicklisp
(let ((quicklisp-init (merge-pathnames "quicklisp/setup.lisp"
(user-homedir-pathname))))
(when (probe-file quicklisp-init)
(load quicklisp-init)))
(ql:quickload '(:slite) :silent t)

The program, itself, runs successfully if I just evaluate the next code in the REPL:

(ql:quickload '(:parse-number) :silent t)

(defpackage :test
(:use :cl))

(in-package :test)

(defun toplevel ()
(print "Hello world"))

(progn
(toplevel)
(ext:quit))

And it compiles:

ecl --eval '(progn (compile-file "test.lisp" :system-p t) (c:build-program "test" :lisp-files '"'"'("test.o")) (quit))'
;;; Loading #P"/home/drag0n/quicklisp/setup.lisp"
;;; Loading #P"/usr/local/lib/ecl-24.5.10/asdf.fas"
;;;
;;; Compiling test.lisp.
;;; OPTIMIZE levels: Safety=2, Space=0, Speed=3, Debug=0
;;;
;;; Finished compiling test.lisp.
;;;

But doesn't print "Hello world":

./test

Condition of type: UNDEFINED-FUNCTION
The function QUICKLISP-CLIENT::QUICKLOAD is undefined.
No restarts available.

Top level in: #<process TOP-LEVEL 0x8295a3f80>.
>

#AskFedi #CommonLisp #ECL #QuickLisp

Need help from Lisp wizards — looks like I'm missing something simple and obvious (but not so obvious for beginner). I'm trying to build (with ECL) the simple program, which uses ql:quickload to load parse-number, then prints "Hello world". It builds without errors, but resulting binary could not be executed — it prints error message about unknown "ql:quickload" function.

QuickLisp was installed like described in the official documentation. It works in SBCL, it works in ECL REPL and it has the necessary lines in the ~/.eclrc:

;;; The following lines added by ql:add-to-init-file:
#-quicklisp
(let ((quicklisp-init (merge-pathnames "quicklisp/setup.lisp"
(user-homedir-pathname))))
(when (probe-file quicklisp-init)
(load quicklisp-init)))
(ql:quickload '(:slite) :silent t)

The program, itself, runs successfully if I just evaluate the next code in the REPL:

(ql:quickload '(:parse-number) :silent t)

(defpackage :test
(:use :cl))

(in-package :test)

(defun toplevel ()
(print "Hello world"))

(progn
(toplevel)
(ext:quit))

And it compiles:

ecl --eval '(progn (compile-file "test.lisp" :system-p t) (c:build-program "test" :lisp-files '"'"'("test.o")) (quit))'
;;; Loading #P"/home/drag0n/quicklisp/setup.lisp"
;;; Loading #P"/usr/local/lib/ecl-24.5.10/asdf.fas"
;;;
;;; Compiling test.lisp.
;;; OPTIMIZE levels: Safety=2, Space=0, Speed=3, Debug=0
;;;
;;; Finished compiling test.lisp.
;;;

But doesn't print "Hello world":

./test

Condition of type: UNDEFINED-FUNCTION
The function QUICKLISP-CLIENT::QUICKLOAD is undefined.
No restarts available.

Top level in: #<process TOP-LEVEL 0x8295a3f80>.
>

#AskFedi #CommonLisp #ECL #QuickLisp

Just use a #ProgrammingLanguage that isn’t popular (e.g. #Haskell or some #Lisp dialect) to write your code, but publish human-readable intermediate form of that code in the public code repositories (e.g. the C programming language). Share the actual source code privately with trusted contributors in non-public branches, and require GPG signatures on actual contributions.

You could argue that not sharing source code is against the GPL, but the GPL does allow you to share the code as a hard copy printed on paper and sent over snail mail. Or you can just wait until the person asking is an actual human that you can trust not to use the source code for LLM training.

LLMs are unable to learn unpopular programming languages because they don’t have a sufficient corpus of training data to learn how to code it, so if your receive a contribution in C, thank the contributor but inform them that they will have to rewrite the contribution in your Lisp dialect before you can accept it.

#Scheme dialects like #Gambit , #Chicken , and #Bigloo would work well for this. So would a #CommonLisp implementation that translates to C such as #ECL . Although keep in mind that the idea is to use a less popular language, so you may have to further obscure these languages a little bit, but not in a way that would be difficult for humans. For example, using a macro system, you could use df instead of define, rename types of things like string? to utf8str?, use generic functions with mulitple dispatch so append will work on strings, lists, vectors, and bytevectors. Small tweaks like this might throw-off an LLM asked to write source code in Lisp.

#tech #software #LLMs #LLM #FOSS #FLOSS #OpenSource #SchemeLang #R7RS

Just use a #ProgrammingLanguage that isn’t popular (e.g. #Haskell or some #Lisp dialect) to write your code, but publish human-readable intermediate form of that code in the public code repositories (e.g. the C programming language). Share the actual source code privately with trusted contributors in non-public branches, and require GPG signatures on actual contributions.

You could argue that not sharing source code is against the GPL, but the GPL does allow you to share the code as a hard copy printed on paper and sent over snail mail. Or you can just wait until the person asking is an actual human that you can trust not to use the source code for LLM training.

LLMs are unable to learn unpopular programming languages because they don’t have a sufficient corpus of training data to learn how to code it, so if your receive a contribution in C, thank the contributor but inform them that they will have to rewrite the contribution in your Lisp dialect before you can accept it.

#Scheme dialects like #Gambit , #Chicken , and #Bigloo would work well for this. So would a #CommonLisp implementation that translates to C such as #ECL . Although keep in mind that the idea is to use a less popular language, so you may have to further obscure these languages a little bit, but not in a way that would be difficult for humans. For example, using a macro system, you could use df instead of define, rename types of things like string? to utf8str?, use generic functions with mulitple dispatch so append will work on strings, lists, vectors, and bytevectors. Small tweaks like this might throw-off an LLM asked to write source code in Lisp.

#tech #software #LLMs #LLM #FOSS #FLOSS #OpenSource #SchemeLang #R7RS

Just use a #ProgrammingLanguage that isn’t popular (e.g. #Haskell or some #Lisp dialect) to write your code, but publish human-readable intermediate form of that code in the public code repositories (e.g. the C programming language). Share the actual source code privately with trusted contributors in non-public branches, and require GPG signatures on actual contributions.

You could argue that not sharing source code is against the GPL, but the GPL does allow you to share the code as a hard copy printed on paper and sent over snail mail. Or you can just wait until the person asking is an actual human that you can trust not to use the source code for LLM training.

LLMs are unable to learn unpopular programming languages because they don’t have a sufficient corpus of training data to learn how to code it, so if your receive a contribution in C, thank the contributor but inform them that they will have to rewrite the contribution in your Lisp dialect before you can accept it.

#Scheme dialects like #Gambit , #Chicken , and #Bigloo would work well for this. So would a #CommonLisp implementation that translates to C such as #ECL . Although keep in mind that the idea is to use a less popular language, so you may have to further obscure these languages a little bit, but not in a way that would be difficult for humans. For example, using a macro system, you could use df instead of define, rename types of things like string? to utf8str?, use generic functions with mulitple dispatch so append will work on strings, lists, vectors, and bytevectors. Small tweaks like this might throw-off an LLM asked to write source code in Lisp.

#tech #software #LLMs #LLM #FOSS #FLOSS #OpenSource #SchemeLang #R7RS

Just use a #ProgrammingLanguage that isn’t popular (e.g. #Haskell or some #Lisp dialect) to write your code, but publish human-readable intermediate form of that code in the public code repositories (e.g. the C programming language). Share the actual source code privately with trusted contributors in non-public branches, and require GPG signatures on actual contributions.

You could argue that not sharing source code is against the GPL, but the GPL does allow you to share the code as a hard copy printed on paper and sent over snail mail. Or you can just wait until the person asking is an actual human that you can trust not to use the source code for LLM training.

LLMs are unable to learn unpopular programming languages because they don’t have a sufficient corpus of training data to learn how to code it, so if your receive a contribution in C, thank the contributor but inform them that they will have to rewrite the contribution in your Lisp dialect before you can accept it.

#Scheme dialects like #Gambit , #Chicken , and #Bigloo would work well for this. So would a #CommonLisp implementation that translates to C such as #ECL . Although keep in mind that the idea is to use a less popular language, so you may have to further obscure these languages a little bit, but not in a way that would be difficult for humans. For example, using a macro system, you could use df instead of define, rename types of things like string? to utf8str?, use generic functions with mulitple dispatch so append will work on strings, lists, vectors, and bytevectors. Small tweaks like this might throw-off an LLM asked to write source code in Lisp.

#tech #software #LLMs #LLM #FOSS #FLOSS #OpenSource #SchemeLang #R7RS

It’s prerelease time! And I managed to go 3:0 for the first time 😁

#magicthegathering #mtg #lorwyneclipsed #ecl #prerelease

I was 100% sure that I order my play booster box of Lorwyn Eclipsed in English but I now have a German box sitting on my table...

I need that box for a home event on Saturday (1 day after release). I'm a bit annoyed 😩

It's not that I don't speak German (it's my native language) but I like the English cards more.

#magicthegathering #ecl #lorwyneclipsed #mtg #boosterbox

In unserer neuen Folge nehmen wir Euch mit in die Geschichte des neuen Sets "Lorwyns Finsternis". Was das Gleichgewicht zwischen Lorwyn und Shadowmoor stört und wer dahinter steckt – das erfahrt in unserem Story-Überblick: https://tastymtg.de/tsty076-die-story-von-lorwyns-finsternis/
#mtg #ecl #mtgecl #wizardsmagic #lorwyn #lorwynsfinsternis

@screwlisp

Thank you.
I have the nagging feeling that it isn't absolutely, positively portable to use `unsigned long long' and `uint64_t' interchangeably, now and forever, but I Am Not A Language Lawyer (IANALL™) and that is off off topic anyway.

I am sure that the implementation at hand that takes care of such embedding of C or C++ fragments is completely sane.
I replied from the user's perspective, but aesthetics is in the eyes of the programmer, of course.

#CommonLisp
#ECL
#EmbeddedC
#NumericTypeNamesInC

@ramin_hal9001

ECL Runs Maxima in a Browser

https://mailman3.common-lisp.net/hyperkitty/list/[email protected]/thread/T64S5EMVV6WHDPKWZ3AQHEPO3EQE2K5M/

#HackerNews #ECL #Maxima #Browser #Lisp #ECLDevel

Wenn wir viel zu wenige Tickets kriegen, dann bucht man eben Zimmer im Hotel beim Stadion.

Györ - #SKRapid
#ecl Playoff

Ostblock Vibes

U.S. Wide-Moat Stocks On Sale - The March 2023 Heat Map

https://seekingalpha.com/article/4585519-us-wide-moat-stocks-on-sale-the-march-2023-heat-map?source=feed

#TheFALCONMethod #USB.PA #USB.PH #USB.PP #USB.PQ #USB.PR #USB.PS #WFC.PA #WFC.PC #WFC.PD #WFC.PL #WFC.PQ #WFC.PR #WFC.PY #WFC.PZ #BRK.A #BRK.B #CMCSA #GOOGL #WFCNP #ADBE #AMZN #BIIB #CSCO #ETSY #GILD #GOOG #GWRE #INTU #LRCX #META #MSFT #VEEV #VRSN #WDAY #WLYB #BLK #CME #CMP #CRM #DIS #DPZ #ECL #EFX #EMR #HON #ICE #IFF #JNJ #MAS

U.S. Wide-Moat Stocks On Sale - The March 2023 Heat Map

https://seekingalpha.com/article/4585519-us-wide-moat-stocks-on-sale-the-march-2023-heat-map?source=feed

#TheFALCONMethod #USB.PA #USB.PH #USB.PP #USB.PQ #USB.PR #USB.PS #WFC.PA #WFC.PC #WFC.PD #WFC.PL #WFC.PQ #WFC.PR #WFC.PY #WFC.PZ #BRK.A #BRK.B #CMCSA #GOOGL #WFCNP #ADBE #AMZN #BIIB #CSCO #ETSY #GILD #GOOG #GWRE #INTU #LRCX #META #MSFT #VEEV #VRSN #WDAY #WLYB #BLK #CME #CMP #CRM #DIS #DPZ #ECL #EFX #EMR #HON #ICE #IFF #JNJ #MAS

U.S. Wide-Moat Stocks On Sale - The March 2023 Heat Map

https://seekingalpha.com/article/4585519-us-wide-moat-stocks-on-sale-the-march-2023-heat-map?source=feed

#TheFALCONMethod #USB.PA #USB.PH #USB.PP #USB.PQ #USB.PR #USB.PS #WFC.PA #WFC.PC #WFC.PD #WFC.PL #WFC.PQ #WFC.PR #WFC.PY #WFC.PZ #BRK.A #BRK.B #CMCSA #GOOGL #WFCNP #ADBE #AMZN #BIIB #CSCO #ETSY #GILD #GOOG #GWRE #INTU #LRCX #META #MSFT #VEEV #VRSN #WDAY #WLYB #BLK #CME #CMP #CRM #DIS #DPZ #ECL #EFX #EMR #HON #ICE #IFF #JNJ #MAS

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.

Forerunner Ventures’ Kirsten Green demystifies the COVID-19 consumer - “In general, the consumer has proven to be more resilient than I would have thought,” said Kirsten G... more: http://feedproxy.google.com/~r/Techcrunch/~3/us4JILukCNI/ #growthandmonetization #forerunnerventures #directtoconsumer #extracrunchlive #venturecapital #kirstengreen #extracrunch #coronavirus #ecommerce #startups #covid-19 #glossier #events #ecl #d2c #dtc #tc

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

Craft your pitch deck around ‘that one thing that can really hook an investor’ - Michelle Davey’s pitch to Jordan Nof of Tusk Ventures about Wheel, a startup focus... - http://feedproxy.google.com/~r/Techcrunch/~3/kIb7sfQfpsk/ #extracrunchlive #michelledavey #echealthtech #tuskventures #extracrunch #jordannof #startups #echowto #events #health #wheel #ecl #tc