Common Lisp Puns

Hi.

I was trying to learn some common lisp and searched for the tools for editing, debugging and formatting lisp code. From what I read Emacs with SLIME seems to be the most popular. Wherever I looked, converts to lisp (even beginners) were being recommended to learn Emacs so they could learn lisp. The other alternatives like Allegro and Lispworks seem crippled in some way.

I think the popularity of Emacs for lisp development is a major drawback in getting people interested in this language. When someone wants to learn a language, they should ideally focus on the language alone, not struggle with the editor along with it. I was able to get it working because I have fooled around with Emacs on and off (but not every newbie has)

Moreover, the current generation of programmers all grew up using MS Word (Ctrl-C, Ctrl-V) shortcuts. There's no reason for them to learn Emacs because there's a plethora of featureful editors even on Linux.

So, IMO there should be a freeware/open source alternative to the Emacs-SLIME toolkit to make the language more approachable to beginners. It should also be easy to use

I would love to hear your thoughts.

Edit: Thank you for all your responses! I had a look at all the tools for Common Lisp suggested in the comments and they are as follows:

1. Emacs+SLIME (Most popular)
2. Atom+SLIMA
3. VSCode+ALIVE
4. Proprietary (LispWorks and Allegro)

While I was able to get Emacs+SLIME working on my laptop, I researched a bit more on the different lisp dialects. Turns our CL and Scheme are the most popular ones. Some posts on Stackoverflow and Quora state that Common Lisp is the best lisp for writing full-fledged software.

However, my online research indicates that the support for developing GUI apps in Common Lisp is very scarce (definitely not crossplatform). For instance, the most popular toolkit is MCCLIM whiich comes with QuickLisp repository but getting it to work on Windows is not worth the effort. Ideally, This should not be a problem, as LISP is an interpreted language which should work on any platform that comes with a lisp interpreter. Another toolkit suggested by many is using TCL/TK to write the GUI and writing the logic in CL. But, whats the point of using another language just for the GUI? Why not write completely in TCL/TK? Also, all these editors like Emacs, Atom or VSCode DO NOT come with a GUI development tools. The only real IDE for common lisp with inbuilt GUI development is LispWorks which requires you t

I am trying to install Common Lisp on Windows 10, from SourceForge. The tutorials i watch seem to get an actual setup downloaded, but i get this folder with a bunch on unexecutable files instead. I am completely new to LISP, so feel free to explain things to me in babysteps.

What CL stuff from 2021 did you like? What improvements in implementations, libraries, tools, applications, articles, ... would you want to mention?

Hi,

I have dabbled with some libraries (including Caveman2) but they didn't work well for me. If you are to build a Restful API service, which libraries would you think reliable and choose? Maybe just Hunchentoot?

Thanks.

As the title says what books would you recommend?

From 2018 through sometime 2020 there seems to have existed two projects surrounding 3D modelling in CL, Tovero as libfive bindings and Clive as some sort of scene graph with a 3D GUI as per this description from a random git commit I found:
>Tovero is a binding of Libfive to Common Lisp, including a standalone REPL-based viewer. Tovero can be integrated with Clive, a Common Lisp scene graph and 3D GUI, to build more complex modeling applications.

Both of these projects seem to have been hosted on common-lisp.net per these reddit submissions:

• https://www.reddit.com/r/Common_Lisp/comments/9ho5oz/clive_is_a_common_lisp_binding_to_open_inventor/
• https://www.reddit.com/r/Common_Lisp/comments/ezruuc/tovero_a_3d_modeling_system_for_common_lisp/
• https://www.reddit.com/r/Common_Lisp/comments/9ho5jg/tovero_is_a_3d_modeling_system_for_common_lisp/

But the project pages 404 now:

• https://common-lisp.net/project/clive/
• https://common-lisp.net/project/tovero/

From another random git commit I found it seems the project moved to being hosted on gitlab.com under the account name "kavalogic-inc" but all the repos got deleted:

• https://gitlab.com/kavalogic-inc

