I'm a bit surprised at the vitriol here for even just type hints, much less even static typing. I'll admit that static typing is probably more pain than most python devs are willing to pay, but I will die on the hill of type hints being an essential contribution to the language that vastly improves its capabilities.

But don't take it from me, take it from the people who wrote urllib3 [1], who insist that typing is even more powerful than unit tests--and they're the developers of a wildly popular library. "People are making it harder to develop without [type hints]" you say, completely ignoring the productivity boon that the type hints have provided to many other people. (I'm also not clear on how the existence of type hints makes it harder to develop without them.)

In my personal experience, adding type hints and enforcement to our code has eliminated entire classes of runtime errors, and I find that developing with them makes my life significantly easier. I'll admit some of that may be because dev tools are leaning on the hints, but I ask what's the alternative? You can't static-analysis your way to a definitive type in a dynamic language.

I'll try to respond point by point:

> I don't want ugly rust-like typing. [...] It looks horrible in Python.

You don't want a feature because... it looks bad? I could understand if it's "confusing" or "unclear syntax" or "makes it harder to read", but just "ugly" I have trouble both believing and understanding.

> 2. Requires additional knowledge to implement correct type hints. [...] It is even getting hard to track the changes without including typing.

I'll admit I'm not certain what you mean here. Typing is an optional feature, you don't have to use it in your own code. I would also personally expect that knowing the types of the things you're working with (e.g. via hints) would make it easier to hint your own code--but again, that's even optional to do.

I'm not sure what you mean by 'tracking the changes'--Could you elaborate on that?

> 3. It encourages bikeshedding on features useless to the core language.

I'll grant that adding typing to python opens up a whole new class of things for people to grouse about in mailing lists and on forums, and could even be pulling effort away from the core libs: but, python being an open-source open-contribution system, I'm amused that you're taking issue with people who're taking time and effort to contribute to the language simply because they aren't contributing in the way that you want. Sure, it's reasonable for the community to provide feedback to the creators,

There's also the obvious comparison to Typescript, which is widely heralded as a massive improvement to Javascript--or at least enough of an improvement to have drunk who knows how many billions of dollars in developer-effort from Facebook and Microsoft because it's so much of a force-multiplier. While python shouldn't blindly follow other languages for the hell of it, I do think it's paramount to sticking ones head in the sand to ignore the transition of the Javascript ecosystem, absolutely THE largest dynamically-typed language, to a statically-typed variant.

> 4. It creates a rift in the language.

This, I'll grant: if we moved to a fully static python, there'd likely be massive compatability issues throughout the ecosystem as library A adopted static types, but not library B. We already have some of this (as people note in other HN threads [2], though they're definitely in the minority) as you pile on libraries with just type hinting, but it is improving as type hints become more and more popular.

> 5. It affects startup performance

I'm assuming this is about static typing; type hints themselves have negligible performance impact. Or at least, in my experience they've been totally negligible (compared to just loading large untyped libraries), and I'd love to see if you have examples to the contrary. There's plenty of ways for static typing to be done without impacting startup performance, or indeed for static typing to be a performance GAIN (as there's classes of issues the VM won't have to handle, or we can emit more efficient bytecode, etc etc--see also, optimizing compilers).

----

Overall, I think you make a lot of claims that require some amount of evidence to back up, especially when there's so many examples of type hints being an absolute boon to people, both individual developers and maintainers of popular libraries. "Useless typing PEPs" and "Manpower is wasted on something the majority of Python developers and applications don't really benefit from" and even citing type hints as adding complexity to newbies when it's a completely optional feature? I can't bring myself to believe these claims in the face of the community's counter points and my massive opposed experience.

Type hints in python are a joy for me, coming from Rust and Swift and C++ and Typescript. I can remember when python was hell because you'd get hours into a run of a program and then the whole damn thing would come down because of a mismatched type. Having that extra bit of static analysis to ensure things worked properly is wonderful. The very first thing I did in my new role at my current company was to progressively typehint things and slowly fix the mypy errors, which led to 50% reduction in error rate in the application and, eventually, a speed increase in the order of three magnitudes. None of that would be possible if I didn't have type hinting.

And, yes, your original premise is around static typing, I know, but you expend considerable electronic ink against the hints as well, and one begets the other.

Overall, your points read more like resisting change for the sake of resisting change than substantive issues with the system.

[1]: https://sethmlarson.dev/blog/tests-arent-enough-case-study-a...

[2]: https://news.ycombinator.com/item?id=26530381 (but also check the whole parent discussion)