My nomination for what we get wrong over and over again: working under the assumption that there is One True Syntax. There isn't. Different syntaxes are suitable for different needs.

A single language can support multiple syntaxes if the AST is exposed as a first-class construct. This makes it easy to write new syntactic front-ends. Unfortunately, the only language to date that supports this idea is Lisp, which means that this incredibly powerful idea is conflated in most people's minds with lots of irritating silly parentheses. (One of the reasons for this conflation is that once you start adopting this mindset the parens become a lot less silly and irritating, but that's another story.)

I'm currently working on cryptography code, where algebraic syntax is very convenient. Here's an excerpt from some code I'm currently working on:

    (define-method (point-double (ec elliptic-curve a b c q r) x y)
      (bb
       lambda modp(q, (3*x*x + 2*a*x + b)/(2*y))
       x3 modp(q, lambda*lambda - a - 2*x)
       y3 modp(q, lambda*(x-x3)-y)
       (values x3 y3)))
    
    (define-method (point-add (ec elliptic-curve a b c q r) x1 y1 x2 y2)
      (if (and (= x1 x2) (= y1 y2))
        (point-double ec x1 y1)
        (bb
         lambda modp(q, (y1-y2)/(x1-x2))
         x3 modp(q, lambda*lambda-a-x1-x2)
         y3 modp(q, lambda*(x1-x3)-y1)
         (values x3 y3))))

Notice that it looks like Lisp (and it is Lisp) but there's infix code seamlessly embedded. Moreover, the MODP construct automatically converts everything to modular arithmetic operations, so, for example, x/y doesn't actually divide but instead expands into (* x (modular-inverse y p)). But when I code, all I have to do is copy the mathematical formulas more or less verbatim and my compiler takes care of expanding everything out into calculations that use Montgomery reduction or whatever optimizations I want to provide. This approach also has the advantage that I can test the correctness of my protocols completely independently of the correctness of my optimizations.