My mood when reading the PEPs is of excitement.

While I'm not too keen on hardcore feature divergences, most of the new features have been really nice things to have, and which are never imposed. (E.g. the walrus operator, type hints, dataclasses, etc). I don't see the need to be so outright hostile to changes, unless they were clearly breaking features.

> "and which are never imposed"

I'm not sure about that part. Even if one personally ignores something new, someone else within the same project or a dependency will employ the new shiny, and invent one or a couple more ways of doing the same thing in a different way.

That means if it's in the language, you'll have to account for it. Not saying Python is, but given enough new features a language may become a kitchen sink of ideas over time.

--

(At the risk of contradicting myself a bit here, I actually agree with the features you mentioned here are all nice to have, and I like using them. IDK if nice to have is a high enough barrier to clear though.)

Industries change, needs change, new possibilities emerge. A language that doesn't change is probably either dead, dying, or headed for a tiny niche. Python changes a lot because lots of people use it and have needs and desires for it. Clojure is used very little, so doesn't have the same kind of demand for improvement or community to do it (I don't for a moment believe it couldn't be improved).

"A language that doesn't change is probably either dead, dying, or headed for a tiny niche"

Or complete. Eternal change is not a value in itself.

Right, but I think any language that is "complete" is either dead, dying, or headed for a tiny niche (or already in a tiny niche). Can you think of any counterexamples?

The vast majority of languages are dead, dying or headed for a tiny niche. How many languages can you name that aren't? There can only be at most 3 languages with more than 25% market share.

Even Python is likely to die; in time. Most things do. Something will have to change first, at the moment it is doing great.

You seem to be arguing against something I didn't say. All I'm saying is that change is a sign of life, and that non-change is a sign of the opposite.

Go ye unto your tool shed, examine your spanner for signs of life, and you will have the possibility of gaining enlightenment - for you are correct in your argument.

C.

C is changing (C99, C11, C17, C2x). It is also increasingly relegated to niches like embedded and systems, though there's still a lot of other use.

Web development as well, as it turns out (compile to wasm).

Nothing is ever truly complete. Especially mediums of communication and construction, such as a programming language.

Don’t lisps (or lisp-likes) push language feature creation into user space? And also with Clojure piggying on the JVM, I would be shocked if it needed continuous updates.

Heavily generalizing of course, but:

Only in so far as the user actually _can_ make those changes, if deemed necessary or elegant using macro facilities. Once something has proven itself good enough to be part of the language standard, there is nothing limiting language maintainers/creators to take it into the standard and ship with next release. So it is strictly more flexible in that way and users do not have to wait on commitees.

Python does too, to a limited extent. A good example is type annotations. You don't _have_ to use type annotations, but you can enforce it in your project by writing a typechecker or a preprocessor; and there's a subset of python that can be compiled statically.

And the Clojure example imho is a bit of a red herring, because while it allows a lot of flexibility (reader macros in Clojure are very powerful), they don't encourage ecosystem divergence, since Clojure can use JVM/Java for "Batteries" and most standard libraries. Cljs is more similar in that way, because it carries much of javascript's divergence with it.