I'm about to start a personal project and I'd love to use XTDB, but I'm not quite sure I should use it instead of a SQL db like eg. Postgres. The reason why I'm not sure is that I don't know if I'll be able to write complex queries in Datalog that I'd otherwise with SQL. I know this is kind of an open-ended question, but is it possible to write complex queries with joins and aggregations in Datalog? Or perhaps a better question is, what are the things that Datalog cannot do that SQL can?

Seems as if one wants to learn lisp, one has to learn emacs first. That said, I am looking for resources for the absolute beginner to learn emacs, looking for something along the lines of Common lisp A gentle introduction to symbolic computation., but for emacs. Something that assumes you know nothing, starts at the absolute beginningwith lots of exercise and answer to those exercise. Any help will be appreciated. Thanks

Seems as if one wants to learn lisp, one has to learn emacs first. That said, I am looking for resources for the absolute beginner to learn emacs, looking for something along the lines of Common lisp A gentle introduction to symbolic computation., but for emacs. Something that assumes you know nothing, starts at the absolute beginningwith lots of exercise and answer to those exercise. Any help will be appreciated. Thanks

1. A program, written in CL, is a huge mutable state. It seems that one can redefine nearly every symbol and there is no immutable data structures. But, as far as I understand, one can modify the language by using macros. So, is it possible to create a macro, which protects data structures from mutation or forbids the usage of mutable operators. For example:

(defmacro with-immutable-scope (&body body) ...) (with-immutable-scope (let ((q (list 1))) (setf q 1))) => compilation error

2. A public interface of a CL package consists of symbols. How can I specify and find out, what a symbol from a different package refers to? Should I do the following:

To specify what I export:

