/**
 * foobar(a, b)
 * foos up a with b.
 * Note: this should never work. Fooing is impossible, and the fact that this function achieves it serves only to prove God has a wicked sense of humor.
 */

That's the final invisible panel. Code that definitely won't compile, does compile, and tests all pass.

When I first code something up, I think of it as a first draft, and I expect maybe 5ish typos / brainos per 100 lines. Only a few times in my life have I finished writing a few hundred lines of code, tried to compile / run it, and not seen at least a few errors.

When I don't see errors, it's almost always because somehow I managed to not compile / run the code at all. Like, one of my typos / brainos managed to cause it to skip that entire new block of code. Only once or twice has it happened because I actually wrote error-free code the first time. And, let me tell you, that perfect code sucked up so much more time than the more typical bad code.

With the bad code, I see the various errors, quickly fix them, and those errors convince me that the compiler / interpreter has actually seen all the new stuff and judged it. But, with perfect-from-the-start code, I now have to go in and throw in print statements, or step through a debugger to convince myself that yes, the system actually made it into that function and actually did execute those statements.

It must be cosmic rays, a bit flipped while compiling. No way I got it right the first time.

WTF! How does that even work?

What does the compiler do when there are 5 implementations for the same name, and none fit the type system?