svetlyak40wt

Indeed! Some time ago, I've made this video review of 8 (EIGHT!) IDE to work with Common Lisp:

https://www.youtube.com/watch?v=eTgDaMREKT4&t=2s

Take a time and choose one. The world is not limited only by Vim and Emacs. However, I prefer emacs these days (happily switched from Vim a decade ago).

Turn on english subtitles if you don't speak Russian.

In this video, I tell you how to make a complex web application in Common Lisp and Clack.

You will see how you can add different middleware to your application, for example, logging all HTTP requests.

I will also show you how to distribute static files from the CL web server and how to combine several Clack applications in one server so that each application responds in its own route.

Also, I will explain the difference between Clack and Hunchentoot. If you want to learn about it, watch the video to the end!

Parenscript is other tool. Mainly it generates Javascript. However it has support for CL-WHO like templating for generating HTML on client side.

Spinneret is better than CL-WHO at least in it's string escaping policy. All values are escaped by default whereas with CL-WHO you need to wrap with CL-WHO:ESC all string values.

Thus CL-WHO is vulnerable to XSS attack by default.

Watch this video on Lisp interactive development approach. I've recorded it especially to answer the question:

https://www.youtube.com/watch?v=JklkKkqSg4c

That is a typical consumerism: "Give me everything ready to use and then I'll use it."

How about bringing some value to the community?

I'm the author and I'm using Emacs + SLY. Happily switched to Emacs from VIM about 10 years ago when decided to invest all my free time into Common Lisp.

And yes, I have real project experience – a lot of Commmon Lisp libraries at https://github.com/40ants and also I'm developing a hosting for CL library distributions: https://ultralisp.org

I'm the author of the video, so you can ask me any questions.

Common Lisp is alive. Don't believe me? Look at this video describing 8 programming environments supporting Common Lisp.

Turn on English subtitles if Russian is not your native language.

Actually it is written in Janet programming language.

That is great, now other developers have a chance to use Kandria as an example for their own projects!

That is why I've put about half of this year into the Common Lisp documentation generator for all of my libraries.

If you are interested, please read it's docs and join the effort of making good documentation for CL projects: https://40ants.com/doc/

Yeah, you've got a dynamically linked binary.

There is a work in progress on SBCL to make it possible to create a really static binaries:

https://www.timmons.dev/posts/static-executables-with-sbcl-v...

I tried this fork and it worked for me!

I think here he is talking about "integrators" - engineers who write in DLisp rules to process documents.

But most probably CL developers you'll be able to find, will be more skillful then an average developer on the market.

Sure. Use it! Or not. Depending on your confidence in the language.

I'd use it in my own startup.

If you have any questions or feature requests, we can discuss them here.

I'm the author of this tool.

Hm, I have similar project, but for OSX users:

https://github.com/40ants/cl-bitbar

It is a library to write plugins for https://getbitbar.com

You can define your own syntax in CL:

    CL-USER> (set-macro-character #\{
           (lambda (str char)
             (declare (ignore char))
             (let ((*readtable* (copy-readtable *readtable* nil))
            (keep-going t))
        (set-macro-character #\} (lambda (stream char)
              (declare (ignore char) (ignore stream))
              (setf keep-going nil)))
        (let ((pairs (loop for key = (read str nil nil t)
            while keep-going
            for value = (read str nil nil t)
            collect (list key value)))
              (retn (gensym)))
          `(let ((,retn (make-hash-table :test #'equal)))
             ,@(mapcar
         (lambda (pair)
           `(setf (gethash ,(car pair) ,retn) ,(cadr pair)))
         pairs)
             ,retn)))))
    T
    
    CL-USER> {:foo 100500 :bar 42}
    #<HASH-TABLE :TEST EQUAL :COUNT 2 {1005879463}>
    
    CL-USER> (alexandria:hash-table-alist #v1)
    ((:BAR . 42) (:FOO . 100500))
    CL-USER> 

    CL-USER> (defmethod print-object ((obj hash-table) stream)
               (princ "{" stream)
               (loop with indent = nil
                     for key being the hash-keys in obj using (hash-value value)
                     when indent
                       do (format stream "~% ")
                     unless indent
                       do (setf indent t)
                     do (format stream "~S ~S" key value))
               (princ "}" stream))
    #<STANDARD-METHOD COMMON-LISP:PRINT-OBJECT (HASH-TABLE T) {10040C9F83}>
    
    CL-USER> {:foo 100500 :bar 42}
    {:FOO 100500
     :BAR 42}

There is a thread on Reddit, discussing different possibilities to build webasm from Common Lisp:

https://www.reddit.com/r/lisp/comments/7z7wuq/has_anyone_con...

About 90% libraries from Quicklisp are hosted on the GitHub.

Have you looked at Qlot (https://github.com/fukamachi/qlot)? It solves the problem of reproducible builds.

Quicklisp and ASDF do not support semver. But you can use Qlot to pin some libraries to a particular version.

Pinning libraries using Qlot solve the issue of being on the bleeding edge.

Oh, I thought this is only my problem and there is some bias.

Common Lisp?

Interesting. It doesn't use any framework like for web. Running on a raw Hunchentoot. Uses Parenscript to generate JS.

Actually, lisp varian can be also a:

    (mapcar #'string-downcase '("Hello" "world!"))

There is already a good PDF version of the Common Lisp Standard Draft. You can download it here: http://cvberry.com/tech_writings/notes/common_lisp_standard_...

I'd recomment a ClozureCL instead of SBCL for a newcomer, because CCL does not do some optimizations and it is easier to debug. For example, it will show you local variables created by `let`, but SBCL – does not.