> I'm at a total loss for why I really care about this major part of their message (type safety).
Honestly, you might not care about type safety. It depends a lot on the kinds of programs you write.
In general, a language with a good type system[1] brings several major advantages to the table:
1. If your program compiles, there's typically a 90% chance it will work correctly on the first try, even if you just changed hundreds of lines of code.
2. Big refactorings are much less stressful.
3. Emacs or Visual Studio Code (for example) can provide pop-up completions of names and methods.
4. Problems like mysterious nulls or data races can be prevented almost entirely at compile time.
One big downside is that it gets harder to do certain kinds of (runtime) metaprogramming and you need to use macros to get similar effects.
At this point, having worked professionally with Rust, I would recommend Rust to people who are really enthusiastic about the above benefits. But if you look at that list and say, "Meh, not worth it," then you might not want to adopt a younger language like Rust. Well, unless you need to get reasonably close to the metal without sacrificing safety, which is where Rust really shines. I just wrote a fast CSV sanitizer in Rust for processing gigabytes of input, and the compiler caught a subtle memory error when one CSV line spanned two buffer reads.
[1] For the sake of argument, a "good" type system in this context includes the ability to define custom collections with type parameters, it only allows NULL to appear where explicitly permitted, and it supports tagged unions with a nice "match" construct. This seems to be roughly the minimum feature set to get the full effect described above. Examples include Haskell, Elm, Rust, ML and (to a surprising extent) TypeScript.
Honestly, you might not care about type safety. It depends a lot on the kinds of programs you write.
In general, a language with a good type system[1] brings several major advantages to the table:
1. If your program compiles, there's typically a 90% chance it will work correctly on the first try, even if you just changed hundreds of lines of code.
2. Big refactorings are much less stressful.
3. Emacs or Visual Studio Code (for example) can provide pop-up completions of names and methods.
4. Problems like mysterious nulls or data races can be prevented almost entirely at compile time.
One big downside is that it gets harder to do certain kinds of (runtime) metaprogramming and you need to use macros to get similar effects.
At this point, having worked professionally with Rust, I would recommend Rust to people who are really enthusiastic about the above benefits. But if you look at that list and say, "Meh, not worth it," then you might not want to adopt a younger language like Rust. Well, unless you need to get reasonably close to the metal without sacrificing safety, which is where Rust really shines. I just wrote a fast CSV sanitizer in Rust for processing gigabytes of input, and the compiler caught a subtle memory error when one CSV line spanned two buffer reads.
[1] For the sake of argument, a "good" type system in this context includes the ability to define custom collections with type parameters, it only allows NULL to appear where explicitly permitted, and it supports tagged unions with a nice "match" construct. This seems to be roughly the minimum feature set to get the full effect described above. Examples include Haskell, Elm, Rust, ML and (to a surprising extent) TypeScript.