Message from the host 💬
Hey y'all! A subset of the Rust core team is now here and we'll be answering from our personal perspectives. Keep the questions coming!
EDIT: And we're done! Thanks for the great questions, everyone! This was a lot of fun.
I feel learning Rust needs functional programming experience, being coming from C background I am facing difficulty in solving problems rust way.
I would like to learn rust by contributing to the open source code, for now can you please recommend some rust projects where I can contribute as a beginner?
I am also interested in embedded systems, what's the plan to support micro-controllers like ARM cortexM3 and friends? Is anybody is doing work on this?
What is your personal vision for Rust in 10 years? I'd love to hear a few random interesting personal highlights from what you hope or envision the Rust language or ecosystem looking like 10 years from now in 2028. Specialty, language feature, adoption pattern, notable success story, however you envision it!
Complex constraints and code abstractions can be handled in different ways, including with advanced type systems including higher-kinded types (as in Haskell and Scala) or by including advanced code-generation capabilities (as in C++ templates and Scheme macros). Both come with drawbacks, however (large learning curve and difficulty in figuring out where behavior is coming from, respectively).
Other languages (e.g. Go) eschew such features. This makes programming feel simple; simple tasks are simple to understand, and you handle complexity face-to-face (manually--the compiler doesn't help you).
Rust already has a sophisticated type system (especially if lifespans are counted), a robust macro system, and plans are underway to add to both capacities. What is the ideal end-goal? Is there a balance to be had between language simplicity and language expressivity? When should the type system carry the burden of taming complexity and when should metaprogramming (macros)?
WebAssembly is on track to receive a number of features to improve targeting it from languages with large runtimes. What wasm features would you like to see to help Rust be a useful choice for libraries and applications on the web? What work might be done on Rust and in the ecosystem to make it more competitive when targeting the web?
I wanted to learn Rust for http://exonum.com/ project, but I think the syntax of the language is quite complicated. In what other development environments can I use it and why it is better than Python or for example Java?
Thanks in advance.
P.S Language actually is very interesting, I think that it has a really lot great features built-in.
Go Rust ! ⚙️
What is the plan regarding Rust and Gnome? Is there a complete integration of Rust and GTK planned? In a few years, would it be possible to use Rust for high quality GUI's on Linux? Could such GUI's be ported to the web through Webassembly?
I've been longing for a clean, integrated, powerful, native GUI toolkit for a long time, and I was hoping maybe Rust could be just that ...
In other words, do you eventually envision Rust able to write both the application logic as well as sophisticated graphical stuff?
What do you think about Rust applicability in the field of cryptography? Not only in technical terms, but also regarding how to attract professional cryptographers to write in Rust. Can we in 5-10 years get a pure Rust OpenSSL replacement which hopefully will be free of all those horrible memory bugs or there is some obstacles which will be hard to overcome?
I'm currently working on code involving cryptocurrencies like blockchain explorers and market aggregators. I know many languages but I mainly use Go and Rust for most things. Unfortunately, this project is going to be very large and I was not comfortable with the delays Rust imposes on the code-build-run cycle, so I went with Go for the core of this project (though I use Rust for other smaller services).
I know incremental compilation has landed and helped a ton, but it's still magnitudes slower than Go compilation. Is there any plans to improve this and is there a timeline (like alternative compiler backends)?
There are lots of great language improvement ideas flying around in the RFC repo. Non-lexical lifetimes, module system revamp, const fns, variadic generics, extensions to the trait system, and so many others... I assume there are a lot more people proposing ideas than people working on the language, so how do you manage to cope with the flux, examine all of the proposals, and prioritize those that get accepted for implementation?
A large fraction of the Rust team works at Mozilla, and I've always been a bit curious about how that came to be. I mean, I work with some MLOCs of hairy legacy C++ code at work, so I can understand the desire to have a better systems programming language, but there is a difference between dreaming that and hiring quite a large team to actually make it happen! Could you give me a bit of perspective on this?
About error handling.. Let's say i'm a crate creator. For now recommended strategy for error handling is to make own error type:
and wrap all possible error with it.
Let's say someones uses my crate and he/she also need to wrap around my error with its own error type. Now when error occurs in 'ending' crate then there is a chain of converting errors, like:
std::io::Error > some-lib1 > some-lib2 > ..
which a lot of conversion is made + a lot of wrapper code is needed
Is there a way of doing it better?
I don't know enough about formal verification (or even if that's the right term), but do you guys see Rust making it relatively easy to verify that a program does what is supposed to do and only that? In time, does Rust have the potential to bring an even higher degree of program soundness than just memory and thread safety?
Hi Rust devs! I love your language, it is a great experience to code in. Got question about simple C++-like "std::cin" manipulation. Doing pretty advanced things on an online judge platforms are fairly straitforward except input handling in performant manner. On spoj for example you can't - as far as I know - use extern crates. What do you think about adjusting std lib or docs to simplify the process?