They're especially useful when you are writing libraries for use by somebody else.

I'd do the same thing in most languages - in fact, I'd end up doing way way way more of it in C because it's very weakly typed.

I think type theorists would disagree.

> Placing a small number of sanity checks on border code is not any kind of argument for static typing.

Yes it is if any of those checks are for types.

> I'd do the same thing in most languages - in fact, I'd end up doing way way way more of it in C because it's very weakly typed.

C doesn't have type checks, unless you're using some runtime type system (like GObject) on top of it. At any rate, C may not be completely type safe, but it's better than dynamic languages which are completely type unsafe; even if you could do type assertions, you would do them far less frequently in C than, say, Python. Further, C is not the canonical statically typed language, and you would be laughed out your workplace if you proposed adding a runtime type check on your function parameters.

Even if you're using Python (assuming you have the good fortune to use a modern version), you can just use type annotations and the static type checker rather than littering the code and slowing your program. Albeit your point stands about writing library code for another's consumption.

And worse than dynamic languages which have greater type-safety. Point being that it's type safety, not static typing that helps cut down on the need for sanity checking.

>you can just use type annotations

Type annotations are both unchecked and render any code that you write unusable in python 2.

>rather than littering the code

Type annotations DO litter the code.

I think you're confusing strong typing with type safety. Strong typing doesn't preclude errors; you just don't see the error until you hit the code, which might be all the time for a happy path, or almost never for an error path. Static typing, on the other hand, completely eliminates the need for sanity type checks (and depending on your language's notion of 'type' this can include virtually all forms of sanity checks).

> Type annotations are both unchecked and render any code that you write unusable in python 2

Static type checking is supported for both Python 2 and 3. If you need to write Python 2/3, you could probably just use the Python 2 annotations.

> Type annotations DO litter the code.

They don't. They're a small annotation that tells you what the variable actually is/does. Much neater than Sphinx docs, etc. And you do need to know the type, whether you like it or not.

Check the wikipedia page for strong typing. Type safety is one of the ~11 or so different definitions. It's one reason I try to avoid using the term - because it's more emotional than meaningful.

>Static typing, on the other hand, completely eliminates the need for sanity type checks

You've not programmed in C have you?