A pull request in the libfive project mentions a user called "sjm-tl-gh" as being the one behind Tovero, and searching that name shows a post made on HN of them mentioning their company:

• https://news.ycombinator.com/item?id=18034260

So, does anyone:

1. Have a copy of either Clive or Tovero (or both) and would like to share that with me?
2. Know what happened to these projects?
3. Know a way to contact the author to ask about 1 and 2.

My algorithm for matching 2 scanners, S1 and S2, works as follows:

1. Generate all rotations of S2.
2. For each rotation SR, compute the offsets from all scanners in SR to all scanners in S1.
3. If an offset occurs 12 or more times, then S1 and S2 overlap, and we can apply the rotation & offset to move S2 into the frame of reference of S1.

But when I compare all the scanners in the example from the problem description, the result is that scanner 1 & scanner 4 don't overlap. And, indeed, when I debug step 3 of the algorithm, no offset occurs more than once for any rotation. Scanners 0, 1 and 3 overlap, while scanners 2 & 4 overlap separately.

So, is my algorithm wrong, or is my code buggy? Here's the work in progress.

Thank you :)

https://github.com/sheepduke/clop

I wrote this library because I did not find any TOML 1.0 parser out there.

Tom’s Obvious Minimal Language (TOML) is a human friendly configuration file format. This library implements a parser (decoder) for it.

Clop strictly follows TOML 1.0 specification and is fully compatible with it. It passes all 296 tests defined in BurntSushi/toml-test.

Any comments, ideas, feedbacks, perspectives etc are welcomed!! :-)

P.S. Already in Ultralisp. Quicklisp on the way.

I just saw this post about a new IDE on /r/haskell. While there is HLS (Haskell Language Server) for different editors, it seems that there are other IDEs with nice GUI (depending on your definition of "nice"), like Leksah and Haskell for Mac.

While I like and enjoy Emacs with Sly, I was just wondering that why was there no new and modern Lisp IDEs? The only two players seem to be Allegro CL and LispWorks and they have relatively long history. Sure, unlike C++ or Python, (Common) Lisp is not that popular, but neither is Haskell (I think; thought I know that Haskell is used in some banks, hedge funds, and certain tech companies...)?

Hi,

Recently I found ABCL and abcl-jazz quite interesting.

I am thinking about building a small project, something like RSS reader, with GUI interface. While I know there are things like GTK, ltk, IUP, and so on. Still, it would be interesting and fun to explore writing GUI interface in Java with Common Lisp, not to mention the cross platform feature. I have some questions that I hope you could help me with, if you have experience with writing Java in CL:

1. There is a new thing called JavaFX, like a new generation of Swing. Is it stable and easy to use? Or should I stick to Swing because it's more mature?

2. Other than on the top of JVM, are there more advantages of using ABCL, instead of CL+J and/or JFFI with SBCL/CCL, for Java-part development?

3. Can I only use Java for GUI and CL for everything else (in the backend)? Can I use Java frameworks/libraries, like FlatLaf, with ABCL or these FFI stuffs?

Many thanks!

Hi all.

Short disclaimer - I'm hobbyist when it comes to programming. I'm quite familiar with C-style language (since I was in high school), but actually most of the time I spent with Ruby (more than 10 years). I'm "flirting" with Lisp for 5-6 years already, first with Scheme and later with CL, but considering chronic lack of time and baby boy, I have only 1-2 hours per week for learning and "hacking" Lisp.

Anyway, on to the point - what is the most common reference for Common Lisp? I assume it is Hyperspec, but I actually have difficulty using it, especially when I am looking for some function(-ality) or when I simple do not have an idea where to look.

