I’ve never did anything serious with Common Lisp, but my light experience on it was that

- the idea that almost all language constructs are user-implementable with macros is quite impressive (but I don’t buy the argument that “real” macros are only able in s-exprs)

- and the REPL-driven development model was a really beautiful and seamless experience.

But… every time I try to use it on some code, I find too many warts and inconsistencies that I just didn’t want to spend too much effort in making it work. It’s a beautiful language in it’s own ways, but the other parts are too ugly (to me, of course).

I’m fine with it being a lisp or not; I just want a clean language with macros baked in (and becomes the basis of most language features), and with a REPL-driven development model as a first class citizen (with interactive restarts and all).

Unfortunately it seems a pipe dream… so I’m stuck here.

[0]: https://mikelevins.github.io/posts/2020-12-18-repl-driven/

Good to see, but at this point in its lifecycle I don't really believe a lack of good tutorials is a barrier or even impediment for CL.

The problem is after the tutorial is done, all the libraries (look (like (this))) and the language is so powerful it is difficult to know if this 10kb contains a life-changing insight into the nature of programming or a half-hearted implementation of half of something that was a bad idea to start with. Knowing the syntax and technical semantics of the language doesn't help with that.

The topic has been done to death, but the lisps seem to have a social organisation problem that the community never quite managed to get a grip on.

Great to see a chapter on LOOP: https://docs.google.com/document/u/0/d/1L9jdKE-XrCU0VhdsmO5w...

If you’re unfamiliar with Common Lisp, it’s important to understand that it’s a multi-paradigm language. The presence of closures, key functions in the standard library, and the syntax often push you naturally to a functional solution. But you shouldn’t feel bad about writing a LOOP that mutates a bunch of state under the hood. This isn’t scheme!

Steel Bank Common Lisp has been one of the most enjoyable, performant, powerful languages I have ever used.

Till now when I hack on something I use Steel Bank Common Lisp.

Only for the most basic of web apps do I switch to Rails.

These set of tutorials are excellent. Thanks for sharing.

Practical Common Lisp gets you up to speed very fast.

I wish there was something similar for scheme. Most scheme books focus on teaching you compsci with the language and not on teaching you how to build practical things with it.

It's quite hard to onboard someone to a scheme codebase, despite scheme's reputation of being a simple language.

Feels appropriate to say that Hylang is in version 1.0 alpha:

https://github.com/hylang/hy/releases/tag/1.0a4

That's Lisp over Python -- you can do data science properly in Lisp now using all you favourite Python packages.

I repeat you can do data science properly in Lisp now.

Rabbibotton has created the CLOG framework and it is fantastic. It supports a full desktop gui experiences over websockets all the way down to static webpages and any combination in between that you could want.

It’s really impressive work. I guess it’s a reimplementation of a framework he wrote in ADA years ago, so it’s really well developed and thought through.

One of the salient features of Lisps is that they are dynamic languages designed so they can be compiled into very efficient code. The details of how this works are interesting (for example, the use of low order bits as tags to efficiently detect common error cases, and also to allow types like characters, fixnums, and some floats to be represented without allocation.) A downside of this is that lisp implementations may not be ABI compatible with other language implementations.

The macros are orthogonal to this. Macros are really just an example of a more general thing: features that are used to effectively implement parts of the language definition are often lifted up and also made available to users. This effectively allows the language to be extended in a way that very closely resembles the language's built-ins. (This is not always the case; lifting more such things would be a good avenue for extending Lisps.)

the point of the tutorial is to give you enough knowledge of common lisp in order to use the author's clog gui-web-framework, which btw is pretty neat

My favorite common lisp thing is the special operator `the`. http://clhs.lisp.se/Body/s_the.htm

`the value-type form) => result*`

Looking at its use, you might think it lets you declare types of things for type-checking purposes. i.e.

(the integer (operate-on 1))

... would make the program assert-fail if (operate-on 1) were somehow not an integer.

The real story is it can do that, but the spec actually says behavior is undefined if the value is not the specified type. So check-failing is one of the many things it's allowed to do.

In practice, depending on your compiler settings, `the` can act like asserts or it can act like places the compiler's allowed to paint racing-stripes on your code to make it go faster by skipping dynamic type checks and letting data structures mangle up if the types are wrong. ;)*

Off hand question. From which lisp did I learn

    (compress (reverse (explode 'ABC))) 
     ==> 'CBA

I tried to google it, but I only found some shit I have written myself. First thing I did with my very own Symbolics-machine, was to implement explode & compress, because I did not want study those marvelous string-manipulating possibilities it may have.

Compress & Explode manipulate of list of numbers, of course. In my latest Brain-Fart production I think have finally solved all problems. List of numbers, whose first number is 34 aka \" , is printed as "string" in ppretty-printer and editor. No need to implement strings *EVER*.

https://github.com/timonoko/nokolis.py#readme

Racket is another dialect of lisp.

Looks really cool (because classic GUI pictures, desktop or desktop-like GUI is what I want). Feels like I'm going to learn it finally. Thanks!

What are people using LISP for? Other than the Emacs flavor, and some companies using Clojure, I'm not really sure what I'd use it for? Would I use it to replace Python or Shell scripting for my custom CLI tooling? Anyway, I've seen a lot of people talking about the Lisps lately, and trying to figure out what I'm missing.

The only Lisp I know of is Emacs Lisp. I thought It was implementation of common lisp, but according to Wikipedia I am wrong.

So If primarily Linux user (sysadmin/devops/ occasional embedder programmer), wanted to learn lispy like language, that is useful which one would you pick?

Emacs one? some common lisp or scheme ?

My plan is after another iteration or two of editing to move it to markdown.

This is a great idea - I'm looking forward to trying it.

One nitpick: the Google Docs code does not display favourably on mobile. It might help to publish in HTML if you're interested in targeting those readers.

But why Google Docs rather directly on GitHub as md files?

Rabbibotton is really motivated and putting in a lot of effort with CLOG and with these tutorials. I think he's even offering monetary rewards for others to write tutorials. Its nice to see his efforts make it to the front page here. :)

>ball of goop

can you please talk to us like programmers? your audience is programmers.