Here's hoping this won't be abused by smaller companies that will no longer want to pay for the actual subscription. I also wonder if they are moving towards a different funding model, since the IDE space is pretty competitive with a free alternative (VSCode) out there.

neovim is marginally more popular.

vscode is the crushing majority.

Will folks revealed preference continue to be big and expensive?

I think you're misremembering. The streets were flooded with Rangers and S10s back in the day. Full sized pickups have been the most popular class of vehicle for decades but that number is grossly inflated by the amount that are bought as fleet vehicles or work vehicles.

F series Fords definitely outsold it, but is also a larger product line.

No, it is because emissions regulations. A small truck can’t be built on our emissions policies, not that there isn’t a market for one.

If i programmed enough in lisp I think my brain would adjust to this, but it's almost like I can't full appreciate the language because it reads in the "wrong order".

I’m not certain how true that really is. This:

    foo(bar(x), quux(y), z);

    (foo (bar x) (quux y) z)

    int bar_x = bar(x);
    char quux_y = quux(y);
    
    return foo(bar_x, quux_y, z);

    (let ((bar-x (bar x))
          (quux-y (quux y)))
      (foo bar-x quux-y z))

One of the things that sucks about LISP is - master it and every programming language is nothing more than an AST[0].

:-D

0 - https://en.wikipedia.org/wiki/Abstract_syntax_tree

can you imagine saying something like

> The fradlis language encourages your average reader to think of essays as syntax [instead of content].

and thinking it reflects well on the language................

  can you imagine saying something like

  > The fradlis language encourages your average reader
  to think of essays as syntax [instead of content].

  and thinking it reflects well on the language

But it is not the right tool for making measured, repeatable, cuts. It is not the right tool for making perfect right-angle cuts, such as what is needed for framing walls.

In other words, use the right tool for the job.

If a problem is not best expressed with an AST mindset, LISP might not be the right tool for that job. But this is a statement about the job, not about the tool.

0 - https://en.wikipedia.org/wiki/Reciprocating_saw

The AST aspect of Lisps is absolutely an advantage. It obviates the need for the vast majority of syntax and enables very easy metaprogramming.

    (let (bar-x (bar x))
         (quux-y (quux y)))
    (foo bar-x quux-y z)

The nesting makes sense to an interpreter, I'm sure, but it doesn't make sense to me.

Is each top-level set of parens a 'statement' that executes? Or does everything have to be embedded in a single list?

This is all semantics, but for my python-addled brain these are the things I get stuck on.

  (let variable-bindings statment1 statement2 ... statementN)

