Hello and welcome to another issue of This Week in Rust! Rust is a systems language pursuing the trifecta: safety, concurrency, and speed. This is a weekly summary of its progress and community. Want something mentioned? Send me an email! Want to get involved? We love contributions.

This Week in Rust is openly developed on GitHub. If you find any errors or omissions in this week's issue, please submit a PR.

What's cooking on master?

273 pull requests were merged in the last two weeks, and 4 RFC PRs.

Now you can follow breaking changes as they happen!

Breaking Changes

• New floating-point to decimal formatting routine. lifthrasiir completely rewrote Rust's floating point to string conversion to employ the Grisu algorithm. This causes some slight changes to Rust's formatting output.
• Redesign Duration.
• Destabilize io::BufStream. Some last minute uncertainty about the semantics of seek.
• Remove addition on vectors for now. These entered the tree under the radar, so to speak, so were removed before 1.0 to give more consideration.
• Mark mem::forget safe. Memory / dtor leaks are not considered unsafe.
• dropck: must assume Box<Trait + 'a> has a destructor of interest. Because these types may have destructors, so the compiler must assume that any contained regions strictly outlive the type, per RFC 769.

Other Changes

• Documentation includes a new error index, cataloging extended error explanations.
• DST coercions. Allows smart pointers of statically-sized types to be cast to smart pointers of dynamically sized types. RFC.
• Add lint to deny transmuting &T to &mut T. The mutable_transmutes lint catches transmutes that are almost always incorrect.
• Implement append and split_off for BitVec.
• Add decorator syntax extensions on trait and impl items.
• Optimize iterator adaptors.
• Implement Debug for std::net::{UdpSocket,TcpStream,TcpListener,Shutdown}.
• Stabilize from_raw_os feature in 1.1. For creating I/O types from raw handles.
• Add AsRef<[u8]> for both str and String.
• More extended diagnostics from ruud-v-a, cactorium, michaelsproul, nham, meqif, caipre: e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13.
• Lots and lots of documentation improvements have been landing in the push for 1.0.
• Allow #[derive(...)] to generate unsafe methods.

New Contributors

• らいどっと
• Aaron Gallagher
• Alexander Polakov
• Alex Burka
• Andrei Oprea
• Andrew Kensler
• Andrew Straw
• Ben Gesoff
• Chris Hellmuth
• Cole Reynolds
• Colin Walters
• David Reid
• Don Petersen
• Emilio Cobos Álvarez
• Franziska Hinkelmann
• Garming Sam
• Hika Hibariya
• Isaac Ge
• Jan Andersson
• Jan-Erik Rediger
• Jannis Redmann
• Jason Yeo
• Jeremy Schlatter
• Johann
• Johann Hofmann
• Lee Jeffery
• leunggamciu
• Marin Atanasov Nikolov
• Mário Feroldi
• Mathieu Rochette
• Michael Park
• Michael Wu
• Michał Czardybon
• Mike Sampson
• Nick Platt
• parir
• Paul Banks
• Paul Faria
• Paul Quint
• peferron
• Pete Hunt
• robertfoss
• Rob Young
• Russell Johnston
• Shmuale Mark
• Simon Kern
• Sindre Johansen
• sumito3478
• Swaroop C H
• Tincan
• Wei-Ming Yang
• Wilfred Hughes
• Will Engler
• Wojciech Ogrodowczyk
• XuefengWu
• Z1

Approved RFCs

• RFC 1066: Alter mem::forget to be safe. Leaking memory and not running dtors is considered safe.
• RFC 1068: Scaling Rust's Governance. Establishes 'subteams' to spread responsibility to more people.

New RFCs

• Result::expect.
• Semantic versioning for the language.
• Introduce split_at on str.
• Stabilize TcpStream::set_keepalive.

Betawatch!

The current beta is 1.1.0-beta (cd7d89af9 2015-05-16) (built 2015-05-16).

Notable Links

