- The interesting part to me is that this bug does not necessarily happen in an unsafe block. The fix happens in an unsafe block, I think the API should change to avoid this. Perhaps by forcing users to pass a lambda to do stuff instead of having to manually lock and drop?
- > Classic Motte and Bailey. Rust is often said "if it compiles it runs".
That claims is overly broad, but its a huge, huge part of it. There's no amount of computer science or verification that can prevent a human from writing the wrong software or specification (let plus_a_b = a - b or why did you give me an orange when I wanted an apple). Unsafe Rust is so markedly different than safe default Rust. This is akin to claiming that C is buggy or broken because people write broken inline ASM. If C can't deal with broken inline ASM, then why bother with C?
- > I suspect debugging is not that straightforward to LLM'ize.
Debugging is not easy but there should be a lot of training corpus for "bug fixing" from all the commits that have ever existed.
- > To give a contrived example, let's say you want to state that a particular computation terminates. To do it in a clear and concise manner, you want to express the property of termination (and prove that the computation satisfies it), but that property is not, itself, computable. There are some ways around it, but as a rule, a specification language is more convenient when it can describe things that cannot be executed.
Do you really think it is going to be easier for the average developer to write a specification for their program that does not terminate
vs
Giving them a framework or a language that does not have for loop?
Edit: If by formal verification you mean type checking. That I very much agree.
- Is there any plans by some DE to replace D-bus with Binder?
- Why haven't anyone randomly generate a bunch of code of various kinds, use LLM to create some summary of it and dump them to github with a restrictive license? The patent office isn't here to enforce anything.
- I'd say it takes about 1 million people with modern military capability to completely take over the world.
- The US could have easily, easily won the Vietnam war if they just dropped 1 or 2 nukes. The modern military is going to have drone that swarm the sky 24/7. They can develop virus that only they have the cure to. They can drop EMPs. They can grow their own food in their own lab while we all slowly die and wither outside.
These are powers that are actually, technically, plausibly be granted to a single or several individual in the future.
The future where human is obsolete is scary. Just reread that sentence again. Humans are obsolete.
- I claim that 99.9999% of software should be written in a GC language. Very, very, very few problems actually requires memory management. It is simply not part of the business requirement. That said, how come the only language closest to this criteria is Go except it hasn't learn about clean water (algebraic data types).
- What I am curious about is, is the compiler smart enough to be lazy with computation and or variables? For example consider:
let a = expr let b = expr2
if (a || b) { return true; }
is the compiler allowed to lazily compute this if it is indeed faster to do that way? Or declaring a bunch of variables that may or may not be used in all of the branches. Is the compiler smart enough to only compute them whenever it is necessary? AFAIK this is now allowed in C-like languages. Things have to materialize. Another one is, I like to do memcpy every single time eventhough it might not even be used or overwritten by other memcpys. Is the compiler smart enough to not perform those and reorder my program so that only the last relevant memcpy is performed?
A lot of times, my code becomes ugly because I don't trust that it does any of this. I would like t write code in consistent and simple ways but I need compilers to be much smarter than it is today.
A bad example recently is something like
const S * s =;
let a = constant; let b = constant; let c = constant; let d = constant; let e = constant; let f = constant; let g = constant; let h = constant; let i = constant; let j = constant; let k = constant; let l = constant;
if (s->a == a && s->b == b /* etc */ ) { return true; }
It did not turn all of this into a SIMD mask or something like that.
- > Arc<Mutex<Box<T>>> is complex
This is not the language problem, but its simply the nature of the problem no? It is like saying, full adders are complex, can't we design something simpler? No, full adders are the way they are because addition in binary is complicated.
What you are saying is that this problem is not your kind of problem, which is fine. Not everyone needs to face the complexity of optimizing full adders. And so we created abstractions. The question is, how good is that abstraction?
C++ is like using FP math to do binary addition.
- And? I don't need any of that fancy. Does anyone need that fancy stuff? I don't think anyone complained about UIs with apps in Windows XP.
- Why not ditch HTML itself? People are already downloading binary blobs on a daily basis anyway, just download some binary once, execute them in some isolated environment. So you only have to transmit data.
- With the ? syntax in Rust results and exceptions are the same thing. I posit that the former is superior. It is unfortunate that results have worse performance but I don't see any reason why. Results that bubbles up all the way ought to be identical to an uncaught exception.
- I don't understand this thread. Is Amazon supposed to keep expanding ever and ever again? If those people are needed, then Amazon will fall (good riddance), if they are not needed then that's just good business.
I don't see any issues as long as everyone plays a fair game.
- Our society lives and breathes this contradiction. We believe in determinism and demands justice. We believe in an omnipotent God and is sinful. On a personal level, there is quite literally nothing "you" can do to change yourself; to change oneself, one has to change to one that changes oneself. This is recursive. Looking at it this way, the important thing is to create an environment, situation, society that makes it easier to change oneself for the better. "Show me the incentives, and I will tell you what happens" as someone might say.
- The next time someone says "the other guy's not much better!" I am going to strangle and choke them.
- I am pretty sure CPUs can speculative load as well. In the CPU pipeline, it sees that there's an repeated instruction to load, it should be able to dispatch and perform all of it in the pipeline. The nice thing is that there is no chance of hazard execution here because all of this speculative load is usable unlike the 1% chance where the branch would fail which causes the whole pipeline to be flushed.
- Since the biggest one is only 11110 (5 bits), can't you use a lookup table of 32 characters by masking the last 3 bits?
Believe me when I say this but 99.99999% of the human population does not give a shit what is Firefox, Chrome, Edge, Brave, whatever.
Their survival is completely detached from how "good" it is. As long as it runs, opens a page, opens picture, plays video.
We all live in the tech bubble, to them its an "app" that is "annoying me with ads". And that if they know its an ad, not just part of the page. That is if they even know its a page, not just something my son told me to click if I want to go to "Facebook".