Ask HN: Why are all of the best back end web frameworks dynamically typed?

You probably already know but you can add type hints and then check for consistency with https://github.com/python/mypy in python.

Modern Python with things like https://learnpython.com/blog/python-match-case-statement/ + mypy + Ruff for linting https://github.com/astral-sh/ruff can get pretty good results.

I found typed dataclasses (https://docs.python.org/3/library/dataclasses.html) in python using mypy to give me really high confidence when building data representations.

And there's https://pypi.org/project/django-stubs/ for working with Django.

Dynamic typing allows more dirty code, in the same way static typing allows for massive inheritance hell with factories and polymorphism.

You can write clean Python without much fuss that is easy and simple to read.

What kind of business-relevant change are you referring to here?

I don't think the compiler with the error messages makes a difference when the business is pivoting between features, when they ask to add a new field to various forms, to generate new reports or add new emails in various points of the work flow. Or change the emails from one point to another point. Or add password less. Or just switch the external provider of an API from an important flow because there is a better deal elsewhere.

I am not saying static typing does not provide speed or flexibility, but I just wanted to say that business-relevant change has more to do with features than code.

Thats the "academic" advantage of static typing.

In practice, it essentially leads to one of 2 things

1. Any time you have to make a change for a prototype, you have to go change a whole bunch of dependencies on your library, even if the change is not used in those explicitly, all because of the prototype.

2. You start introducing dependency hell or duplicate code, to either abstract stuff away so you don't have to do the prototype changes, or you start writing duplicate classes/functions to handle different parameters.

Neither of which is either fast or flexible. Anyone who has worked at Amazon dealing with Java services can attest to this.

Dynamic typing on the other hand is actually flexible and fast. For example in Python when building out something that is changing quite often, its very easy to pass around dict objects.

And yes, dynamic typing, it can lead to more errors, but in practice, most all of these are caught during testing, and are just as straightforward to fix as compiler errors. If you try to access a dict field that is not in the passed dict, its pretty much equivalent to a compiler error.

That's not spring though, that's poor developers

Off the top of my head and non-exhaustive? Not a fan of the lack of real controllers and the way the endpoints are defined, especially when it comes to class based views, mixins, etc; and, while, the ORM is mostly good and useful, I think it has a couple features (like through fields) that obscure too much what is actually happening at the DB level.

I suspect that if I really sat down and tried to more thoroughly write my thoughts on the subject, a lot the things that annoy me with it may just apply to dynamically typed languages in general (and sometimes just Python in general).