127 karma · joined June 27, 2023
Unauthorized copying (aka pirating) is definitely a copyright violation.
That appears to be a huge problem with the large models and training. They don't secure legal access to the materials they train on, and thus fail to compensate authors for their work.
AKA students are required to buy or otherwise obtain legal access to their text books(like checking the book out of the library).
Training AI should play the same rules humans students have to follow.
There are companies and bosses that know how to value employees contributions. I have heard it referred to as herding cats.
There are situations that are not good. Sometimes it is intentional when they have decided they want someone out. Sometimes the boss as you say only wants as yes man. Sometimes there are good intentions and without the needed skill.
To get to memory safety with C:
- Add support for array bounds checking. Ideally with the compiler doing the heavy lifting and providing to itself that most runtime bounds checks are unnecessary.
- Implement trivial dependent types so the compiler can know about the array size field that is passed next to a pointer. AKA
void do_something(size_t size, entry_t ptr[size]);
- Enforce the restrict keyword. This is actually the tricky bit. I have some ideas for a language that is not C, but making it backwards compatible is beyond where I have gotten. My hint is separation logic.
- Allow types to change safely. So that free() can change the type of the pointer passed to it, to be a non-dereferencable pointer (whatever bits it has).
This is an idea from separation logic.
Allowing functions to change types of data safely could also be a safe solution to code that needs type punning today.
I think conceptually modules are great, but if your goal is source compatible changes that bring memory safety then something like modules is an unnecessary distraction.
Any changes that ultimately cannot be implemented in the default C compiler I don't think will be preferable to just rewriting the code in a more established language like Rust.
On the other hand I think we are in a local maxima with programming languages and type systems. With everyone busy recombining proven techniques in different ways instead of working on the hard problem of how to have assignment, threading, and memory safety. Plus how to do proofs of interesting program properties with things like asserts.
Unfortunately it appears that only through proof can programs be consistent enough that specific security concerns can be said to not be problems.
What I have seen of ADA Spark lately has been very tantalizing.
I have a personal project that I think I have solved the memory safety problem, while still allowing manual memory management and assignment. Unfortunately I am at a stage where everything is mostly clear in my head, but I haven't finished fleshing it out and proving the type system, so I really can't share it yet :-(.
While implementing modules, memory safety, type variables, and functions that can change the types of their argument pointers. I think I will end up with something simpler than C in most respects.
I keep going well that doesn't make any sense today, as I go through all of the details and ask why is something done the way it is done.
One of those questions is why doesn't C use modules.
How does Upsilon know which values from other basic blocks it could receive? That information is critical for transformations like constant propagation, and register allocation.
My prefered form is basic blocks with arguments. Where the final jump has parameters it passes to it's destination blocks.
That form has a 1-1 equivalence with SSA and I find it much easier to reason about. Every SSA algorithm I have looked at so far works just fine on the representation. Plus there is none of the annoying transforming into and out of SSA.
If you omit the mucking about with return closures in CPS what is left is basic blocks with arguments.
To see basic blocks with arguments as a form of SSA just see every basic block argument as a phi function, and the callers parameters that feed into that argument as the other end of the sources of the phi function.
Just from your description I think your pizlo special SSA is actually a form of basic blocks with arguments. What I don't see from your description is why Upsilon and phi aren't combined into a single notion (What I would call an incoming block parameter).