What are /r/Common_Lisp's favorite Products & Services?

From 3.5 billion Reddit comments

To those who, like me, don't know what a planning validator is, and don't care to look it up, I did, you can get a general idea looking at this tutorial (it is a PDF), in summary you have a set of objects with an initial state, a set of predicates to check the state of an object or combination of objects, actions that can change that state, and a goal (subset of objects must be in required state), if I understand everything correctly the plan is the set of actions that accomplish the goal, and the plan validator's work is to verify that indeed the plan is executable and solves the problem (meet the goal criteria). This reminds me a bit of GPS (as they appear on PAIP), which try to generate a plan.

Anyone that thinks I'm wrong please correct me.

CM is about music composition, CLM is about sound synthesis.

If you look at the book, then you'll find that it is a bit older. CM's current version uses a special Scheme dialect.

The older CM version was working in Scheme and CL. From the repository, this would be the version 2:

https://sourceforge.net/projects/commonmusic/files/cm/2.10.0/

Could be that there are versions somewhere, with some later attempts/fixes to use it.

This is a Travis configuration that automatically pulls and installs the SBCL version configured in the environment variable on three different OSes. I post it here in case someone else wants to tackle a similar problem in the future.

Currently SBCL is compiled from source each time the CI runs. A possible improvement is to have Travis build SBCL once and cache it in GitHub releases of some repository; I'll do that soon and post the results here.

Example run: https://travis-ci.com/phoe-trash/furcadia-post-splitter/builds/133614805

While I haven't used it, you might consider a Tk based GUI system since Tk is quite portable and straightforward to install or bundle with a program from what I understand. LTK (http://www.peter-herth.de/ltk/) is commonly recommended. There was a recent fork of it called nodgui (https://notabug.org/cage/nodgui) that might also be of interest.

Tk GUIs are often quite old fashioned looking, for better or worse, and Tk GUIs can be a pain to make compared to some other systems in some ways (or at least, my experience with Tk in Python has shown this); but Tk is quite portable and lightweight compared to anything Qt based.

yes, as mentioned in another comment, see Dash (Mac) / Zeal (Linux) / Velocity (Windows). You'll have to download the Lisp docset.

(hint: https://github.com/CodyReichert/awesome-cl#offline)

https://kapeli.com/dash

Thanks! If you put ":results output" into begin begin_src line like so: "#+BEGIN_SRC lisp :results output"

Then it outputs printed things. Link to org mode documentation: https://orgmode.org/manual/Results-of-Evaluation.html " Scripting mode. Org passes the code to an external process running the interpreter. Org returns the contents of the standard output stream as text results.

When using a session, Org passes the code to the interpreter running as an interactive Emacs inferior process. Org concatenates any text output from the interpreter and returns the collection as a result. "

Agreed, I was in a similar dilemma before building deftask - really wanted to use an async framework for it. Thankfully good sense prevailed before I went down the rabbit role - code would have been less readable, community support would be non-existent, essentially I would have been on my own, all for efficiency gains that I may not need for months or even years.

Threads and blocking I/O may be more resource intensive, however your code is much more readable and debugging is far easier (backtraces are virtually non-existent in async code).

Really hoping that at some point we see a Lisp implementation support co-routines alongwith smart run-time management, like go:

> Goroutines are part of making concurrency easy to use. The idea, which has been around for a while, is to multiplex independently executing functions—coroutines—onto a set of threads. When a coroutine blocks, such as by calling a blocking system call, the run-time automatically moves other coroutines on the same operating system thread to a different, runnable thread so they won't be blocked. The programmer sees none of this, which is the point. The result, which we call goroutines, can be very cheap: they have little overhead beyond the memory for the stack, which is just a few kilobytes.

https://golang.org/doc/faq#goroutines

IMO this brings best of both worlds.

I think so, it's the most mature alternative. Unfortunately I don't think it's really "easy to use", mostly because you have to learn Emacs, but maybe try slima and Atom?

Portacle if you want to give emacs a try, else slima with Atom.

If you sre already familiar with emacs, simply install the emacs packages slime, slime-company and company; optionally, paredit or lispy.

I found this, last week I think, with a general web search for <em>learn lisp the hard way</em>. I guessed it might exist after learning of the other Learn X the Hard Way sites.

Is the issue the password hashes? You might be able to take this approach if you can figure out how the cl-pass passwords are hashed (and if keycloak supports the same algos, which is likely): https://dev.to/carnewal/import-existing-users-with-bcrypt-hashed-passwords-in-keycloak-17oo

Looks to me you jumped step 2 (https://atom.io/packages/atom-slime) "Install a lisp if you don't already have one (such as SBCL)".

Did you

apt-get install sbcl

? Good luck !

ps: https://lispcookbook.github.io/cl-cookbook/editor-support.html hope that helps

I don't think that MSYS2 has X server. But it has X capable graphical programs like xpdf. Through the years I've used several X servers for Windows like Xming http://www.straightrunning.com/XmingNotes/ , Exceed, and currently trying out X410.

I like this, it reminded me of frink, a programming language I experimented a bit with, the author was concerned with people often forgetting about converting units of measure.

Time for a shameless plug! On my machine:

% time sbcl --noinform --eval '(write-line "hello world")' --quit hello world sbcl --noinform --eval '(write-line "hello world")' --quit 0.25s user 0.02s system 99% cpu 0.268 total % time python3 -c 'print("hello world")' hello world python3 -c 'print("hello world")' 0.03s user 0.01s system 98% cpu 0.048 total % time lcli say '"hello world"' hello world lcli say '"hello world"' 0.00s user 0.00s system 65% cpu 0.007 total

Here lcli is the client of my home-made server https://notabug.org/quasus/lserver/. It's inspired by ScriptL and probably is simpler.

The Hyperspec is available through Dash/Zeal. When you started looking for "values-list", I just popped zeal open (I have it assigned to a scratchpad which opens when I hit M4-z) and typed in "values" and saw what you were looking for much more quickly than it took to browse through the Hyperspec. I recommend trying it out. (Looks way nicer in "dark" mode too.)

The author of the german book "Funktionale Programmierung und Metaprogrammierung", which is a fine book, describes analysis and log file scanning tooling developed with Common Lisp used for some "Deutsche Welle" HTTP servers.

https://www.amazon.de/Funktionale-Programmierung-Metaprogrammierung-Interaktiv-Common/dp/3658137436/ref=sr_1_1?__mk_de_DE=ÅMÅŽÕÑ&amp;dchild=1&amp;keywords=common+lisp+funktionale&amp;qid=1630090232&amp;sr=8-1