It didn’t take me long to prefer this syntax to that of Java, C, C++, etc.
How about we consider the normal case (where you write out the types):
int num_entries = ..
float div = ..
float result = num_entries // div
vs num_entries: int = ..
div: float = ..
result: float = num_entries // div
Because they are on the right, they aren't aligned which makes it harder to parse (imo). It gets even worse with more complicated types (lists etc).let foo = Bar();
Anyway, these are all subjective perspectives, but I was personally won over to them, especially as I started using type inference more often.
[citation needed]
The way Nim, Rust, etc do it, with a useless 'var' keyword even when a type is present, is clearly needlessly verbose (ie, inferior, though I'd hesitate to say vastly), but I'd be interested to see a analysis of the merits of something like "Foo[2] foo = bar()" vs "foo Foo[2] = bar()" (or maybe that should be "foo [2]Foo = bar()"?), since it hadn't actually occurred to me to use the latter order seperate from the useless keyword.
I'm not a fan of Nim because types go after the variable. But the fact that you did not consider that you may have messed something up and just thought "yeah totally, a language built to compete with C++ is slower than python", really discredits your entire post.