[ReflectedImage]

A signature of a function is very different from it's implementation.

"That's just laughably false. There is zero empirical evidence supporting this claim."

There is a reason all the startups are using Python. Just ask Eve Online or Discord. Dynamic typing is great for getting products to market fast.

Neither of them have problems with too many bugs. What you are saying doesn't even make sense, since you would just increase your QA budget if it increased the rate of bugs. So how in earth could the end user see more bugs?

Dynamic typing has an issue but that issue is code performance. Eve Online gets slow downs during massive battles and Discord rewrote parts of their interface in Rust to save on server costs.

[naasking]

> There is a reason all the startups are using Python.

Show the evidence that "all the startups" are using Python.

[ReflectedImage]

Why don't you go argue with an empirical study on the topic instead of me?

https://games.greggman.com/game/dynamic-typing-static-typing...

Because all the studies say that dynamic typing reduces development time without increasing the number of bugs.

[naasking]

> Because all the studies say that dynamic typing reduces development time without increasing the number of bugs.

This is literally false, which you can clearly see if you'd bothered to actually check the references cited in that article that links to this review:

https://danluu.com/empirical-pl/

Numerous studies demonstrate that static typing had little effect on development time, if the typed language was expressive, but did have noticeable effects on the quality of results and the maintainability of the system. The more advanced and expressive the type, as with Haskell and Scala, the better the outcome, but all studies done so far have flaws.

As for the specific data discussed in that article, here's what that review had to say:

    The speaker used data from Github to determine that approximately 2.7% of Python bugs are type errors. Python's TypeError, AttributeError, and NameError were classified as type errors. The speaker rounded 2.7% down to 2% and claimed that 2% of errors were type related. The speaker mentioned that on a commercial codebase he worked with, 1% of errors were type related, but that could be rounded down from anything less than 2%. The speaker mentioned looking at the equivalent errors in Ruby, Clojure, and other dynamic languages, but didn't present any data on those other languages.
    This data might be good but it's impossible to tell because there isn't enough information about the methodology. Something this has going for is that the number is in the right ballpark, compared to the made up number we got when compared the bug rate from Code Complete to the number of bugs found by Farrer. Possibly interesting, but thin.

In other words, this "evidence" you cited is a clearly biased anecdote, nothing more. I also recommend reading the HN comments also linked, where former Python programmers describe why scaling dynamic typing to large codebases is problematic.

In the end, my originally stated position on this stands: you have literally no empirical evidence to justify the claims you've made in this thread.