Funny how tools are useful. But a person who is a tool is not.

Exactly. And what is the best tool? The best tool for the job

So, lisp?

Sometimes I just want to use a particular tool, and care less what I'm making with it.

I rarely get this pleasure at work.

I despise python syntax.

Almost any language is ok but some ecosystems make me want to turn into a murder hobo (looking at you, JavaScript).

Hard disagree. Super beautiful.

what? what part of rust is ugly?

FORTRAN isn't a beauty either.
And Python is strange as hell with its mandatory tabs.

I can actually see where this is coming from, as I found Rust hard to read when I started out. I do really like Rust for reference, but I do agree Rust is hard to read for someone that has not learned it.

For example:

return statements that are implicit just because the semicolon isn't there. Even better if they occur inside a if block or something like that. Very hard to understanding when you don't know the syntax rules.

Lambda functions, especially when using move semantics too. They are quite simple, but if you don't know the meaning, it's more arcane characters. Especially when this is used inside lots of chained methods, and maybe a multi-line function in the lambda.

A lot for the if let x =... type of stataments are tough the first time around. Same for match statements.

Defining types for use with function::() and such.

Lifetimes, especially when they are all named a, b, c etc. It quickly gets messy, especially when combined with generics or explicitly defined types.

Macros, though not entry level rust to begin with, they are really cumbersome to decode.

None of these are sins of Rust, but for new people they are a hill to climb, and often hard to just "get" based on previous programming experience and reading the code. Rust can be really hard to approach because of these things. This happens in other languages too, but I do feel Rust has a particularly large amount of new concepts or ways to do something. And this is on top of learning lifetimes and borrow semantics.

One of the reasons i find it so hard to use non-Rust languages is how ugly they typically are by comparison. "fn" instead of "function" is such a great example of saving key presses where they're most needed. And you get very used to seeing compact abbreviations. Idk if that's what you're talking about though.

Go look at that Lisp kojumbo then tell me Rust is ugly.

(defmethod wake ((object magic-packet) address port)
  (let* ((payload (encode-payload object))
         (size (length payload))
         (socket (usocket:socket-connect nil nil :protocol :datagram :element-type '(unsigned-byte 8))))
    (setf (usocket:socket-option socket :broadcast) t)
    (usocket:socket-send socket payload size :host address :port port)
    (usocket:socket-close socket)))

Actually unreadable.

It mostly reflects my own story. From a beginner enthusiast of multiple "cool" languages (Scala was all the rage back then), through considering myself more "mature" and thinking about business priorities, ending at understanding that using a good programing language is a business priority.

If the team works with a language they enjoy, they will be happier (and more productive). Doesn't even matter if the code is written by humans or machines.