These two arguments contradict each other and together are an argument for static typing, not against. Which just shows how weak these arguments are.

The way I read it, he wasn’t suggesting that was a good argument at all. He was just explaining what he believes dynamic type enthusiasts say.

This bit I am not convinced by. Inferring the API of a function from its body makes it harder to see breaking changes when you refactor the body. It can be useful for internal private helpers, but IMO public APIs should be explicit about their signature.

Well, in F# at least, this inference is the default. However, anybody can still fully type out the function signature. I think I get what you are saying, but in the case of a public API or interfaces the programmer can simply just add the type specifications.

I would go one step further here. It should support OOP and procedural paradigms as well.

Yea I somewhat agree with this. Though I mostly abhor OOP, it taken in small doses can be good. And procedural programming is always invaluable of course.

My current main is Thunder. Like all the rest it also has bugs, but none of them are particularly bad and the GUI is super slick.

I literally can’t hear some words occasionally in newer shows. I don’t need them for older shows though.

That leg better have they own wallet. Ain’t paying for two amberlamps.