Rust is an effort to offer the control and performance of a language like C or C++, while making it much difficult to write the kind of security-compromising bugs that are ample in those languages. The language’s handling of memory and memory management is the key to this. Mishandling of memory is some of the biggest problems that come with C, which is mainly due to more data being read or written onto a block of memory than the block of memory it contains. Or it could be reading or writing from blocks of memory that have been de-allocated. Environments such as Java, .NET, and JavaScript handle these through a combination of bounds checking—making sure that every effort to read and write memory is restricted to the memory that has been allotted—and garbage collection—making sure that memory is de-allottted only once all the citations to the memory (through which reads and writes are performed) are ruined. Many developer mistakes and the security issues they cause are protected by these techniques; however, they can come at a price. Garbage collection has a tendency to increase memory usage and can bring some discrepancies in program performance. While using old C or C++ libraries often issues are introduced mostly needed because many of the existing code use these languages. Hence, special attention has to be given when mixing and matching. Languages such as C#, Java and JavaScript also do not use innate code, instead they tend to be converted to innate code only at runtime. It has some advantages like the programs need not be recompiled for different processor architectures, and program safety can be verified at runtime, a useful feature when running an untrusted code, such as in the browser. However, this also has a tendency to restrict performance. Though there’s no vital reason for this, some day runtime code generation would have the potential to constantly beat native code compilers. The highest performance as things stand today comes from compiling once and distributing the native code. Rust uses a very different method. It takes native code for high performance and performs bounds checks to provide some of its safety. However, it doesn’t rely on garbage collection to guard against misuse of memory. It uses a concept of compiler-tracked memory ownership and object lifetimes instead. Objects allotted in memory can only have one owner although ownership can be “borrowed” to let objects be moved to functions. Rust makes sure that the owners of objects have lifespan that are at least as long as the objects themselves. These decisions make sure that many of the typical C errors such as – freeing memory while other code is trying to use that memory – can’t happen in Rust. The language also includes in-built concurrency features, powerful macros and support for generics. These features should allow Rust to be competitive in terms of memory usage and performance with C and C++, without the same exposure to security errors. Similar features were offered by other languages too; however, they have been nothing more than academic novelties. The backing by Mozilla is what makes Rust different from others. Mozilla is establishing an experimental, parallel browser engine in Rust called Servo, along with other elements such as a Rust-based URL parser for the network stack. While the Rust URL parser may not find its way into Firefox any time soon, although a request to optionally include the same was recently opened. They meant that Rust, which is exclusive among niche languages, has a big and important software project that could one day use some amount of Rust code. Combined with a striking feature set, this is a language that may end up finding some real-world success.
