creusot VS book

However, it seems that C is not "notified" whether --cfg thing is set, only the main crate being built is. Regardless of this flag, the dummy macro is always chosen. Am I doing something wrong? It should work; the Creusot project is doing something similar.

I believe https://github.com/xldenis/creusot is more similar in that it also uses proofs to prove rust code correct.

Wow that sounds really cool! I'm not an expert but does that mean that one day you could implement dependend types or refinement types in Rust as a crate ? I currently only know of tools like: Flux Creusot Kani Prusti

Easy reasoning does not end on memory safety. For example, deductive verification of Rust code is possible exactly because there's no reference aliasing in safe Rust

> No support for using something like separation logic within Rust itself to verify that unsafe code upholds the invariants that the safe language expects.

I think this is something we might see in the future. There are a lot of formal methods people who are interested in rust. Creusot in particular is pretty close to doing this - at least for simpler invariants

https://github.com/xldenis/creusot

Seems similar in principle to cruesot except as another language instead of as a layer on-top of rust.

You often encounter this entire thread of rhetoric when someone wants to put a diversion into the central argument, yeah but it doesn't ____.

But Rust does do that, match exhaustiveness, forcing the handling of errors and the type system enables things like CreuSAT [1] using creusot [2]

[1] https://news.ycombinator.com/item?id=31780128

[2] https://github.com/xldenis/creusot

> Creusot works by translating Rust code to WhyML, the verification and specification language of Why3. Users can then leverage the full power of Why3 to (semi)-automatically discharge the verification conditions!

Units of Measure, https://github.com/iliekturtles/uom

The base properties of the language enable things that can never be done in C++.

> I’ve been working on a tool: https://github.com/xldenis/creusot to put this into practice

Note that there are other tools trying to deal with formal statements about Rust code. AIUI, Rust developers are working on forming a proper working group for pursuing these issues. We might get a RFC-standardized way of expressing formal/logical conditions about Rust code, which would be a meaningful first step towards supporting proof-carrying code within Rust.

This is exciting! I've met with people from AdaCore and Ferrous systems (individually) several times and they're all serious, competent and motivated.

I'm curious what kinds of software they want to (eventually) verify, my PhD thesis is developing a verification tool for Rust (https://github.com/xldenis/creusot) and I'm always on the look out for case studies to push me forward.

The road to formally verified Rust is still long but in my unbiased opinion looking quite bright, especially compared to other languages like C.

My first port of call was to google learn rust which lead me to "the book". The book is a first steps guide written by the rust community for newbies (or Rustlings as they're called) to gain a 'solid grasp of the language'.

Before Prodzilla, I’d read 'The Book' a couple of times, and had made my way through Rustlings, but hadn’t yet built a serious project in Rust.

To answer your last question;

Start with the Rust book.

https://doc.rust-lang.org/book/

Then do Rustlings until the syntax becomes muscle memory.

Then join the Discord and start doing little projects.

You won’t get up to the proficiency of other languages as quickly in Rust. It takes longer. For me it’s taking a lot longer, but I enjoy it.

Before diving into these repositories, familiarize yourself with Rust and its development ecosystem. The official Rust book is an excellent resource for developers at all levels. Each repository has documentation on how to contribute, covering code style, issue tracking, and pull requests.

This is my third Rust book after the official book and Rust in Action. The other two books are great, but they were too theoretical for me. I'm a slow learner and had much trouble grokking Rust's features and idiosyncrasies. When I was done with these books, I was lost and unsure of what I could do.

It's the same reason everything digital and downloadable isn't free: there's a cost to create it and there's a value to it.

For a language developer to charge for a book about that language, I think that's a completely valid way to make some money off of their work.

Even the Rust book, "The Rust Programming Language" is available freely online [0], but also as a print and ebook for sale via NoStarchPress [1].

[0] https://doc.rust-lang.org/book/

[1] https://nostarch.com/rust-programming-language-2nd-edition

You know you can just read it online right now in 2 different variants It does contain some systems programming.

I am looking at The Book (https://doc.rust-lang.org/book/), but hoped there was an amazing person on youtube.

Yeah, I'll build something, finally trying webassembly.

https://doc.rust-lang.org/book/ https://github.com/rust-lang/rustlings https://doc.rust-lang.org/rust-by-example/