> A lisp paren can do both jobs: expression and scopes.

Using different symbols for different purposes makes sense, it helps humans to parse correctly faster.

That's right, which is why the parenthesis is combined with a leading symbol like (let ...).

Mainly, you don't look at the parenthesis when reading; you look at that let and your eyes rely on indentation for structure.

Okay, but now you have to look at more things.

Also, the ending paren doesn't have anything to help you see what it is on its own.

You're not supposed to look for ending parentheses in Lisp; getting the right number of them is more or less your editor's job, and they are maximally stacked together like this: )))), as much as the given nesting and indentation permit. Given some (let ..., the closing parenthesis could be the third one in some ))))) sequence; you rarely care which one. If it's not matched in that specific ))))) sequence where you expect, then that's a problem.

)))) is like a ground symbol in a schematic:

    (+5V
      (+10V
        (-10V
          (INPUT3 ...))))
                     -----  local "ground" for all the above

    (different circuit)

That doesn’t seem very user-friendly. ;) Or at least that’s always my perception when programming Lisp.

As a side note, I believe that different people fundamentally have different programming languages that objectively suit them best, due to differences in their respective psychology and way of thinking and perceiving. It’s interesting to discuss trade-offs, but in the end there is no single truth about which language is better overall — it depends on the task and on the person. There’s no “one size fits all”. What’s valuable is to understand why a certain syntax or language might work better for certain people.

Just ignore the parentheses. Setting them to the background color may enforce that.

It does, but there are still many different purposes. In JS:

( can mean: function call, part of an expression to be evaluated first, regex capture group

{ can mean: scope [of ... loop, if, lambda, function etc.], object definition, string interpolation code i.e. ${..}, class definition

There are probably other things I am not thinking of.

The one that trips me in JS is code like x.map(v => {...v, v2}) breaks because the compiler sees the { as the beginning of a scope, not the object definition I intended.

The working solution is x.map(v => ({...v, v2}))

But x.map(v => v+1) is allowed.

I don't think the compiler could figure out what you meant because an object definition might be a lambda function body. For example { myvar } can be both an object definition, and a function that returns myvar.

Sure, why care about splitting algorithms into functions and naming them appropriately when you can just write it all in a 3k line function.

That's obviously nonsense.

Java, one pair of parens:

    int x = 1;
    int y = x + 1;
    System.out.println(y);

Clojure, six pairs of brackets:

    (let [x 1 y (+ x 1)] ((. (. System out) println) y))