r/Common_Lisp

Hi, judging from some examples on the McClim webpage, it should be possible to draw things with anti-aliasing in a McClim application frame. There is a "X rendering extension" that is maybe just doing that. But I can't find a documentation or code example.

Is there someone familiar with the subject that could point me in the right direction ?

Maybe it is easier this way. I have this minimalist example that draws a circle. How can I draw the same circle with anti-aliasing ?

(define-application-frame circle-app ()
  ()
  (:panes
   (canvas :application
           :background +white+
           :display-time :command-loop
           :display-function 'display-my-circle
           :width 400 :height 400))
  (:layouts (default canvas)))

(defun display-my-circle (frame pane)
  (declare (ignore frame))
  (draw-circle* pane 200 200 100
                :ink +red+
                :filled nil
                :line-thickness 2))

(define-circle-app-command (com-quit :name t :menu t :keystroke (#\q)) ()
  (frame-exit *application-frame*))

(defun run-circle-app ()
  (run-frame-top-level (make-application-frame 'circle-app)))

Maybe related: I am also interested in pointers that show how to draw text using TTF fonts (zpb-ttf).

BTW, i am using SBCL on Linux (archlinux).

Wrote this tool to documenting my other Lisp projects. (tclish...)

I'm seeing this on Linux ARM64 and a current macOS with SBCL.

% sbcl
This is SBCL 2.6.2, an implementation of ANSI Common Lisp.
More information about SBCL is available at <http://www.sbcl.org/>.

SBCL is free software, provided as is, with absolutely no warranty.
It is mostly in the public domain; some portions are provided under
BSD-style licenses.  See the CREDITS and COPYING files in the
distribution for more information.
* (let ((*print-readably* t)) (write (symbol-name :symbolfoo) :stream *standard-output*))
#A((9) BASE-CHAR . "SYMBOLFOO")
"SYMBOLFOO"
* 

#A((9) BASE-CHAR . "SYMBOLFOO") looks strange. Why doesn't it print a keyword symbol?

I just put the docs on a small Clojure framework I've been hacking on, **stube**. It's a personal research project, not a product — somewhere I'm working out an idea about web apps that has pulled at me for twenty years.

Short version: components are plain maps of pure functions, the conversation is a value, handlers return effects, and one component can *call* another and read its *answer* like a return value (Seaside / UCW lineage). The wire is Datastar (SSE + morph by id); the implementation is a small effect kernel over plain Clojure data.

(s/defcomponent :demo/save-or-cancel
  :render (fn [self]
            [:div (s/root-attrs self)
             [:button (s/on self :click :as :save)   "Save"]
             [:button (s/on self :click :as :cancel) "Cancel"]])
  :handle (fn [self {:keys [event]}]
            (case event
              :save   [(s/call :ui/confirm {:question "Save changes?"} :on-confirmed)]
              :cancel [(s/answer :cancelled)]))
  :on-confirmed
  (fn [self yes?]
    [(s/answer (if yes? :saved :cancelled))]))

Built heavily with LLM assistants — wouldn't have shipped it this fast otherwise — but the shape, the namespace layout, and the choice of what to include and what to leave out is mine and reflects how I think about systems.

If you're a re-frame person and the conversation map feels familiar: yes, deliberately. The conversation here is closer in spirit to a re-frame app-db than to a Smalltalk image.

- Repo: https://github.com/zekzekus/stube

- Rationale (why this exists at all): https://github.com/zekzekus/stube/blob/master/docs/rationale.md

- Tutorial: https://github.com/zekzekus/stube/blob/master/docs/tutorial.md

Happy for feedback, war stories, "have you seen X" pointers.

I am looking for a recent post (2-3 months back) that very nicely broke down a CL installation into a hierarchy of specifications. It went something like

• Hardware/CPU
• OS, Shell, environment variables
• Lisp implementation
• Lisp package manager
• Editor & API

I asked CoPilot to help me find it, and it was not able to. It generated its guess on the hierarchy which seemed reasonable. I will not post it because I don't want to pollute Reddit.

I will be very grateful if someone points me to the post (& the author).

Thank you very much,

Mirko

Greetings!

I know one can use COMPILE to compile a function for later use in the current image, and COMPILE-FILE to read a file, compile the code in it, and save a loadable version of the code (FASL).

I'm working on a system that generates Lisp forms programmatically, however it does so outside of the usual read-compile-load cycle. You can imagine a DSL with its own syntax, that is mapped to Lisp forms.

Now, at some point I would like to compile the generated code "as if" it was normal Lisp code, and save it into a FASL. I know I can PRINT it to a temporary file and call COMPILE-FILE on that, however, it feels like a suboptimal solution.

Perhaps there's no portable way of doing that, but I would be happy with implementation-specific code, and the temporary file hack as a fallback.

cl-codegraph: https://sr.ht/~hajovonta/cl-codegraph/

> Given a package loaded in the SBCL image, builds and maintains a graph of its symbols, class hierarchies, method specializations, call relationships, and metadata — all without parsing source code. Includes a live Emacs integration that shows code intelligence as you navigate.

Screencast: https://drive.proton.me/urls/JE5EQ6KNMR#tN7CcgN96YL7

Seen on: https://mastodon.online/@hajovonta/116501259663689389

I just got a copy of LISP Metaprogramming: A Hands-On Guide to Macros, Syntax Transformation, and DSLs by James C. Shepherd. It's a softcover book with 179 pages and cover art of a train made of a colorful collection of circuit board wires.

For the life of me, I can't find where the endnotes are. They aren't footnotes, nor at the end of the chapters, nor end of the book (either before or after the appendixes).

Anyone have a copy of the book that has the notes?