One question that has come up a few times is “how did you learn Rust?”
I am sharing my path with Rust and the other languages I have experimented with.
I want to emphasise that it is great for any developer to take some of these first steps into other languages.
Once I started on this path, I developed much faster in my primary language and what I was learning.
By learning other languages, I found I could separate the language-specific ideas from the underlying software design principles, making me a better designer and bringing new ideas back to the table.
First, I wanted to highlight some things that impacted my choices and the elements I spent more time on, as this will be different for you and affect how you approach this.
- I did a bit of C++ and computer architecture at university, so while my systems understanding was poor, I had some fundamentals.
- I’m rubbish at working on toy projects on the side.
- I am quite unstructured – skimming through the basics quickly and jumping back and forth as needed.
- I work for myself, so I don’t have to ask permission.
Getting Started – Do I Want To Learn This
At this point, I started exploring Rust around 4 years ago, so my memory is vague.
I wanted to pick up another systems language to expand what I could deliver to customers. But memory issues in C++ made me nervous.
I kept hearing about Rust on hacker news and decided to look further. My first question is, “do I think this is worth investigating more?”.
I don’t remember exactly, but I suspect this looked like this:
* Finding some basic tutorials and guides to understand the syntax and mental models.
* Following some of these to get something basic working with every shortcut possible.
* Finding libraries related to my work and looking at them on GitHub. Can I make sense of them?
Confirming My Interest – Minor Side Projects
My next step was to ensure my understanding of the fundamentals. I tried to reach a point of knowing what I don’t know and looking for places in my business which would exercise them.
They always have to be a little real to me. Otherwise, I struggle to work on them.
A couple of early examples:
- I wanted to understand the industrial libraries, and we had issues with a Modbus system – so I created a small application which printed the values from the Modbus device to the command line.
- I needed to write a LabVIEW driver for a TCP device I didn’t have, so I wrote a simulator in Rust. This project let me experiment with TCP.
In each case, I would know which bit of Rust I wanted to learn (let’s say lifetimes), and so if I hit a problem which needed another part that I didn’t know already, I would either work around it or park the project until I learned it.
This focus was critical:
- I chose a language feature I wanted to learn.
- I sidestepped other features I didn’t know.
- I worked on problems I was already familiar with, so I didn’t also need to learn how to solve the main problem.
This combination meant each experiment had a singular learning goal; otherwise, I tended to get overwhelmed.
Also, note from the examples that they could all be thrown away when I was done – that takes the pressure off!
Committing – Could I do this in Rust?
For the next year or so after deciding I liked Rust, the question was, could I do this in Rust?
Answering this looked like taking projects I had already done, or was doing, in LabVIEW and _designing_ them in Rust. Generally, I didn’t build them all, but I would use the playground or a small project to work out:
- How would I structure this bit in Rust?
- What would the types look like in Rust?
- Is there a library to do x in Rust?
Each of these might have just been a 20-line example solving the major issue in Rust. But it helped me build confidence, especially with lifetimes, which tripped me up the most in these experiments.
This stage also involved absorbing myself in the Rust community, lurking forums, reading blog posts – anything I could to build confidence or find the sharp edge which would stop it from working.
First Steps – Rust Components
At this point, I was convinced I could solve most problems in Rust with enough effort! Now, I needed to gain experience in building larger pieces of code.
Simple questions like how do I structure this in a project? What about CI? Can I be productive?
So, I started looking for changes in projects which could be done in Rust. Not building a whole project but just components of a project where Rust had a clear benefit.
In the end, the key projects that formed this were:
- A device server in Rust – We needed to use some C++ APIs anyway, so I built a component in Rust which could interface to the device and communicate with LabVIEW through TCP.
- A web backend in Rust – This was an easier choice as LabVIEW is not an option anyway, so this was displacing Node.js, which was my preferred language for this.
- Migrating G CLI to Rust for the launcher made it easier to make it cross-platform.
I had to be realistic with my experience and accept I had to take on the additional cost. So, I charged what I would have charged with LabVIEW but allocated double the time to complete it.
I also had to be prepared to throw it away if it didn’t work. However, I did enough prototyping up front to be confident this wouldn’t be the case.
Again, there was a clear benefit to the project to having a separate component anyway. If it was a more minor addition that was just as good as LabVIEW, I stuck with that.
Today – Rust Projects & NI Libraries
That brings me to now – I have confidence that I can do _almost*_ anything I do in LabVIEW in Rust. This confidence means that Rust is now my default in the future.
Rust will be the choice for greenfield projects unless there is a compelling reason not to (and these exist, such as customer commitment to LabVIEW due to other developers or needing to prepare to make the relevant APIs in Rust).
I continue in LabVIEW for existing projects, but a couple have some compelling benefits in Rust. For these, I’ll be migrating new components to Rust with a long-term goal to replace LabVIEW in one case due to significant product benefits.
I’m also working on preparing integrations with key technologies in Rust. I’m working on an FPGA interface library (since I will still use LabVIEW FPGA) and a TDMS library. You can already find my crates for NI System Configuration API and LabVIEW interoperability on crates.io (the Rust package manager)
* .net integration and UIs are still a weak spot.