As a first approximation, there is not much to learn. The lisp syntax thing is a scarecrow for the uninformed

In Python, you write:

a = atan2(x, y)
b = sin(x)
c = b if x > a else 1
# use values of a, b and c here

Where the indentation is a block.

In Scheme, you write:

(let ((a (atan2 x y))
      (b (sin x))
      (c (if (> x a) b 1)))
       ; use values of a, b, and c here
)

Where the outer paren around “let” determines the scope of the binding, and the scope serves as an expression with a value (like in Rust), and scopes can be nested arbitrarily deep.

it’s as simple as

(command argument0 argument1 argument2)

meaning arguments 0, 1 and 2 are applied to command. when an expression is evaluated it dissolves into a value according to its context.

(+ 1 2 3)
; evaluates to 6 in a context where + actually means an addition or sum operation

(* 2 (+ 4 3))
; evaluates to 14 (i think)

the absolute killer feature is the elimination of idiotic, man-made madness excused with the term “operator precedence”

Yeah, the style of syntax originated in LISP. The technical name is S-expressions.

But yes, the basic syntax rules are extremely simple. It’s rather when you actually want to do something with that syntax that it takes some thinking…

It’s actually really easy.

Somehow it’s not the bracket syntax that stopped me.

It’s the amount of dialects LISP has. Way too many of it. I don’t know where to start