To give you an example - I was looking for a way to run shell command or to read current/working directory in CL. With Ruby (I'm not by any means comparing Ruby to CL here), I just go to rubydocs.org (!rb bang at DDG), open Dir class/Object and I have nice overview of all the methods with short description and even examples and source code.

However, with Common Lisp I was unable to do it, except by Googling and finding random answers at Stack Overflow and similar.

So what do you use to easily browse CL documentation and reference sheet? Any tips or advises are very welcome.

Thank you.

Hi, i am a beginner.

so this question may be strange for expert lisp programmer.

i want to write map function in two ways in common lisp : recursive and iterative.

first, i write recursive solution that

(defvar test
  '(1 (2 3 4) (5 (6 7 8) 9) 10))

(defun map-rec (f xs)
  (cond ((null xs) nil)
        ((atom xs) (funcall f xs))
        (t (cons (map-rec f (first xs)) (map-rec f (rest xs))))))

CL-USER> (map-rec #'(lambda (x) (+ x 10)) test)
(11 (12 13 14) (15 (16 17 18) 19) 20)

this seems to be working fine in my eyes...

however i write iterative solutions that

(defun map-iter (f ret)
  (do ((stk (rest ret))
       (top (first ret)))
      (nil)
    (cond ((null top)
           (if (null stk)
               (return-from map-iter ret)
               (setf top (pop stk))))
           ((atom top)
            (setf top (funcall f top))
            (setf top (pop stk)))
           (t (push (rest top) stk)
              (setf top (first top))))))

;; this solutions is probably not correct...

CL-USER> (map-iter #'(lambda (x) (+ x 10)) test)
(1 (2 3 4) (5 (6 7 8) 9) 10)

original list not changed.

so i have inserted the following code for testing.

(defun map-iter (f ret)
  (do ((testret nil)     ;; additional code
       (stk (rest ret))
       (top (first ret)))
      (nil)
    (cond ((null top)
           (if (null stk)
               (return-from map-iter testret) ;; additional code
               (setf top (pop stk))))
           ((atom top)
            (setf top (funcall f top))
            (push top testret)  ;; additional code
            (setf top (pop stk)))
           (t (push (rest top) stk)
              (setf top (first top))))))

CL-USER> (map-iter #'(lambda (x) (+ x 10)) test)
(20 19 18 17 16 15 14 13 12 11)

at least it seems to be traversing the list.

why doesn't change the value of the original list in my code?

I write some code for test

(defun testcode-1 (lst)
  (dolist (e lst lst)
    (setf e (+ e 10))))

CL-USER> (testcode-1 '(1 2 3 4 5))
(1 2 3 4 5)

why not changes?...

(defun testcode-2 (lst)
  (do ((ret lst (rest ret)))
      ((null ret) lst)
    (setf (first ret) (+ (first ret) 10))))

CL-USER> (testcode-2 '(1 2 3 4 5))
(11 12 13 14 15)

it's the same result as I thou

https://github.com/sheepduke/chameleon

Chameleon is a configuration management library shipped with profile support. It can help you:

1. Define configuration items with default value.
2. Define profiles reflecting different scenarios, e.g. development, testing, production etc.
3. Switch between several profiles just like a chameleon switching its colors!
4. Access configuration item via functions (instead of bare-bone keywords or strings) to avoid invalid names.
5. Extend its behavior by providing :before, :around or :after methods.

I wrote this library 3 years ago. Recently I got some time to work on it and refined the generated code. Compared with the v1 version, it does:

1. Re-implement the logic with CLOS (instead of hash table) and refined generated code.
2. Generate variable *profile* to store current profile.
3. Generate function switch-profile for switching profile.
4. Stop generating active-profile and profiles.

Any comment/feedback/idea/perspective is welcomed!

And thanks @svetlyak40wt for his feedback!

P.S. The version in Quicklisp might still be old, Ultralisp should be good.

I'm curious to hear everyone's thoughts on this.

What if a project was written ENTIRELY in Common Lisp.

Where the shell commands for building the program are wrapped in Common Lisp, the documentation, and everything in between.

Would this even be feasible?

My thoughts are that this would be kind of neat.

Looks like one can get PCL as hardcover for USD $10 at https://link.springer.com/book/10.1007/978-1-4302-0017-8

I've wanted one for a while but they're hilariously expensive at Amazon, so hopefully this is interesting to some of you as well!

I started writing this for myself, but maybe useful for others.

http://retro-style.software-by-mabe.com/blog/Common+Lisp+-+Oldie+but+goldie

I use Fedora Silverblue, installing packages is possible but discouraged. And there's no Flatpak client for NordVPN.

Instead I wrote a very basic client that executes nmcli for me with information it gathers from the NordVPN API. It's not fancy, but gets the job done :)

https://github.com/sebasmonia/nordvpn-client

As always, suggestions on making things more idiomatic in CL are appreciated!

I've recently been re-evaluating the role of Common Lisp in my life after decades away and the last 8-ish years writing clojure for my day job (with a lot of java before that). I've also been trying to convey to my colleagues that there are lisp based alternatives to Clojure when it is not fast enough, that you don't have to give up lisp ideals just for some additional speed.

Anyway, I was messing around writing a clojure tool to format database rows from jdbc and though it might be fun to compare some clojure code against some lisp code performing the same task.

Caveats galore. If you're interested just download the tarball, read the top level text file. The source modules contain additional commentary and the timings from my particular environment.

tarball

I'll save the spoiler for now, let's just say I was surprised by the disparity despite having used both languages in production. Wish I could add two pieces of flair to flag both lisps.

Hi,

I have been using a fairly old Macbook Pro and need to develop Common Lisp in Linux. I am currently using VirtualBox for that, but sometimes it can get slow or hangs/freezes.

I have been thinking about getting a Raspberry Pi 4. I have read other posts here and on other Lisp-related subreddits that SBCL can run on Raspberry Pi OS. I was wondering that suppose if I wanted to compile SBCL or other large Lisp projects (30k+ LOC) from sources, would a Raspberry Pi 4 be able to handle that? If I develop said project with Emacs and Slime/Sly, would it slow down the computer?

Many thanks.

This is both an introduction and asking for help post.

Before reading this, please go and check out https://github.com/digikar99/polymorphic-functions which this project is fully based on. It's great.

We started developing our libraries roughly at the same time and I'm glad I could've been of help to digikar99.

Anyway, this library(https://github.com/lisp-polymorph) is inspired by https://github.com/alex-gutev/generic-cl and provides polymorphic versions of many common standard functions based on types. For example, now `>` and `<` work on characters and strings as well, and `at` is a universal by-key accessor for all data structures (`aref` + `nth` + `gethash` + some more). It also tries to be as strictly typed as possible, resulting in compile-time errors/warnings in case types are mismatched. Types do not always need to be declared, they can be inferred thanks to excellent https://github.com/alex-gutev/cl-form-types by Alex Gutev. Besides that it includes a collection of useful macros for more "typey" style of coding as well as several data structures I consider missing from the standard. The structures are templated -- which means there's a structure type generated for each contained element-type.

It may look like the whole thing consists of too many systems that are too small, but that is intentional. The main idea is, even if some users disagree with the overall design, they can still use small parts. I am open to discussion on this.

As of right now, some parts are done, but I need help with overall polishing, my outdated and bad documentation and maybe some design ideas. As an example, sequences (traversable) needs work and the whole thing about functions that use map and reduce is not finished at all. Data structures need polishing: better interface and tests. I am not an experienced programmer and feel burnt out because of irl stuff happening, which is why I cannot finish it -- which doesn't mean I am abandoning it, I do want to continue working on it. However even this post is about 3 months late.

Anyway, thanks for your attention, I'm happy to answer any questions in the comments.

Recently I made a nix based skeleton for common lisp projects. Today I decided to wrap fukamachi's cl-project to use the skeleton and place the needed common lisp files in one step.

Both the generator and the skeleton are unpolished and I would appreciate any help in making them work properly. The skeleton could also be used to try building common lisp libraries before adding them to nixpkgs, because, unlike nixpkgs, it does not rebuild the entire quicklispPackages set.

Is there an equivalent of cl's format specifiers in emacs lisp?
I haven't found anything like `cl-format` in `cl-lib`?

Is this just not implemented or is it planned to be done at some point?