Generally I prefer a challenge to be specified in terms of its output, rather than its internal workings. So "the output must meet these criteria" rather than "you must use this algorithm". It is easy to verify that the output is correct, whereas it is difficult to prove that a particular algorithm is being used (code can be misleading even before it is golfed).

For the same reason, I am wary of allowing a non-halting program, as the quality of being non-halting is not in general measurable.

I don't feel so strongly that I would want to prevent a challenge author from allowing this in a specific challenge, but I feel uncomfortable with it being allowed by default.

Part of the appeal of code golf is that it is easy for anyone to verify that the code works correctly, and everyone can agree on the score. Introducing a time limit means that the code could be considered non-halting on one machine but not on another.

I agree.

Changed the suggestion and now use always a limited runtime which measurable.

The time limit is a big part of my concern. Everyone can agree on how many bytes there are, but different computers will have different speeds and therefore different outputs if based on run duration.

The point is that there is large factor between both, so it easy to test, even on different computers. Automatically: Run it once where you know the the runtime will be fast, measure it, multiply it by 4. Use this time as a limit, if it stops before you know it had a fast runtime if not, it had a long one. For a human it is easy to tell the difference, so manual testing shouldn't be a problem.

It would allow some solutions where in one case the program ends in a few ms and in the other it runs infinitely long. This can make code smaller and is very easy to test.

It's tempting to think that multiplying by 4 would always be enough, but in general the duration on one computer will not scale linearly to the duration on another computer. For different code the scaling factor will be different (even for different solutions to the same challenge).

I agree it could work well for some solutions to some challenges. For this reason I'd like to see it permitted but only if specified by the challenge author. I wouldn't want this to be a default as it puts a burden on challenge authors who haven't chosen it.

Is there a requirement that the author can test it? Many solution are platform specific and i don't think most authors have all the platforms, interpreters and compilers a solution can use.

That's a good point. Currently the only restriction I can find is against non-free languages, and that only applies to one challenge type (so not to code golf):

• How free is "free" for cops and robbers?

This doesn't change my opinion (I would still prefer output by run duration / non-halting to not be a default) but it does weaken my argument.