• Rust 1.0 is here.
• Rust 1.0 t-shirts are available for order.
• Announcing the subteams. The official Rust governance structure has expanded.
• Finding closure in Rust. The best explanation of Rust closures.
• How to write a Rust syntax extension.
• Virtual structs part 1: where Rust's enum shines.
• Where Self meets Sized: Revisiting Object Safety.
• Slides from cburgdorf's talk on Nickel.
• RailsConf 2015 - Bending the Curve: How Rust Helped Us Write Better Ruby (video).
• rust-learning and awesome-rust. Resources for newbies.
• Servo's dependency graph. It's massive.
• rust-rss. Library for serializing the RSS web content syndication format.
• Rust Discovery, or: How I Figure Things Out. Carol's thought process for contributing to Rust.
• Rust's ownership model for JavaScript developers.
• Abstraction without overhead: traits in Rust.
• Support for building components in Rust lands in Firefox Nightly. This just means that the Fx build system can build Rust, not that it is.
• Rust ownership, the hard way.
• Criticizing the Rust language, and why C/C++ will never die. This article was seen as something of a misleading hit-piece by a C++ static analysis vendor but it got a fair bit of attention.
• A Taste of Rust. An experience report with some critique.
• Proposed security disclosure policy. A security policy for Rust.
• Rust makes me excited about the future. Rust will make everything better.
• Pre-RFC: std::net expansion.
• Error handling in Rust. From Andrew Gallant, who knows a few things about the subject.
• Diversity on the governance teams.
• Porting a ray tracer to Rust, part3.
• O'Reilly book on Rust available for pre-order.
• Diving into Rust for the first time. On the Mozilla hacks blog.
• My Python's a little Rust-y - PyCon 2015 (video).
• Rust 1.0 Bay Area release party (video). Some lightning talks about production users.
• Mozilla-backed Rust language stabilizes at version 1.0. First time Ars has mentioned Rust in my recollection, but shallow coverage.
• Clean Rust Off Campaign. Ridding the Internet of out-dated information.
• The problem with single-threaded mutability.

Project Updates

• Vagga. Docker-inspired container engine.
• rust-adorn. Python style function decorators.
• recycler. Recycling types with owned memory.
• MemBuf. Managing heap buffers.
• A Rust cartridge for OpenShift.
• Routing. A distributed hash table.
• Rustful 0.1 was released. A simple web framework.
• twox-hash. A fash hash algorithm.
• http_replay. Hyper middleware for recording and replaying HTTP requests.
• Rust + Go. An example of calling Rust from Go.
• Glutin running on a Raspberry Pi
• rust-api-docs-helper. atom.io package for accessing std docs.
• Chapter 1 of Iron by Example: Decomposing Hello World.
• kafka-rust. A Kafka client.
• Google.rs 0.2 was released.
• Google.rs dev diary #3 (video).
• Packt is releasing a book called Rust Essentials soon.
• Pulse. A 'composable wait system'.
• Servo: The embeddable browser engine. An article for Samsung by Lars and Mike about Servo embedding.
• Chris Morgan overhauled the design of play.rust-lang.org.
• Rust running on a PlayStation.
• Visual Rust 0.1 released.
• sxd-document. XML and XPath in pure Rust.
• This Week in Servo 32.
• Bloomberg CodeCon, a programming competition, supports Rust.
• docker-rust has been updated to 1.0 stable.
• Hematite, the Minecraft clone, running in the browser via Emscripten.
• A Racer-based code completion plugin for KDE's Kate editor.
• A Kickstarter for a book called Rust Programming Concepts.
• KISS-UI, a simple UI toolkit for Rust.
• gtk, the GTK+ 3.x's binding.

Upcoming Events

• 5/22. Boulder, CO. Lambda conf. 'An Introduction to Rust: Or, "Who Got Types in My Systems Programming!" - Jared Roesch'
• 5/23. Bangalore, India
• 5/23. Pune, India
• 5/27. Columbus Rust Society
• 5/27. Lithuania. Functional Vilnius #4: Rust & Monoids.

If you are running a Rust event please add it to the calendar to get it mentioned here. Email Erick Tryzelaar or Brian Anderson for access.

Quote of the Week

"Yes, because laundry eating has evolved to be a specific design goal now; and the initial portions of the planned laundry eating API have been landed behind the #![feature(no_laundry)] gate. no_laundry should become stable in 6-8 weeks, though the more complicated portions, including DRY cleaning, Higher Kinded T-shirts, Opt-in Builtin Detergent, and Rinse Time Optimization will not be stabilized until much later."

"We hope this benefits the Laundry as a Service community immensely."

Manish explains Rust's roadmap for laundry-eating.

Thanks to filsmick for the tip.

And since there were so many quotables in the last two weeks, here's one from Evan Miller's evaluation of Rust:

"Rust is a systems language. I’m not sure what that term means, but it seems to imply some combination of native code compilation, not being Fortran, and making no mention of category theory in the documentation."

Thanks to ruudva for the tip. Submit your quotes for next week!.