The variable-bindings occupy one argument position in let. This argument position has to be a list, so we can have multiple variables:

  (let (...) ...)

  (let (var1 value1
        var2 value2
        var3 value3)
    ...)

  (let ((var1 value1)
        (var2 value2)
        (var3 value3)
    ...)

  (let (a b c d e) ...)

Another aspect to this is that Common Lisp allows a variable binding to be expressed in three ways:

  var
  (var)
  (var init-form)

  (let (i j k (l) (m 9)) ...)

Interleaved vars and initforms would make initforms mandatory. Which is not a bad thing.

Now suppose we have a form of let which evaluates only one expression (let variable-bindings expr), which is mandatory. Then there is no ambiguity; we know that the last item is the expr, and everything before that is variables. We can contemplate the following syntax:

  (let a 2 b 3 (+ a b)) -> 5

If I have to work with your code, I will grok that instantly and not have any problems.

In the wild, I've seen a let1 macro which binds one variable:

  (let1 var init-form statement1 statement2 ... statementn)

1. Just for the sake of other readers, we agree that the code you quoted does not compile, right?

2. `let` is analogous to a scope in other languages (an extra set of {} in C), I like using it to keep my variables in the local scope.

3. `let` is structured much like other function calls. Here the first argument is a list of assignments, hence the first double parenthesis (you can declare without assigning,in which case the double parenthesis disappears since it's a list of variables, or `(variable value)` pairs).

4. The rest of the `let` arguments can be seen as the body of the scope, you can put any number of statements there. Usually these are function calls, so (func args) and it is parenthesis time again.

I get that the parenthesis can get confusing, especially at first. One adjusts quickly though, using proper indentation helps.

I mostly know lisp trough guix, and... SKILL, which is a proprietary derivative from Cadence, they added a few things like inline math, SI suffixes (I like that one), and... C "calling convention", which I just find weird: the compiler interprets foo(something) as (foo something). As I understand it, this just moves the opening parenthesis before the preceding word prior to evaluation, if there is no space before it.

I don't particularly like it, as that messes with my C instincts, respectively when it comes to spotting the scope. I find the syntax more convoluted with it, so harder to parse (not everything is a function, so parenthesis placement becomes arbitrary):

    let( (bar-x(bar(x))
         quux-y(quux(y)))
    foo(bar-x quux-y z)
    )

it distinguishes the bindings from the body.

strictly speaking there's a more direct translation using `setq` which is more analogous to variable assignment in C/Python than the `let` binding, but `let` is idiomatic in lisps and closures in C/Python aren't really distinguished from functions.

    (let (bar-x quux-y)
      (setq bar-x (bar-x)
            quux-y (quux y))
      (foo bar-x quux-y z))

  [](){}

https://jsfuck.com/

    let bar_x = x.bar()
    let quux_y = y.quux()
    return (bar_x, quux_y, z).foo()

As a bit of a digression:

The ML languages, as with most things, get this (mostly) right, in that by convention types are encapsulated in modules that know how to operate on them - although I can't help but think there ought to be more than convention enforcing that, at the language level.

There is the problem that it's unclear - if you can Frobnicate a Foo and a Baz together to make a Bar, is that an operation on Foos, on Bazes, or on Bars? Or maybe you want a separate Frobnicator to do it? (Pure) OOP languages force you to make an arbitrary choice, Lisp and co. just kind of shrug, the ML languages let you take your take your pick, for better or worse.

People don't work in postfix notation either, even though it would be more direct to parse. What people feel is clearer is much more important.

Tather than obj.f(a, b). we have obj.(f a b).

  1> (defstruct dog ()
       (:method bark (self) (put-line "Woof!")))
  #<struct-type dog>
  2> (let ((d (new dog)))
       d.(bark))
  Woof!
  t

  3> '(qref a b c (d) e f)
  a.b.c.(d).e.f

  4> '(qref a b 3 (d) e f)
  (qref a b 3 (d)
    e f)

  1> (defstruct circular ()
       val
       (:method next (self) self))
  #<struct-type circular>
  2> (new circular val 42)
  #S(circular val 42)
  3> *2.(next).(next).(next).(next).val
  42

   *2.(next)
   .(next) ;; nope!
   .(next) ;; what did I say?

  obj.?slot
  obj.?(method arg ...)

However, experience shows that functions having one "special" argument that basically corresponds to grammatical subject in natural languages is such a common case that it makes sense for PLs to have syntactic sugar for it.

  (progn
    (do-something)
    (do-something-else)
    (do-a-third-thing))

  (let ((a 12)
        (b 14))
    (do-something a)
    (do-something-else b)
    (setf b (do-third-thing a b)))

  (define (start request)
    (define a-blog
      (cond [(can-parse-post? (request-bindings request))
             (cons (parse-post (request-bindings request))
                   BLOG)]
            [else
             BLOG]))
    (render-blog-page a-blog request))

Here's an example that mixes in a decent amount of procedural code that I'd consider idiomatic. https://github.com/ghollisjr/cl-ana/blob/master/hdf-table/hd...

https://github.com/hipeta/arrow-macros

The common complaint that Common Lisp lacks some feature is often addressed by noting how easy it is to add that feature.

I don't understand why you think this. Can you give an example?

  (log (sqrt (sin (* 2 pi x)))

    log (sqrt (sin (2 * pi * x)))

The ergonomic problem people face is that the chaining of functions appears in other contexts, like basic OOP.

Some kids trained on banana.monkey().vine().jungle() go into a tizzy when they see (jungle (vine (monkey banana)))).

    (-> (* 2 PI x) sin sqrt log)

The parenthesis do really disappear, just like the hieroglyphics on C influenced languages, it is a matter of habit.

At least it was for me.

Plus, if syntax errors can easily take several minutes to fix, because if the syntax is wrong, auto format doesn't work right, and then you have to read a wall of text to find out where the missing close paren should have been.

  Language shapes the way we think, and determines what we can think about.
  - Benjamin Lee Whorf[0]

  Ask a C programmer to write factorial and you will likely
  get something like this (excuse the underbars, they are
  there because blogger doesn't format code in comments):

  int factorial (int x) {
      if (x == 0)
          return 1;
      else
          return x * factorial (x - 1);
  }

  And the Lisp programmer will give you:

  (defun factorial (x)
    (if (zerop x)
        1
        (* x (factorial (- x 1)))))

First, let's "modernize" the LISP version by replacing parentheses with "curly braces" and add some commas and newlines just for fun:

  {
    defun factorial { x },
    {
    if { zerop x },
      1 {
        *,
        x {
          factorial {
            - { x, 1 }
          }
        }
      }
    }
  }

  {
    "defun" : {
      "factorial" : { "argument" : "x" },
      "body" : {
        "if" : { "zerop" : "x" },
        "then" : "1",
        "else" : {
          "*" : {
            "lhs" : "x",
            "rhs" : {
              "factorial" : {
                "-" : {
                  "lhs" : "x",
                  "rhs" : "1"
                }
              }
            }
          }
        }
      }
    }
  }

    int
      factorial ( x )
        {
          if ( zerop ( x )  )
            1
          else
            x * factorial ( x - 1 )
        }

0 - https://www.goodreads.com/quotes/573737-language-shapes-the-...

The citation is relevant to this topic, therefore use and attribution warranted.

As my mother tells the story, my great grandmother had the choice of either taking a bus, or hanging on to the back of some delivery truck. She chose the truck. The bus broke through the ice and disappeared under the water.

It's strange to realize how close one can be to not being "here" and how history weaves its way through your blood and ends up on the front page of hackernews.

I would like to invite the audience to remember how many similar stories are being played out in the present day.

https://qntm.org/lena

Finally, if everyone just leaves their jobs without trying to improve them, won't everyone run out of places to jump to eventually?