Rust 1.9 release announcement.

This does not yet have contributor information, that will be added
before merging.

Author: steveklabnik

_posts/2016-05-26-Rust-1.9.md

@@ -0,0 +1,155 @@
+---
+layout: post
+title: "Announcing Rust 1.9"
+author: The Rust Core Team
+---
+
+The Rust team is happy to announce the latest version of Rust, 1.9. Rust is a
+systems programming language focused on safety, speed, and concurrency.
+
+As always, you can [install Rust 1.9][install] from the appropriate page on our
+website, and check out the [detailed release notes for 1.9][notes] on GitHub.
+About 1400 patches were landed in this release.
+
+[install]: https://www.rust-lang.org/install.html
+[notes]: https://github.com/rust-lang/rust/blob/master/RELEASES.md#version-190-2016-05-26
+
+### What's in 1.9 stable
+
+Rust 1.9 contains some exciting new things!
+
+First up, a new attribute for library authors: `#[deprecated]`. Authors of
+libraries can now tag items with this attribute, and users of their crate
+will see a warning when it is used. This new feature was defined in [RFC 1270].
+
+[RFC 1270]: https://github.com/rust-lang/rfcs/blob/master/text/1270-deprecation.md
+
+We now publishes std binaries for the `mips-unknown-linux-musl`,
+`mipsel-unknown-linux-musl`, and `i586-pc-windows-msvc` targets.
+
+[The time complexity of comparing variables for equivalence][compare] during
+type unification is reduced from O(n!) to O(n). What does this mean? Certain
+kinds of code compiles much, much faster.
+
+[compare]: https://github.com/rust-lang/rust/pull/32062
+
+Strings are a very common type, and implement a lot of different traits.
+Specifically, when converting between `&str` and `String`, you have many
+options. Rustaceans used these two the most:
+
+```rust
+let s = "some string".to_string();
+let s = "some string".to_owned();
+```
+
+The former is the official convention, but it was discovered that it's not
+as fast as the second method. For a long time, it was not possible to improve
+this situation, however, a new language feature has landed on nightly and made
+this possible. [`libstd` now uses this internally][str] to make the two equivalent.
+
+[str]: https://github.com/rust-lang/rust/pull/32586
+
+Finally, this feature is technically a library change, but it's worth
+mentioning here as well. The `std::panic` module is being stabilized. This
+allows panics to be caught:
+
+```rust
+use std::panic;
+
+let result = panic::catch_unwind(|| {
+    println!("hello!");
+});
+assert!(result.is_ok());
+
+let result = panic::catch_unwind(|| {
+    panic!("oh no!");
+});
+assert!(result.is_err());
+```
+
+This behavior was defined in [RFC 1236].
+
+[`std::panic`]: http://doc.rust-lang.org/stable/std/panic/index.html
+[RFC 1236]: https://github.com/rust-lang/rfcs/pull/1236
+
+Historically, this has not been possible in Rust: panics are always
+unrecoverable. And in practice, this is still how they should be used. While
+the current implementation of `panic!` does unwinding, in a future release,
+crates will be able to choose a different implementation, namely, that
+`panic!` causes an abort, rather than unwind. Given that panics are for
+non-recoverable errors only, this is a valid implementation.
+
+If panics are for non-recoverable errors, why provide an interface for
+recovering from them? There are two big use-cases here:
+
+* Embedding Rust in other languages
+* Abstractions that manage threads
+
+For the first case, unwinding across a language boundary is undefined behavior,
+and often leads to segfaults in practice. This means that when embedding Rust
+inside of other languages, you must avoid any code that can possibly panic, or
+rely on the (still unstable and only recently landed) 'abort' implementation of
+panic. Allowing panics to be caught at the language boundary provides more
+options in this case: an issue in Rust can return an error, rather than aborting
+the entire process. This is very important for many use-cases of embedding Rust;
+aborting is not always an acceptable option.
+
+In the second, consider a threadpool library. If a thread panics, it's
+reasonable for the pool to not want to abort, but instead report the error,
+and, depending on the details, possibly even restart the thread, in an
+Erlang-style model. Recovering from these kinds of errors is very useful.
+
+This change had a lot of discussion and thought put into it, by a large group
+of people. A significant worry about this change is that people may use it to
+try and emulate exceptions, which is not the intention of this functionality.
+However, the use-cases for this feature are legitimate, and there are two
+reasons we believe that this will not happen, generally:
+
+* Rust already has a very strong culture of using `Result<T, E>` and `panic!`
+  appropriately, and a new function will not change this culture overnight.
+* A significant part of Rust's userbase desires the abort implementation of
+  panic, and libraries will need to work with both implementations.
+
+See the [detailed release notes][notes] for more.
+
+#### Library stabilizations
+
+About 80 library functions and methods are now stable in 1.8. Lots of stuff!
+The most major is the `std::panic` module, described in the previous section,
+but there's a lot more too:
+
+* Raw pointers gained `as_ref()` and `as_mut()`, which returns an `Option<&T>`.
+* `char` gained the ability to decode into UTF-16.
+* `BTreeSet` and `HashSet` gained the `take()`, `replace()`, and `get()` methods.
+* `OsString` gained some methods to bring it up to parity with `String`.
+* `SocketAddr` and its variants gained `set_ip()` and `set_port()`.
+* Slices gained `copy_from_slice()`, a way to efficiently copy a slice.
+* `ptr::{read,write}_volitile()` allow for volitile reading and writing from a
+  raw pointer.
+* `TcpStream`, `TcpListener`, and `UdpSocket` gained a number of methods that
+  let you set various aspects of the connection.
+
+Finally, many of the types in `libcore` did not contain a `Debug`
+implementation. [This was fixed](https://github.com/rust-lang/rust/pull/32054).
+
+See the [detailed release notes][notes] for more.
+
+#### Cargo features
+
+There were two major changes to Cargo:
+
+First, Cargo has historically not been able to be run concurrently. [This has
+been fixed](https://github.com/rust-lang/cargo/pull/2486).
+
+Second, a new flag, `RUSTFLAGS`, [was
+added](https://github.com/rust-lang/cargo/pull/2241). This allows you to
+specify arbitrary flags to be passed to `rustc` through an environment
+variable, which is useful for packagers, for example.
+
+See the [detailed release notes][notes] for more.
+
+### Contributors to 1.9
+
+We had XXX individuals contribute to 1.9. Thank you so much!
+
+* YOUR NAME HERE