[haolez]

I've started with static languages and I prefer dynamic ones over static. Code is a liability and static typing can create incentives for adding more and more boilerplate that brings little value to the table.

I'm preferring dynamic languages and lots of tracing and rollback capabilities in production in 2021.

[brundolf]

I've found this to be a common mindset among people who started out with Java/C#/C++/etc.

Modern statically-typed languages are a totally different beast. Type inference is widespread and powerful, and you end up writing very little additional boilerplate. On top of that, guarantees like the prevention of null values greatly increase the value you get from having static types.

If you haven't tried one in a few years, I recommend revisiting them. TypeScript is a great place to start.

PS: It's totally possible, but also totally unnecessary, to write TypeScript like you would Java or C# (lots of classes, nullable-everything, explicit types for everything). To get the most out of it you honestly have to do the exact opposite of that (turn on strict null checks, use plain types, leverage type inference as much as possible).

[haolez]

My last experience was with Go. Awesome language. I use it when I need extraordinary performance. For everything else, it's Python or vanilla JavaScript.

[arcanon]

If only there was some project that was a go webserver with a client that was like some sort of python/javascript hybrid…

[IshKebab]

Even "old" statically typed languages like Java and C++ are streets better than dynamically typed languages like Python (without type hints).

I don't think people have that view because they haven't experienced modern static typing systems. I think they have that view because they aren't willing to admit that they make the kinds of mistakes that static types help with, and they aren't willing to admit that they benefit from the kinds of assistance that static types provide (autocomplete, go to definition, etc.).

It's annoying.

[haolez]

I get autocomplete and goto definition with dynamic languages just fine. And I make mistakes that static typing could have helped, but then again they are not frequent enough to justify the bureaucracy (and they don't break production).

Of course, there is no general rule. This is true for the type of projects that I've been recently working on, which are small-scale distributed web systems.

If a new project demands a rigorous type system, I would probably go to something like PureScript[0] before going to C# clones like TypeScript. It seems that the compiler would help me a lot more in a language like that.

[0]https://www.purescript.org/

[IshKebab]

> I get autocomplete and goto definition with dynamic languages just fine.

No you don't. See how autocomplete does with this function:

    def foo(s):
        s.

Now try it with type annotations:

    def foo(s: str):
        s.