(defpackage :foo (:use :cl) (:export ;; macros :with-immutable-scope ;; functions :fetch-data ...

To find out what I import:

(describe fetch-data)

3. When I create a variable binding with \``let\ and then modify the variable, this modification doesn't propagate through the binding. Example:

(defstruct point x) (let* ((point-obj (make-point :x 1)) (x-ref (point-x point-obj))) (setf x-ref 2) (point-x point-obj)) ;; => returns 1 because setf changed the reference to point-x but not the point-x itself

Does it mean that the let-bindings are effectively read-only pointers?

4. How can I remove a method, which was previously associated with a generic function? For example:

(defgeneric foo (x)) (defmethod foo ((x list)) "list") (defmethod foo ((x integer)) "integer") (fmakeunbound-for-clos-methods '(foo (x integer))) ;; <- need help here (foo '()) ;; => "list" (foo 1) ;; => NO-APPLICABLE-METHOD-ERROR

Does \``fmakeunbound-for-clos-methods\ exist ?

Hi guys, I was wondering if there were some concepts in category theory that'd be practical/pragmatic to be used in Clojure. Ik that category theory can sometimes get too abstract such that it will be confusing or straight up not optimal in Clojure. But still i thought there might be some concepts that were practical and might fit well into Clojure. So if anyone here have good experience with category theory or ml have you discovered some design patterns/concepts that are a good fit for Clojure

Please see readme-sailfish.

This uses the Qt5.15 meta packages, and needs an app called qt-runner for launching the apps in a separate wayland client, providing also the SailfishOS keyboard.

So, it's not 'native' in the look & feel sense (no Sailfish specific QML items available), but allows basically any Qt5.15 compiled app to run on SailfishOS, which is great news!

Obligatory screenshot: cl-repl-sailfish

We've just released a first-class Clojure API for Rama. Rama is a new programming platform we released in August that enables end-to-end scalable backends to be built in their entirety in 100x less code than otherwise. It's a "programmable datastore on steroids" where you mold your datastore to fit your application rather than the other way around. The introductory blog post to the Clojure API culminates in building a highly scalable auction application with timed listings, bids, and notifications in only 100 LOC.

A counter in racket-scheme:

``` #lang typed/racket

(define my-counter! (let ([t 0]) (lambda () (set! t (+ 1 t)) t);lambda );let );define (print (my-counter!)) (print (my-counter!)) ```

A counter in sbcl-lisp:

``` load "~/quicklisp/setup.lisp")

(declaim (optimize (speed 3) (safety 3)))

(let ((c 0)) (defun my-counter! () (lambda () (setf c (+ 1 c)) c); lambda ) ;defun ) ;let

(defun main () (print (funcall (my-counter!))) (print (funcall (my-counter!))) )

(sb-ext:save-lisp-and-die "test.exe" :toplevel #'main :executable t)

```

Could someone elaborate why i need "funcall" in lisp and not in scheme ? And why the different placing of let ?

I had the honor and the pleasure to demo an AI-augmented user interface during a recent meetup. Since the demo is online and publicly available, I am inviting anyone who might be interested to try it out. The audience for this demo is, I'd venture to say, front-end developers, designers, and photographers.

As an amateur photographer myself, I frequently post photos on social media. There are lots of forums out there, and it becomes quickly apparent that different communities have different rules as to how a post should look like. For example, subreddits often require that the type of lens be mentioned in the title. Posts need to be tagged differently if the image is straight from camera (SOOC) or post-processed. Crafting a post isn't terribly difficult, but some details can be gleaned from the embedded EXIF data in a more reliable way than from the shooter's memory. Also, I wanted to see how helpful image recognition could prove in this context.

So I set out to build a user interface that only requires one action from the user: uploading a photo. All the rest is done via asynchronous requests that integrate with the UI. EXIF data is extracted on the server, AI-generated tags come from a third-party image recognition service. The challenge is to display the information seamlessly, as it comes in from the various sources, without startling the user.

Here is the demo. Special thanks to Scicloj for hosting me with grace and kindness. If you're not familiar with that organization yet, check it out.

Have you tried uploading a photo from your own devices/cameras? What are your thoughts? Is there something you would have done/seen differently? Please let me know.

​

Hello everyone!

I apologize for the consecutive posts and any disturbance caused. I've written an article about why I'm passionate about Lisp development. If you're interested, please take a look. Thank you Rediscovering the Joy of Math: A Journey with Lisp | by Kenichi Sasagawa | Oct, 2023 | Medium

Hello everyone.

I wrote an article reminiscing about my childhood when I used to build radios and amplifiers. Please take a look if you're interested. Rediscovering the Joy of Hardware Hacking with Raspberry Pi and Lisp | by Kenichi Sasagawa | Oct, 2023 | Medium

I just added a short chapter on using the Anthropic completion API to my Common Lisp book. Here is a link to the start of the new material https://leanpub.com/lovinglisp/read#leanpub-auto-using-the-anthropic-claude-llm-completion-api

If you have been using OpenAI’s APIs from Common Lisp and want to try using Anthropic, this new material should save you a few minutes work getting setup.

If you are interested in linear-algebra and numerical computing in general or use the libraries in lisp-stat, a discussion on the future direction of the libraries has been started within the linear-algebra library. Feel free to comment and suggest.

https://github.com/Lisp-Stat/linear-algebra/discussions/5

What are the strengths , weaknesses. How to compare sbcl with clojure

Gerbil v0.18-rc1, the first release candidate for Gerbil v0.18 is ready!

• Release announcement: https://github.com/mighty-gerbils/gerbil/discussions/983
• Release tag and changelog: https://github.com/mighty-gerbils/gerbil/releases/tag/v0.18-rc1

Happy Hacking!

Happy to share the first release of ClojureScriptStorm, a dev compiler that tries to bring the same experience as ClojureStorm does for Clojure (automatic instrumentation) to ClojureScript.

This dev compilers are created to improve the experience of using FlowStorm but are not coupled to it, so other tooling can be built on top of them.

It is a fork of the official ClojureScript compiler, with a patch on top to enhance it with automatic instrumentation. It currently supports cljs.main and shadow-cljs.

Here is the new user guide entry .

If you want to try it, be aware that it requires shadow-cljs >= 2.25.4

The current coordinates are com.github.jpmonettas/clojurescript {:mvn/version "1.11.60-2"} which applies the patch over 1.11.60 and the latest FlowStorm is com.github.jpmonettas/flow-storm-dbg {:mvn/version "3.7.5"}

The project is currently hosted here

If you want to use it for your own tooling, take a look at the current tests :

• setup
• functions tests, bodies tests, types tests

Hi folks,

is anyone of you teaching their kids Clojure as I do? A couple of years ago I decided to home school my kids because I wanted to teach them programming in a lispy language in conjunction with mathematics as early as possible (7+ years of age, after finishing their first year in the elementary school). So, I made a private course for my kids and created a series of hand-drawn comic textbooks full of maths combined with all the lispy goodness.

I thought it would be a nice experiment as I was not sure if the concept of LFL—Lisp as First (programming) Language can really work. You know, there are these theories that before fully appreciating a lispy language, you have to experience the horrors of ‘garbage languages’ first… Also, Clojure is not exactly a pedagogical language, is it? At some point, I was thinking about creating my own Lisp dialect for the purpose. But I wanted something to support functional approach, lazy evaluation, and having a collection of nice data structures, so why bother making another language if Clojure suits my needs (almost) perfectly (there are some features that I do not like that much but I guess nothing is perfect) and, yes, my spare time was also a limiting factor.

I have been doing this for five years now and it has been a fascinating journey. I really like how it works together with teaching maths and boosts abstract thinking. Some of my friends showed interest in what I was doing (apparently, they wanted the same fine education for their kids), so I decided to make an official series of books, the first was just published and can be purchased on Lulu (the plan is to make 3 volumes per year). In addition to that, I will be posting ‘my pedagogical notes’ (and later problem-oriented web-based programming environments) on Patreon for those who would like to follow this path. This project takes a substantial amount of my time, so any support from you fellow lispers is highly appreciated!

Project home with book preview: https://prog-mat.com

Any thoughts?