I could as easily pick apart your arguments. I find it hard to imagine never using code that is shared with other projects for example. Why re-invent the wheel? Are you declaring code re-use dead? What about the system libraries? Do you hack those without notice too?
You could move the goalposts like that. I explicitly didn't respond because that is trying to derail the conversation.
But what the hell. You've stopped actually responding to the points I make.
So, I would contend that code reuse is helped, not hampered, by compiler-verified interfaces. I would contend that your "code reuse" is so stifling that it is literally inferior to copy-and-pasting... at least with copy-and-pasted code you can improve the module you copied without worrying that it breaks things.
And what happened to unit testing where you should easily enough shake out cases where people called a function they shouldn't have?
Why do you want to re-invent the wheel. Now, unit testing is good, but using unit testing to re implement (imperfectly) interfaces is, well, crazy.
I have argued that the programmer who just takes the IDE's word for it will eventually end up in deep trouble.
No, you've argued that programmers are perfect, that the comments will always be accurate, functions you call will never change, and the comments always need to be read for every getter and setter. And that's just to reject my examples.
And I categorically reject any of the above.
You seem to be arguing that duck typing is bad because shoddy practices rule.
Since the only example you have been able to give as to why duck-typing has any benefit, is as a patch to shoddy use of interfaces, this seems a remarkably dumb statement. I contend that duck-typing hurts the ability of the computer to detect errors, and your only response is that some people didn't properly use interfaces in legacy code. Not that interfaces are somehow a bad way to program. But a shoddy programmer may not have used them.
Well, fuck that. A paradigm that gives up useful features to paper-over shitty work, or allows code reuse between kinda existent modules via unspecified hack code that works 95% of the time is bad. Heck, any code that would need to be papered over like you suggest probably shouldn't be trusted. Duck typing is bad, it encourages bad practices and bad coding, and allows bad programmers to continue programming with silent errors as opposed to either fixing their shit or quitting their job and flipping burgers.