What's on tap for Mozilla's Rust in 2016

Incremental compilation, cross-platform deployment, and features that don't break the language are all planned for the new year

Now that Mozilla's Rust has put its 1.0 release behind it and even clocked a 1.1 release, what's next for the fledgling systems programming language?

Its development team is thinking big: faster and more efficient compiling, fewer missing features, and more ways for Rust to run on multiple platforms.

Rust is positioned as an avenue into system-level programming, but with far more memory safety and behavioral protection built into the language than with C. To quote a blog post that appeared last Friday on Rust's development blog, "You can hack without fear."

Hack more, break less

In that post, Nicholas Matsakis and Aaron Turon of the Rust team outlined several major objectives for Rust to tackle through 2016. They claimed that the goals came from discussions with "the core team, early production users, and the broader community" to find out what would be the most critical additions for Rust. (Matt Asay of InfoWorld cited the community around Rust as one of its big draws.)

Under the category of "infrastructure investments," Matsakis and Turon talk about improving compilation. Some of this is about better integration with existing IDEs or ensuring the Rust compiler doesn't regress between revisions. The latter is done with the Crater testing tool, which checks to see if commonly used "crates" (software packages, in Rust lingo) are not compiling correctly against the most recent version of the Rust compiler.

Even more intriguing, however, is incremental compilation -- so Rust can recompile only the parts of a codebase within a crate that have actually changed. If done right, this could push Rust toward the compilation times clocked by Go, as fast compilation has long been one of that language's selling points.

The blog also noted where a few gaps in the language could be closed over, such as specialization, a feature that allows "a more complete toolkit for zero-cost abstraction." Abstraction in higher-level languages (whether C++ or Python) typically comes at some performance cost, so the claim here is that Rust will be able to provide functions found in other languages without undue costs in performance.

Boldly going to new places

In "Branching out: taking Rust to new places," the authors state, "We're shooting for push-button cross-compiles." That is, building Rust binaries for other platforms should be as easy as specifying a command-line flag. Thus, a developer working on an x86 Linux box could build binaries for ARM without needing to build on ARM itself.

Another "new place" is other languages -- specifically, allowing Rust code to talk to other languages by way of a C-compatible API. But the challenge is in working with language environments with advanced garbage collection, such as the V8 engine for JavaScript. Rust's plan is to add extensions to its compiler so that any code that needs integration with garbage collection can obtain it on demand.

Most of these changes are either about the environment around the language -- compilation, deployment, and so on -- and not about breaking existing functionality. Rust was notoriously unstable before its 1.0 release, so the best news about these forward-thinking features is that they don't signal a return to the days of the language as a moving target.

Copyright © 2015 IDG Communications, Inc.