I really don't understand why so many people are trying to push Nix when it has fundamental flaws which are not being addressed.

I've done a cursory read of the paper, but because it was in a foreign language I wasn't able to grok enough of it to see how they actually addressed my issue.

The issue comes down to computability which is a part of the Fundamental Theory of Computation. If you look at Nix, yes the language is functional but how does it operate, simply put it uses Galois fields (hashes of the dependency build graph). The important part of that is Galois fields have properties like the fact they are never unique.

Computers are basically turing machines, they operate on state. Certain properties must be true for them to do work. Aside from the mathematical properties of discrete steps, and time invariance, you need determinism.

They are state machines, they perform operations on state, and one of those properties is determinism, but how do you define determinism.

It comes down to state graphs, each edge can only have one possible next-state, if that isn't true and the same state varies between two next paths, you get non-deterministic behavior. You then either run into undefined behaviors which can include all behavior such as filesystem corruption, etc, and you can't test for it because of the halting problem, or the software (due to exception handling) halts.

So what happens when you have a Galois field being the unique identifier, and someone finds a collision. That property computers need no longer holds true. How does it know which one is correct, is it a security issue?, does it silently install the wrong things? How do you troubleshoot when troubleshooting requires those properties to be present (and they aren't).

These are all questions which I have not had a satisfactory answer from anyone involved in the project and I've asked a couple times in the IRC. They jump down into the details (limiting scope to just the language) but completely ignore the fact that the uniqueness isn't present. So why should anyone go and use that functional language (learn it, spend time packaging for it, etc), when it will fail at some point, the failure will not be troubleshootable, because the flaw has not been addressed.

I don't see why they received a PHD for that work given that anyone who has been through a Compiler Design class or a Systems and Signals course at the undergraduate level should know this stuff.