I was thinking the same from the root of this argument: "redundant encoding" isn't a way to automatically fix errors, but rather only a way to detect errors. Like a one-bit Error Correcting Code: the fact that the parity bit is wrong tells you something is corrupt, but it doesn't let you know what the right value should be. There's one useful thing you can avoid doing in response to such an error being detected: not rely blindly on either the implementation or the specification being correct, but instead check them both.

Fully agreed. That's why I consider descriptive identifiers a valuable hint.

Even if the product has been running flawlessly in production for 5+ years?

"Proven in use" and backwards compatibility is a bitch.

Well, if it's a library function like printLine and it does something else instead of printing to the console, that's probably a mistake (though if it does something so wildly different it cannot be simply a bug, for example logging to a file, I'd still wonder if the name is wrong). The problem is that you can't generalize this reasoning. For example:

  def sumAllNumbers(nums: List[Int]): Int = {
    nums.filter(_ % 2 == 0).sum
  }

Is the function name wrong or is the implementation? We can't tell without looking at how the function is used, and maybe not even then! Maybe we have to ask the person who made the last change. Maybe they changed the implementation for a valid reason and forgot to change the name. It happens!

So the name definitely helps, but it's not conclusive.

It's a bit more than that. Function names are precisely encapsulation of the intent of the function. And unlike comments, function names are not subject to rot.

Also addresses are not like names. As with names in general, a name can refer to more than one object. (Consider modules, for example.)