10 ms·
Rust's 2019 Roadmap
- xvilka 8y agoPorting unique and omnipresent applications to Rust can help the adoption. For example applications like ElasticSearch. There is an ongoing Toshi[1] project to create an alternative. Creating analogs for IPython and LanguageTool can add much more Rust users and developers without significant promotional efforts. [1] https://github.com/toshi-search/Toshi https://github.com/toshi-search/Toshi
- est31 8y agoIn other Rusty news, two phase borrows just got enabled on nightly but stable Rust in the 2015 edition: https://github.com/rust-lang/rust/pull/59114 https://github.com/rust-lang/rust/pull/59114. If not backed out, it will most likely be part of the 1.36 release. This is a milestone of maturity for the new borrow checker: they had a ticket with multiple blocker bugs before they chose to enable it on the 2015 "stability" edition as well: https://github.com/rust-lang/rust/issues/57804 https://github.com/rust-lang/rust/issues/57804
- atombender 8y agoIs there a document anywhere explaining what this change means in practice?
- estebank 8y agohttp://smallcultfollowing.com/babysteps/blog/2016/04/27/non-lexical-lifetimes-introduction/ http://smallcultfollowing.com/babysteps/blog/2016/04/27/non-... https://doc.rust-lang.org/edition-guide/rust-2018/ownership-and-lifetimes/non-lexical-lifetimes.html https://doc.rust-lang.org/edition-guide/rust-2018/ownership-... https://stackoverflow.com/questions/50251487/what-are-non-lexical-lifetimes https://stackoverflow.com/questions/50251487/what-are-non-le... http://smallcultfollowing.com/babysteps/blog/2017/03/01/nested-method-calls-via-two-phase-borrowing/ http://smallcultfollowing.com/babysteps/blog/2017/03/01/nest...
- est31 8y agoThe change was part of the 2018 edition already, so is covered in the 2018 book: https://doc.rust-lang.org/edition-guide/rust-2018/ownership-and-lifetimes/non-lexical-lifetimes.html https://doc.rust-lang.org/edition-guide/rust-2018/ownership-... As an experienced Rust developer I can usually deal with the borrow checker, but sometimes I'm still annoyed by its limitations or hit them without expecting to hit them. Most of the times this happens it's either because I want to partially access a struct in a closure, or do something that's now allowed by NLL. So this is a big deal.
- atoav 8y agoIn a very meta way, this means the programmer can get away with more while the safety guarantees are still upheld.
- CryZe 8y agoUnless I'm wrong, this is NLL, not two phase borrows (which may contain two phase borrows). But considering two phase borrows are still a problem for the memory model, they might actually somewhat unstabilize them to a certain degree again (I haven't checked on what they decided regarding that).
- est31 8y agoNot a borrow checker expert, but this PR was on the blocker list. Maybe it's what you mean? https://github.com/rust-lang/rust/pull/58739 https://github.com/rust-lang/rust/pull/58739
- sanxiyn 8y agoSince the new borrow checker is maturing, people are working on the new new borrow checker: https://github.com/rust-lang/polonius https://github.com/rust-lang/polonius
- kibwen 8y agoFor those wondering, the "new new borrow checker" is similar to its predecessor in that it operates on the compiler's MIR, but is a different and slightly more complete algorithm (it accepts a strict superset of code, thus backwards compatible). This two-step rollout was decided last year due to (at the time) some unacceptable compile-time regressions in the new-new algorithm's implementation. Read about it here: http://smallcultfollowing.com/babysteps/blog/2018/06/15/mir-based-borrow-check-nll-status-update/ http://smallcultfollowing.com/babysteps/blog/2018/06/15/mir-...
- mjw1007 8y agoI'm pleased to see that improving the language reference is on there, but mildly concerned by the core team thinking of this as a matter of "polish".
- steveklabnik 8y agoIt's more about how it fits into a general theme; it's not a comment on the amount of work, just that it's a resource that already exists that needs improvement. There's a ton of things that need to improve with it.
- dfabulich 8y agoHow many of the language improvements called out in the 2018 roadmap https://blog.rust-lang.org/2018/03/12/roadmap.html https://blog.rust-lang.org/2018/03/12/roadmap.html are done? Seems like async/await still isn't.
- dbrgn 8y agoRegarding async, see https://areweasyncyet.rs/ https://areweasyncyet.rs/. The foundations are mostly done, currently the syntax is still being bikeshedded.
- CryZe 8y agoAnd Futures are about to be stabilized any moment now (and with that I mean within a few hours probably).
- steveklabnik 8y agoThe futures stabilization is very close as well, see https://github.com/rust-lang/rust/issues/59725 https://github.com/rust-lang/rust/issues/59725 and https://github.com/rust-lang/rust/pull/59739 https://github.com/rust-lang/rust/pull/59739 . Very soon! Like, hours. But yes, after that, the big issue is the syntax issues around async/await. Working on it!
- steveklabnik 8y agoFew plans survive contact with the enemy :) Out of the stuff called out there, everything other than async/await shipped, most in total, some in part. Custom allocators didn't fully ship, only the global custom allocators did so far. Hygene didn't ship for macros 2.0, but the non-hygenic ones did.
- Buttons840 8y agoIt looks to me like the 2018 roadmap was followed pretty well. A few exceptions are that async/await was not finished, but that is not for lack of trying (from what I gather), so this is excusable. The 2018 roadmap did correctly indicate what would be worked on throughout most of 2018, even if some things took longer than expected. I think a roadmap is only a failure if it gets ignored and none of the stuff mentioned in the roadmap gets worked on at all. I've been at some dysfunctional startups like this, for a time the company tries to rally the developers, a roadmap is made, people feel good, the next week the CEO decides to go in a completely different direction and then things are back to being dysfunctional, and nobody ever thinks about the roadmap again. It does seem like "macros 2.0" might have fallen through the cracks? As far as I know they were never finished and I haven't heard much about their progress.
- SlowRobotAhead 8y agoCTRL-F embed Nope, well... Maybe next year! I've been eyeing Rust for embedded but until there are major players shipping IDEs that natively support it, it's just a hobby thing. Embedded and IoT is about to get a lot bigger - if I was them I'd be focusing hard on it to make sure my language had a strong foothold for when there was a new hottness that all the kids start raving about.
- stusmall 8y agoIt's in the more detailed roadmap RFC under the embedded WG: https://github.com/rust-lang/rfcs/blob/master/text/2657-roadmap-2019.md#embedded-bare-metal-devices https://github.com/rust-lang/rfcs/blob/master/text/2657-road...
- Aissen 8y agoWhich itself is hidden behind having a dropbox account: https://paper.dropbox.com/doc/ZmUYvRp4PjX1jqq6LSxcZ https://paper.dropbox.com/doc/ZmUYvRp4PjX1jqq6LSxcZ Can anyone copy/paste it somewhere else ?
- KarboniteKream 8y agoHere you go! https://rentry.co/wyf5v https://rentry.co/wyf5v
- deleted 8y ago[deleted]
- _bxg1 8y ago"Embedded and IoT is about to get a lot bigger" I'm curious what makes you think that? Culturally, I feel like there's been some general backlash to the gratuitous IoT-ification of every aspect of our lives, from a privacy perspective, a fragility perspective, and a "using apps to control everything isn't actually convenient" perspective: https://twitter.com/internetofshit https://twitter.com/internetofshit
- 8y ago
- Tomte 8y agoThe MITM proxy issue makes Rust a non-starter in many corporate environments. Unfortunately, when someone tried to make a first step, he was treated very poorly and his work was sabotaged. I don't have much hope that it will be addressed again soon: https://github.com/rust-lang/rustup.rs/pull/1624#pullrequestreview-201321423 https://github.com/rust-lang/rustup.rs/pull/1624#pullrequest... It's really sad, because Rust started with the same good idea as Golang: treat Windows users as first-class citizens.
- steveklabnik 8y agoWe've made other moves toward this kind of thing; for example, you can run your own crates.io instance. This is something we care about, but it's also something we want to make sure we do right. We'll get there. (Note also that that PR is not yet closed.)
- Tomte 8y agoThanks for working on it! But I still think someone "official" should have weighed in and reined in the "what about security?" people. That was pure ignorance. The security angle has been discussed, and "I don't know much about it, so let's kill it" is a really bad precedent.
- steveklabnik 8y agoYes, part of the issue here is that there hasn't been a ton of ownership on rustup, and even the Cargo team has not had as much time and effort as we'd like. We're currently working on growing both teams, which means better ownership, which means someone to make these calls. > "I don't know much about it, so let's kill it" is a really bad precedent. I would agree, but a "completely ignore security" flag is something to be cautious about.
- staticassertion 8y ago> and "I don't know much about it, so let's kill it" is a really bad precedent. I feel the opposite. Where user safety is concerned, if a problem is not understood the solution should not be implemented. In an example where it's "disable security feature X", and the developers don't know the implication, would you really want them to just say "well whatever, I don't understand the implications, but let's push forward" ?
- oaiey 8y agoI happily read that rustc is split into a incremental parsing frontend and a supporting backend. This capability is key in modern compilers and editors. I read about this like 8 years ago in the C# Roslyn compiler project. Roslyn also aimed in supporting IDEs (here the language server) using the compiler frontend. My question is: are there any compiler which predate Roslyn in this aspect? Anders Heijlsberg said in a video once, that this is modern compiler architecture (compared to the outdated Dragon and Tiger) but did not mention that the Roslyn team invented it.
- kibwen 8y agoIndeed, I recall hearing that Roslyn was an inspiration for the Rust developers in this regard.
- raphlinus 8y agoI'm not super-expert, but know of some background. I think Rosyln grew very much out of Delphi, and Anders Hejlsberg is the common thread to both. Before that, he did Turbo Pascal, which might have been incremental in some ways (it certainly was very fast). Another earlier example of successful incremental technology was the Java compiler in Eclipse. I'm sure there are academic efforts as well, but don't know as much about these.
- lostmsu 8y agoI thought the main technology behind Roslyn is some researched or customly engineered parser/semantic analyzer that came out of MSR. The original C# parser was quite typical.
- pjmlp 8y agoPhoenix, it was a kind of LLVM (search for "Frameworks for Research in Code Generation and Execution").
- fxfan 8y agolook up Microsoft research Phoenix.
- integricho 8y agoOff-topic, but I'll just ask, is the book Programming Rust: Fast, Safe Systems Development 1st Edition [1] still relevant / worth reading (given the book is based on an older, although stable? version of Rust)? If it isn't, does anyone know maybe if a 2nd, updated edition can be expected? [1] https://www.amazon.com/Programming-Rust-Fast-Systems-Development/dp/1491927283# https://www.amazon.com/Programming-Rust-Fast-Systems-Develop...
- steveklabnik 8y agoIt covers Rust 1.17. It is almost entirely still accurate; you’d need to set the edition back to 2015 in your Cargo.toml for some examples to work, but the foundations are still very solid. You’d have to adjust some import paths to get them to work in Rust 2018 thanks to the module system improvements. It won’t tell you about new features, but the big picture is still fully accurate, you might just need to tweak some details, and read some newer release notes to learn about some new things. It’s still a great book.
- integricho 8y agoThanks, that's quite reassuring, I wasn't sure whether it's a good investment of time or not.
- kod 8y agoIt's still probably the most well-written Rust book.
- nobleach 8y agoThat whole module system change really took me for a ride a few months back. After a "routine" rustup, none of my code worked. I have to be honest here that I still don't think I have a good grasp on how files/packages are imported in Rust....
- ausjke 8y agoNever really got a chance to do serious c++ development but I am more and more interested in Rust these days. It appears Rust might be a good alternatives. My field is embedded products.
- dorfsmay 8y agoWhat do you use today? C?
- ausjke 8y agoMostly C, some python. I spent more and more time on rust and golang these days.
- dorfsmay 8y agoDo you do embedded in golang as well? What has been your experience going from C to Rust for embedded?
- ausjke 8y agoyes but I am not using either heavily at this point in any real product, just experimenting, so far golang is easier to pick up, binary size is a concern still even with upx, security is the major selling point for both. golang is not good for realtime due to its GC.
- whatshisface 8y agoOne of my biggest concerns about the Rust project is that their governance is getting more and more complicated. Every language so far that I like was orchestrated by a BDFL, and the ones that aren't so well-designed (C++, Java) also happen to be elaborately governed. How can the Rust project be sure that it isn't going to smother itself with working groups to decide the color of the bikeshed that committee members park their bikes in on the way to meet about the code of conduct?
- steveklabnik 8y agoThe language itself is still designed primarily by the language team, which is not many people. If anything, the team is large because we see Rust as more than just the language. The language you like that’s designed by the BDFL doesn’t generally have the BDFL make all decisions about the package manager, or the website, or the documentation, or the conferences. It’s just not humanly possible. We have the core team to provide overall oversight over all of these teams to ensure things are coherent.
- woah 8y agoJavaScript went from being a bad language designed by a BDFL to a good language designed by a very large committee. It’s not the best language ever, but it is better at this point than similar languages such as Python or Ruby (good async, good type system, good module system, no decades-long versioning crisis). The last part of your comment hints that your objections to Rust’s governance may be more political than language design related.
- whatshisface 8y ago>The last part of your comment hints that your objections to Rust’s governance may be more political than language design related. I checked the code of conduct and it didn't seem too political to me, internet forums have had those kinds of rules for decades. What it is, though, is an example of an administrative artifact, too many of which will suck energy away as top level people spend more and more of their time not thinking about the end product.
- v_lisivka 8y agoOne long-standing problem is the incompatibility of Rust enum with C enum. In C, enum's are just labels for integers, similar to const int values in Rust, so C enum { A=0, B=1, C=2 } is more like Rust's enum E { A=0, B=1, C=2, Unlabeled(3..MAX_INT32), } . This slight incompatibility forces writing of converters between C enums and Rust enums. See https://github.com/rust-lang/rust-bindgen/issues/667 https://github.com/rust-lang/rust-bindgen/issues/667
- v_lisivka 8y agoCan anybody explain the downvotes? It looks suspicious. It's well known and long standing problem. Rust the Language allows proper enum, but Rust the Compiler cannot pack enum into single value, as in C. Example: #[repr(C)] #[repr(i32)] #[derive(Debug)] #[allow(dead_code)] enum E { A, B, C, Unlabeled(i32), } fn main() { { let v: E = unsafe { std::mem::transmute::<(i32,i32), E>((0,0)) }; println!("v = {:?}", v) } { let v: E = unsafe { std::mem::transmute::<(i32,i32), E>((1,1)) }; println!("v = {:?}", v) } { let v: E = unsafe { std::mem::transmute::<(i32,i32), E>((2,2)) }; println!("v = {:?}", v) } { let v: E = unsafe { std::mem::transmute::<(i32,i32), E>((3,3)) }; println!("v = {:?}", v) } { let v: E = unsafe { std::mem::transmute::<(i32,i32), E>((3,55)) }; println!("v = {:?}", v) } { let v: E = unsafe { std::mem::transmute::<(i32,i32), E>((55,55)) }; println!("v = {:?}", v) } } Output: v = A v = B v = C v = Unlabeled(3) v = Unlabeled(55) v = A
- pleasecalllater 8y ago> Can anybody explain the downvotes? It looks suspicious. I can. This is a long tradition here. If someone criticizes something loved by people with little knowledge (aka fangirls and fanboys) then they downvote it. The truth doesn't matter, the hurt feelings do. And it's downvoted without any explanation. I had this many times, I'm thinking about not posting at all. It's not worth it. There is no discussion, just downvotes. I'm sure this will be downvoted too :)
- xvilka 8y agoAny updates and plans on Chalk[1][2] and Traits subsystem? [1] https://github.com/rust-lang/chalk https://github.com/rust-lang/chalk [2] https://github.com/rust-lang/rust-roadmap-2017/issues/8 https://github.com/rust-lang/rust-roadmap-2017/issues/8
- steveklabnik 8y agoThat's required for several of the items under "long-standing requests".
- hi41 8y agoThe write ups from Rust team is so good! Do they have a documentation team or is it written by a technical person?
- steveklabnik 8y agoThank you! There is a documentation team, I am the lead, and I tend to write the posts on the blog. This one was significantly written by Niko as well.
- lenocinor 8y agoSounds like you're still significantly involved with the docs, then. Are you currently working on transitioning away those responsibilities?
- steveklabnik 8y agoI am planning on staying significantly involved in Rust overall. We're currently discussing some stuff within the docs team, as the roadmap says. We'll see :)
- hi41 8y agoNo! Thank you for writing such amazing documentation! Can you point me to resources so that I can write good documentation.
- steveklabnik 8y ago<3 I don't have a good set of resources for you, sadly. Practice, practice, practice. That's sort of the best I've got right now :/