I have recently been wanting to work on a new automaton which requires particle physics, some glowy graph drawing, and machine learning algorithms. I am working presently to make these libraries in rust. My machine learning library was the first thing I wrote in Rust, and I intend to improve it significantly with what I've learned so far before publishing it. My particle physics library is at version 1.0.1 and I have published it on crates.io. I intend to add Barnes-Hut tree simulation to the library at some point, and a branch exists in the repository with code for Octrees, but I found that this was a complicated ordeal and have suspended this effort to continue working on other things.
Right now I am working on glowygraph, the library intended to use shaders to draw fancy glowing orbs and lines. This will be used to write two applications I plan to work on: a library for drawing and navigating 3d force-directed graphs and the automaton I am planning to work on.
Now, after having used Rust a fair amount, I feel that I can write this blog post to comment some of my thoughts about it. Firstly, the Rust community is amazing and filled with systems programmers and people that care about large project maintainability. People are constantly making good libraries and publishing them to crates.io. We have a plethora of libraries and applications written in Rust already, despite it being so new. The most important thing Rust has to offer is its powerful language saftey. Designers have strong powers to prevent users from incorrectly using the API of their libraries and modules. Rust also guarantees you won't cause a segfault so long as you don't use an "unsafe" block (which gives you the freedom of pointers and unsafe operations), or use any libraries with bugs in them. It is common to never get a segfault in rust even during development, and for userspace applications unsafe blocks are not necessary even for large projects. Libraries might have to use unsafe blocks to implement things that are safe, but Rust does not understand are safe. On top of this, Rust guarantees that you will have no race conditions, again so long as you avoid unsafe blocks. Rust is built around threading, but the standard library is a bit restrictive. I recommend the crate (library) crossbeam if one needs more powerful threading capabilities.
Another important point about Rust is how easy it is to use libraries. Rust has a build system called cargo which is quite simple but amazingly powerful. It connects with crates.io and makes publishing crates as easy as running a single command. Using crates is as simple as specifying a version in the Cargo.toml file for the project. It automatically fetches the most recent compatible version using semantic versioning from crates.io. This is amazing power at a Rust developer's disposal. On top of that, cargo supports tests (built and ran), examples (built and not ran), and benchmarks (built, ran, and timed), which are all handled when running 'cargo test'.
I could type for hours about the potential benefits of Rust as a replacement for C++, but just know that learning it is absolutely worth it. In the future I see Rust replacing C++ as the systems language of choice for writing new applications when all of the dependencies are available. If you are interested, watch this video to see what Rust is all about (it is a bit old, but the ideas are the same):
I will try to keep the blog updated again with projects as I work on them. College is my primary focus now, but my projects are second in line, and this is my best way to keep people updated in as much detail as they like.
