Lisp thread. Do you use Lisp? What dialect?

Who fucking cares? Is the code voting on your behalf?

just the racket i learned in school but im getting better every day

>(((parentheses)))

So? It's developed under GNUs wing and while there is one main developer there appear to be 5 regular committers.
The project should be safe in case of a "Leah" event.

There are at least two others - MIT Scheme and SCM. Maybe more since the last time I checked.

Scheme is simply a more modern dialect of Lisp.

MIT Scheme is GNU Scheme. The implementation of Scheme at MIT is a GNU project.

That's my point. Guile, MIT Scheme and SCM are all Scheme dialects made by the GNU project.

When I first started poking around with it I got the Symbolics LM emulator working on Linux and ran Genera, now I use emacs+slime and it's not as good. Clozure CL is nice though.

>(((lisp)))

Clojure will do more for less than whatever npm webpack monstrosity you will eventually create.

Scheme and Common Lisp are both members of the Lisp family of programming languages, but they are different languages.

After the original Lisp was created different people and corporations started making their own dialects of Lisp and all those dialects were in some way incompatible with each other. They all died out eventually as new languages began adopting features of Lisp and the Lisp machine companies went out of business. Common Lisp was created as a sort of common ground so that one could write portable Lisp programs.

CL is a huge language that includes everything and the kitchen sink and is ugly as fuck due to having bits and pieces from everywhere. On the other hand it gives you a lot of what you need to write real-world applications. However, there is still a lot left up to the implementation, so no real-world program will ever be 100% portable (no 100% portable way of opening a file). The best thing you can do is wrap up the unportable parts behind an interface so that the unportable code can be nicely isolated. Or use a library. Or just pick one implementation and roll with it.

Scheme is its own Lisp and as such it doesn't suffer from the uglyness of Common Lisp. Scheme is also a scam created by (((Sussman))) where MIT students pay tuition and end up learning a language that is completely useless outside the classroom. It's a really nice language though, so the various implementations have added their own stuff to actually make it useful in the real world. The problem is that everyone adds their own flavour of extensions.

How bad is it? Well, until the R6RS standard there was not even a module system, so only if you wrote all your code in one file was it actually portable. What it effectively means that each implementation is its own language. R6RS tried to address this issue and create a language that is actually usable, but many found it to be too bloated, so barely any implementation is standard-compliant. R7RS tried to appease both camps by splitting the languages into two languages: R7RS small is a small language that adds some sorely-needed features (module system, record types), while R7RS is meant to be a huge real-world language (possibly even larger than Common Lisp). R7RS small is complete and Chibi Scheme is its reference implementation:
synthcode.com/scheme/chibi/

R7RS large will still take years to be finished. Some implementations like Guile or Racket have essentially given up by this point and barely even pretend to be Schemes. They support some of R6RS, but in practice they are doing their own thing now in order to implement an actually useful language.

Common Lisp are two different languages with common ancestry. Techniques that work in one work in the other, so pick whichever one either looks better to you or has the libraries you want to use.

There are no good lisp implementations. Common lisp is insane and basically removes the whole point of lisp by separating the function and variable scopes (among others) and not having hygienic macros which devolves into C #define forest garbage. Meanwhile there is no well-performing scheme implementation. In either case there is no gc-less or provable-latency lisps, and none that offer competent (this is the keyword) static type annotation (for example cl implementations do runtime checks and warnings instead of erroring out on mismatches and doing compile-time checks, while scheme implementations such as racket's (>) are broken and can't express many types used in the standard lib).

this is not what the languages were designed for. CL has them so the compiler can optimize your shitcode better, not to be a haskell clone.

...

SBCL is OK.
ccl is OK.
ya whatevr yu jst lk speling variabls lik 'lst', 'ary', &c. fugging leetspeakr.
voodoo bullshit.
read Let Over Lambda
what. CL's version of '#define forest garbage' is a whole lot better than the actual thing.
Chicken is OK.
well that's true

I got into Clojure right before Hickey broke everybody's code by giving the language lazy semantics, which is a bullshit nonfeature.
Although I was 'getting in Clojure', I was also reimplementing everything special about Clojure in CL, which is actually very easy if you read Let Over Lambda.
I learned
1. fuck lazy semantics. Fuck off and die, Haskell. You're not cool because you've gotten used to wearing the hair shirt. The hair shirt is retarded.
2. fuck language dictators that break other people's code because they had a microstroke one day. Perl6, Python3. Fuck anything without a standard. (5 years later: nevermind OCaml proves that not everyone is retarded.)
3. you can give CL a cute syntax but it's pointless because you have to then either write in CL or in CL-with-cute-syntax, which is even less popular of a language. So what's the point of the ability to create cute syntaxes?
4. the Java ecosystem is fucking weird. Why is it so damned weird? The weirdest languages in the world still manage to be good Unix citizens, usually.
5. Clojure is absolute shit on Android but advocates for the language will still eagerly suggest it as an option for Android development because they are scum.
so you could say I learned a lot from Clojure.
shit language, tho.
If you're going to Lisp, just do it like the best programmers traditionally have: implement it as needed in your practical language. The warnings about reimplementing it necessarily being buggy--those were always FUD. We're not talking about a cool language with real features like ML, here.

You wouldn't have that problem if there was a static type system that lets you specify the types of objects. In math you always specify the "type" of a variable and then you can get away with single-letter variable names. I don't think computer programs should use single-letter names, but names like "list"/"lst", "array"/ary" and such are indicative that the reader is not certain which type goes where. Instead of
(define (map lst proc) (...))
the signature should be something like
(define (map [items : (Listof T)] [f : (-> T T)]) (...))
Now I instantly know what goes where. Static type systems also protect me from mistakes like when a return type might be a value or some sort of null. When I switched one of my libraries from Racket to Typed Racket I was appaled by often I did not check for EOF.

Racket; the elegance of scheme with batteries included.

...

The only well maintained Scheme variant is PLT (Racket).

...