I’m interested also - please post a link when you write the blog post :)

why should I choose Racket instead of Common Lisp? :slightly_smiling_face:

Sure I could say racket is a modern lisp and a descendent of scheme with arguable the most advanced meta programming available, but I really just stay for the people :blush:

https://racket-lang.org/\|https://racket-lang.org/ is a good place to start

but tell us what you want to achieve

Plenty of common lispers use racket

It’s not you have to choose

And Common Lisp is good too

Mostly comes down to personal aesthetics IMO. I use both and love them both. I generally lean more heavily on racket these days just due to the infrastructure, community (ie this slack group), and a few other things.

The important thing to remember about lisp is that - like forth and smalltalk - you are essentially picking an implementation that isn’t really compatible with the others because the standard is really just the basics and doesn’t include all the batteries.

So pick whatever has the most batteries you need at the start and which has the personal aesthetics you prefer (that’s a CL vs Scheme thing and not CL vs racket).

I was always under the impression that the big selling point is that it makes it dirt simple to write your own languages and to interop between them and other racket programs

That’s certainly rackets unique selling point. But when comparing to CL my guess is that wasn’t a factor in the original question (assuming the question genuine)

Some people just want grow as developers, and a lisp(common, scheme or racket) is often recommended as a good way to do this. I should also mention that Clojure should not be ruled out if you want to learn a lisp.

That said, it is hard to beat Rackets books and documentation if you are new to programming or an experienced developer. The IDE(DrRacket) is especially kind to beginners. You won’t find an easier to install language.

i would choose racket over common lisp because racket doesn’t do anything obviously strange.

the first oddity that you’ll see in cl are the two standard namespaces. one for functions and the other for non-functions.

the deeper you dig into cl the more obtusities like this will show up.

variables have hidden properties that you can use to store extra values. for example.

honestly I would pick racket just because of how much the community cares about user experience. compare http://www.lispworks.com/documentation/HyperSpec/Front/\|http://www.lispworks.com/documentation/HyperSpec/Front/ with https://docs.racket-lang.org/\|https://docs.racket-lang.org/

for studying Julia is an interesting lisp that’s a good starting point.

@sw5355700, what’s something in CL that’s “obviously strange” in comparison to Racket?

Generally speaking, I like CL (specifically SBCL or LispWorks) considerably more than most Scheme implementations.

How is Julia a lisp?

While not homoiconic, Julia does have macros: https://jkrumbiegel.com/pages/2021-06-07-macros-for-beginners/\|https://jkrumbiegel.com/pages/2021-06-07-macros-for-beginners/. Certainly not the same, though. I - personally - would need to squint really hard to make Julia a Lisp :)

Elixir has hygienic macros

(I only recently found out)

I did Erlang work professionally for a bit an enjoyed it. Friends try and get me into Elixir, but I haven’t really tried it much yet. I like Ruby, though, so maybe it’d be nice.

ehh, I found its handling of generic collections pretty strange. That’s my biggest complaint though

I imagine CL has the same problems, elisp certainly does (and way worse)

julia uses syntax but it’s ast is just a lisp

https://docs.julialang.org/en/v1/devdocs/ast/#Julia-ASTs

@massung http://www.lispworks.com/documentation/HyperSpec/Body/f_set.htm http://www.lispworks.com/documentation/HyperSpec/Body/m_setf_.htm http://www.lispworks.com/documentation/HyperSpec/Body/s_setq.htm http://www.lispworks.com/documentation/HyperSpec/Body/m_psetq.htm

literally just cl works this way.

and to no obvious benefit.

All those make sense to me, I guess. set is for runtime use. setf is for macro definitions so that defsetf is possible. setq is just the compile-time version of set, and psetq - I admit - is dumb and likely just there for historical reasons (likely there was a single implementation that had it and to keep backwards compat with exiting code it was grandfathered into the spec).

I will admit that sometimes the naming of various CL functions can be weird. rplaca and rplacd come to mind immediately. But every time I’ve wondered about the use of something in the spec, I’ve eventually needed it.

that looks absolutely absurd compared to racket which needs none of that.

And CLOS is just awesome (IMO).

the take away is there’s something fundamentally wrong with the design of cl.

Well, I’m happy to debate the finer points of any language/implementation details. Nothing is perfect as they are all made by people. And anything that’s been around for a long time has some serious warts. Racket has many of them, too.

But given that CL has been used quite successfully by many companies and individuals for many decades I think shows that there isn’t something “fundamentally wrong” with it. But the warts it does have may just rub you the wrong way, and I can get that.

Another way to look at it is like everything else, we all stand on the shoulders of the giants that came before. The real advantage Racket has over any CL implementation is that Racket is still evolving and improving. And - while rare - the move to Racket CS showed that the Racket team is even willing to break some backwards compat if they feel it’s in the best interests of all moving forward. Sadly, CL is pretty much stuck and I don’t think it’ll ever get revised.

racket doesn’t have generic collections in the base language.

Hey everyone, Stephen & I are running another summer event: https://racket.discourse.group/t/summer-lang-party Make a #lang , win a prize!