Even the maintainability argument is suspect I think: Static type systems as commonly used are not very powerful compared with schema validation style approaches used in the dynamic languages world (eg malli or spec in Clojure world). Static types lose in expressiveness, flexibility of when & where they are enforced, and ability to pass around the data shape specifications as data.

edit: and tangentially, the building and iterating lifecycle phase is of course usually the make-or-break bottleneck - maintenance phase sw engineering is comparatively a "happy problem".

That's true, and Clojure (when used with metosin/malli) is probably the only reasonable alternative to statically typed programming languages in terms of long-term maintainability.

Essentially, it's like two completely different reasoning models: inside-the-box (ALGOL / SQL), and outside-the-box (LISP / Datalog).

The first model (ALGOL / SQL) is about designing for machines to better understand, and the second model (LISP / Datalog) is about designing for humans to better understand.

I think that the main issue with dynamically typed programming languages is the lack of robust enforcement.

I believe it is a lost fight, but why have Rust and Go become a collocation?! It’s as faulty as C++ and JS.

Go becomes an answer when one is willing to trade the correctness of Rust for a garbage collector and a bullet-proof standard library.

So does Java, C#, D, Nim, Haskell, OCaml, and a litany of other languages.

Rust and Go were designed with concurrency and portability in mind – unlike Java (which requires the JVM), C#, D, Nim, Haskell, or OCaml.

Java literally has a synchronized keyword and it literally runs on your SIM/bank card, was originally created for DVD players, and runs on every major OS. Plus it used to have 20 years ago as well, but has right now also ways to produce a single native binary.

Rust is a low-level language, quite similar in the target niches to C++, while Go is a managed language with a barely-optimizing compiler for fast compile times, and a GC that prioritizes latency over throughput. They are nothing alike.

Rust and Go are very much alike, when Java is not an option because of the JVM startup time and memory requirements (GraalVM Native Image solves this, but at the expense of highly reduced performance).

I'm not sure what your use case is that only rust and gonare options, but is unusual.

NIM supports concurrency and is as portable as the c and js it can generate to.

C#/F# work on x86 and arm which covers most targets today. And supports concurrency. And is situationally more performant than go.

I can't speak to the other languages mentioned, but they all seem quite similar to go as well, except for haskell.

Rust is more like c, c++, zig, ada etc.

I see Rust and Go as the best high-performance high-concurrency programming languages today, and choose between Rust and Go depending on the bottleneck (Rust – CPU / RAM, Go – I/O).

GraalVM native might have worse performance than the same application running on the JVM, but highly reduced is a scratch.

And sure, just as alike as Rust and D, Haskell, OCaml - they all produce a native binary with in-built GC, just like Go.