In recent discussions with some developers the topic of determinism surfaced. This idea did already surface before: Some developers are not using AI, because AI results are not deterministic.
But non-determinism is something we already live with.
If I give a problem - as a manager or fellow developer - to different developers, I different results.
If I give a problem to the same developer after six months, I get a different result.
The reason non-determinism is evident in AI, but not with developers, is that AI is faster than developers writing code, so it’s clearer to see. We let AI write the same code twice or three times - no one pays developers to write the exact same code 10x.
The second reason developers do not like non-determinism in AI is they live in delusion about determinism. Their belief that compilers are deterministic is delusional. A JIT compiler generates code depending on the hot path driven by user actions - which are non-deterministic. The same happens when a compiler is deterministic but in a different way than developers think. Developers think they know what code is generated, but they don’t. A compiler translates a double loop or a stream into just one SIMD instruction - they think they know what code the compiler generates, but they don’t - so their trust in the compiler is for the wrong reasons. And even if compilers would be fully deterministic, and people would know the code they generate, compilers are so complex that determinism is not useful for verification - just because ‘someone’ looks at compiler output does not mean it’s correct.
Then there is always undefined behavior for example in C - no deterministic by definition :-)
Developers do not really want determinism - this is just a scapegoat against AI.
What we want is correctness, not determinism.
For correctness we want trust, not determinism.
We trust someone, because there will be no surprise with the person. They do what they told us they would do. Their results are not wild but within normal parameters. Their results work. Developers trust compilers for the same reason we trust people. They are predictable, mostly don’t have wild results and we trust the results as ‘correct’.
Over time AIs will gain the trust of developers. By creating less and less surprises and the results being more and more within normal parameters, people will trust AIs more and more. And will look at code less and less. When I migrated from assembler to C during the 80s - and I felt I was an assembler god (don’t all teenagers overestimate their skills?) and knew all the optimizations you could do with 68000 machine code, I did look at C compiler output and the compiler wasn’t as good as me! - but it was predictable and ok - and the productivity gains and easier maintenance didn’t make me look back.
The non-determinism will no longer be a problem because of increasing trust.