To explain… I have a constants that I declared:

const TWO_32 = 0x100000000;
const INT_MASK = 0xFFFFFFFF;

With that in mind, I was about to port this Java code (which I’m sure that copilot has already seen and analyzed):

boolean carry = (sum >>> 32 != 0);
while (xIndex > 0 && carry)
    carry = ((result[--xIndex] = x[xIndex] + 1) == 0);

var carry = (sum >= TWO_32);
while (xIndex > 0 && carry) {
    sum = unsignedLonger(x[--xIndex]) + 1;
    result[xIndex] = sum & INT_MASK;
    carry = (sum >= TWO_32);
}

This is entirely correct. But I had to check it carefully, because… what the hell!

I think this is a simpler version of the github's mechanism: https://en.akinator.com/ https://www.youtube.com/results?search_query=akinator

That's neat. My feeling right now though is how often can it be wrong, and does it take me longer to validate it isn't wrong, or to just do it from scratch myself?

Like when you say you had to check it carefully, did that take you more time than it would have to convert it yourself?

It's code without tests. This is why it took time. I think it should be the same as reading a function written by another person and without tests.

It does take me longer to check it, and sometimes it’s wrong. Worse, sometimes it’s subtly wrong. But I’m amazed at when it gets it right

> I think it should be the same as reading a function written by another person and without tests. That often takes me longer then writing it myself haha

I guess maybe it would work really well in a TDD workflow though, since you'd write your tests first, then auto-complete the full implementation if possible and just see if it passes your tests

I can already imagine having a seed for the generator and then only writing tests. And having a source directory which you can't ever edit... And for mutation testing... you only change the seed xD

That would kind of be crazy, in the future, programmers only write tests lol, Copilot writes all the implementation for you