> you have a std lib, which can interact with many things, you can build UIs, networking libraries and all that.

Racket has all of that: https://docs.racket-lang.org

Common Lisp too: https://common-lisp.net/libraries

Clojure too: https://www.clojure-toolbox.com

(Or you could even just build anything within Emacs with Emacs Lisp: https://en.wikipedia.org/wiki/Emacs_Lisp)

> And I could probably start using any language that is "similar" to these.

Then you probably could start also using any of the Lisps mentioned. Most likely you are just hung up on the surface syntax, which does not take long to get used to.

> it feels like as I've never seen code once in my lifetime.

I think you must be fixating on syntax, or have been seeing some code that is advanced or (it exists) a very confusing example by some academic to demonstrate some curiosity.

Except for idiomatic recursion (which you don't have to use), Scheme semantics should initially look familiar to a Python or JavaScript programmer, like a subset of that, just with a different syntax. (Scheme nuances are much better designed, but to a new programmer semantics will look like a subset.)

And the Scheme syntax is one of the simplest ever, once you understand it.

What should instead be confusing is a language with very different semantics, like lazy evaluation, or an OOPL with complicating dispatch rules to reason about.

Would strongly recommend watching the SICP video lectures: https://ocw.mit.edu/courses/6-001-structure-and-interpretati...

Ah, thanks, that's what @tmtvl was talking about

Most of them use most of the same core idioms you're familiar with from other languages, they just look superficially different because of the syntax (especially the parenthesis placement)

Try moving the left parenthesis of each expression over to the right by one and it may become clearer

(my-fn 1 2)

my-fn (1 2)

Why not just program everything in assembly? High level languages give you powers of expression that lead to better programs or are simply more convenient for the particular task at hand. Lisp languages have several features that aren't found in most other programming languages. And a lot features that are found in other languages originated in Lisp.

Perhaps what you are missing is the practical part. For that you should look to the two types of Lisp in widespread usage: Common Lisp and Emacs Lisp. Common Lisp is a general-purpose language with a very large standard library and rich set of third-party libraries. Emacs Lisp is a complete language, but only really used to build text editing like stuff for Emacs. There's tons of real, effective code out there in these languages.

Or perhaps you are confused about the functional programming part. This is only strongly associated with Scheme as other Lisps support other paradigms like object-oriented programming. Functional programming is a thing that takes a while to understand, although my theory is it's actually more natural and it's only because you already learnt imperative programming, which is thoroughly unnatural, that you find it odd. Once grasped it will help you with other languages that support functional programming like JavaScript and Python.

They say learning Lisp will make you a better programmer even if you never use it again. I tend to agree with this.

>Perhaps what you are missing is the practical part.

I think that's it. Thanks, I'll take a look at common lisp, especially at projects written in it.

Not exactly what you asked for but, if you have time, I would recommend looking at Practical Common Lisp:

https://gigamonkeys.com/book/

And also this blog post (which is a much smaller time commitment):

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

Thanks this looks promising!

At least for me, there is a certain appeal in building the world. With scheme you get a very small set of functionality, but you use that to implement the rest of the language, and build abstractions on top of abstractions. Seeing how the whole system can be built from a small set of functionality is pretty cool, and also very satisfying. There is a talk from Andy Wingo, one of the maintainers of Guile, where he describes working on Guile as akin to tending to a garden, and I think its an apt comparison. Something about it feels very organic and personal, which is part of the appeal.

The syntax itself doesn't _really_ matter, it just makes it easy to do so - functions and syntax visually look the same, so it makes it easy to build.

Its not for everyone, but I think its worth exploring for a little bit. Similarly I think its worth really learning any language just a bit, if not to just expand your tool kit. The parenthesis do disappear at a certain point and you learn to read it, but if its not your thing that is fine.

Basically the differences are in the concepts you'll use to write code. Lisps themselves are very different from each other, but just like the languages you're used to, many lisp distributions have standard libraries that can be called, and those building blocks can be used to build applications or whatever else. In this case specifically, Steel provides the facility to call Rust functions within a Steel program: https://github.com/mattwparas/steel.

So, although I haven't used Steel, it looks like the advantage you'd get from using it is the opportunity to take advantage of features it provides like transducers and contracts, which are feature common to some other Lisps as well.

So, just like choosing any other language, it boils down to a series of tradeoffs.

You're not missing anything. You have two choices: a) either take it as true that there's nothing to see here and move on, b) or if you have some spare time learn lisp and then move on. (b) avoids that nagging feeling that you're somehow unworthy.

Maybe look at: https://github.com/arclanguage/anarki/blob/master/apps/news/...

Thanks, good hint!

My first introduction to Lisp-like programming languages were the SICP videos with Abelson and Sussman so to me Lisps are just programming languages like any other but with a nicer syntax and great support for interactive programming.

Why do you think homoiconicity is a gimmick? Have you seen languages that offer metaprogramming capabilities as simple & powerful as Lisp without homoiconicity?

Homoiconicity is why Lisps have rich macros and legendary metaprogramming capabilities. You don't even have to deal with it yourself to feel its usefulness. Emacs use-package is an example.