1,035 karma · joined February 12, 2012
When you look at the details of how these machines are made, the price tag almost seems low in the end.
I do agree with the broader point about cleverness’ failure mode though.
That said, PhD students (and researchers) are still poorly paid (though PhD stipends are being raised over the next few years), and though France has a legal 35 hour work week, informal pressure of academia means that tends to be thrown out the window.
There are legal requirements on graduate schools that help protect students from abusive advisors or other abuse within their laboratories, of course since the research world is small, it remains to see how effective they can be.
In any case it shouldn't be up to whether you had a permissive advisor or not, PhD students like everyone deserve time off, and without legal protections that always gets abused.
It’s allowed me to learn from colleagues, make friends and create a sense of belonging, my lab isn’t just an abstract organization but a group of interesting people.
In general it’s roughly at the level of microsat so worse than minisat and kissat, but not garbage either.
If you have any questions about CreuSAT or Creusot, I’d be happy to answer
Something I have never understood is why people want to write web-apps in Rust. I love the language, but honestly, a managed language (like js/ruby/go) is always going to be better suited to the world of web-apps.
I feel like this imposes an undue burden on Rust to do everything for everyone which has to break down somewhere
I don't want to discourage them from learning Iris, or designing a dependently typed language, but I really think that's missing the difficulty in formal verification.
I think the two areas that need focus are: ease of specification and automation. In short, we need to lower the cost of verifying a line of code, by at least an order of magnitude. These two objectives are also directly opposed to the direction Magmide sets as the goal. Ease of specification means we want to use the least amount of seperation logic possible, and hide it from the user if possible. Doing proofs / writing specs in seperation logic sucks and not for interesting reasons. Automation means favoring simpler logics, specifically we want to stick as much as possible to FOL since that's where we have good automation. By doing everything in a rich dependently typed language from the start it also makes it harder to do incremental verification, I think there is a lot of value in having a 'pyramid of trust' with more and more powerful tools which take you up a level of trust and verification, potentially requiring more input from engineers as they go up.
Finally, I think there's a lot of potential to explore in the interfaces we use to write, read, and debug proofs. I don't think tactic languages (as exist today) are the last word, and I think we should be doing a lot more interesting things to interface with and explore the proofs.
Our preprint can be found here: https://www.lri.fr/~xldenis/paper/rusthornbelt.pdf
I’m actually doing my PhD on the verification of Rust programs and wanted to add that the opposite is actually true. The type system of Rust helps to create a much simpler model of the language which allows us to do proofs in much larger scale than with C (for the same effort). This is specifically because of how ownership typing helps us simplify reasoning.
Ah, that's frustrating, my tool Creusot is meant for the verification of safe code, though I also worked on unsafe code verification as part of the RustHornBelt project (upcoming PLDI paper).
I'd still love to chat and see how far we can push verification, you can reach me via email at xldenis @ lri . fr
Do you make extensive use of `unsafe` Rust? What other features do you use? I ask this as my PhD thesis is building a deductive verifier for (safe) Rust, and I'm always looking out for interesting challenges.
If you would ever be interested in a collaboration proving your algorithm correct let me know :)
In particular, the dirty secret of C verifiers is that they don’t handle pointers all that well. Either you find yourself doing a lot of manual proof work or you have to dramatically simplify the memory model.
In contrast, when verifying safe Rust, the rules of the borrow checker allow us to dramatically simplify the verification work. All of a sudden verifying a manual memory program with pointers (borrows) becomes as simple as verifying a basic imperative language. I’ve been working on a tool: https://github.com/xldenis/creusot to put this into practice
On the other hand, the moment you dive into unsafe, all bets are off and you find yourself wading through the marshes of (weak) memory models with your favorite CSL as your only friend.
This may be a bit weird/niche but I care a lot about the thickness of the monitor itself, the depth of the stand and the bezel around the screen. I’d like if the object I spend 8 hours a day staring at isn’t aesthetically horrendous..
That's not even entering into the issues with ministries which are (illegally) keeping certain software closed source, or have signed recent contracts which make open sourcing impossible.
There's also the related question of Open Data, which I think is often of more civic importance than open source itself. Here again, ministries drag their feet when politically convenient (covid data), or just play deaf.
I want to be able to compose these tools like I would random unix ones: Something like 'Identify album covers in this image | extract the text in said covers | spotify api'.
It seems like there are so many breakthrough models but both due to technical (size/compute) and industrial ($$$) concerns they remain out of reach for random devs, let alone packageable into a `grep` style composable tool.
Memory unsafety allows you to change the 'category' of the bug, you become free to do whatever whereas a logic bug forces to to work within the (flawed) logic of the original program.
Rust won't solve logic bugs but it can help bring up the foundations. So long as memory safety bugs are so pervasive we can't even properly reason on a theoretical level about logic bugs. The core theorem of any type system is "type safety" which states that a well-typed program never goes wrong (gets stuck, aka UB). Only then can you properly tackle correctness issues.
> Rust is cool because Haskell Lego Edition is better than no Haskell at all, and Rust is cool because now that it’s proven affine/linear typing can work, someone will probably get it right soon.
I don't understand the condescending remarks about "Haskell Lego Edition". I do agree that Rust has shown that substructural type systems work and are useful, and that they will be a 'theme' in the next batch of languages (or I can hope).