Beginner's Series to Rust

Do people claim seniority by language still? My anecdotal experience has been that per language skill peaks after 6 months to 1 year of full time dev. This time frame shrinks the closer the language is to a known toolchain.

I’d be surprised if companies filtered for rust specific experience.

This is a Rust thread about learning Rust. I believe you will mostly get advice to learn Rust, as would be my advice, but that’s because Rust fits into the work environments that I enjoy.

Databases, distributed systems, backend web systems, webassembly, low level systems programming. Rust is fantastic at these things.

When aiming to learn something new, I find it best to ask myself what I want to accomplish with it. Each of the languages you’ve listed have made significant inroads in various areas, learn the one that fits your use cases the most.

I'm not a huge Go fan, but I do have to give it a lot of credit at its very linear learning curve. You get a few basic concepts, and you're pretty much good to write a great many things. It can really frustrate you if you've done other languages - and you're used to being able to solve problems in many different ways. Rust on the other hand has a what I'd call a factorial curve. You get Hello World, you get into learning how most things return a Result monad... and then you're hit with some really complex stuff. It can be deflating unless you really stick with it. The language is pretty vast, so you won't be re-inventing things like many often do with Go. Both are worthwhile tools to have in your toolbox. I will say that if you're into web-dev, Go will get you results with less "pain". But even that's debatable.

Maybe you should start with "why" you want to learn a new language?

Job? I'd say Go

Command line tools with complex logic for fun and community support? Rust

Julia? Julia.

If you'll forgive me creeping around in your comment history, it looks like you work with PHP? I don't know Julia, but between the other two I suggest you should learn Rust.

Don't get me wrong: Go is a really good language, and eminently practical (and I am ATM working on getting productive with it myself) , but it doesn't have anything particularly novel to teach you, and part of what makes it good is that it's really easy to pick up, so it's something that you can just learn on the fly if you need to.

Inversely, Rust requires a fair bit more ramp up time if you ever need to use it in anger, and there's a lot of fairly novel stuff to learn there that is generally useful, so you'd benefit more from learning Rust as a project.

Depending on your current language, I might recommend Rust because it integrates really well for writing high-performance extension modules for other languages.

For example at $WORK we're slowly rewriting our entire data processing pipeline in Rust, but for awhile we've had a hybrid Rust / Python setup using PyO3, which makes it really easy to build your Rust code into a shared library and call it from Python, with the entire API specified declaratively using derive macros and the GIL handled for you using typestate tokens. Really cool stuff.

Go is low-hanging fruit. You can pick it up in a weekend pretty easily. Rust is a much steeper learning curve, but it will also deepen your understanding of type systems and memory management. Julia seems like it hasn't broken out of the data science niche in full yet, and even there it seems like it hasn't made a ton of headway with respect to marketshare--it doesn't seem like it appeals much to me.

If you want something halfway between Go and Rust, I'd look at Gleam--it seems like a garbage collected Rust, so you get a nice ML-inspired type system without the pedantry of the borrow-checker (sometimes that pedantry is helpful, but rarely so for the applications I write). This would be next on my list of languages to learn.

Also, my favorite way to learn a new language is to write a static site generator. It will take you through a tour of the standard library as well as the third-party library ecosystem. It's a simple project without being a toy.

Many people are rightfully recommending Rust and Go, so I'll weigh in under what circumstances you should learn Julia.

If you regularly find yourself solving problems with Matlab, numpy/torch/pandas or R, you'll be delighted to learn Julia. R and Matlab were great at the time, but really show their age. Python was never meant to be fast, so all the algorithms are in C/C++, making them very hard to inspect, modify or build upon. Julia excels at bridging the gap between high-performance numerical algorithms, great composability through it's type system, and a great syntax for vectorized programming, which makes it straightforward to inspect and change code for very complicated algorithms. For instance, check out Octavian.jl for a pure-julia (fast) alternative to BLAS - or try reading the DataFrames.jl source code (and compare it to the source code of pandas).

Note also that the mentioned applications go beyond data science into general machine learning (+deep learning), simulation science, optimal control, decision making under uncertainty, and many other fields leveraging custom numerical algorithms.

BUT, Julia is (imo) only worth learning if you need to write sophisticated numerical algorithms. If you're more of a systems level programmer, web dev, etc, you might not appreciate what sets Julia apart. Julia and Rust target somewhat different niches, with Rust being much more aimed at developing applications with many interacting components that may not fail. Go doesn't really target numerical programming at all and is instead great for multiple-instruction-single-data (MISD) applications (as opposed to SIMD applications like matrix multiplication).

Definitely Go, you can crank out stuff with it over a long weekend or a few hours a night for a week. You won't be a senior Go programmer but if you know another language, you'll pick it up quickly. You will not pick up Rust and Julia quickly (as compared to go) :) .

You may want to check out Rustlings https://github.com/rust-lang/rustlings/

While I agree with this take, and I vastly prefer text based sources to video, is this true for everyone? This seems to support that, though I bet the study is a little biased:

“More students preferred reading than preferred video (30% to 20%, the other 50% preferred other forms of learning like in-person lectures and hands-on learning). And students who’d consumed the material via reading performed slightly better on the post-learning assessment than students who watched video, although the study’s numbers were small enough that this difference was not statistically significant.”

— https://www.dataquest.io/blog/video-text-learn-data-science-...

There's a link to a text version in the description: https://docs.microsoft.com/en-us/learn/paths/rust-first-step...

I've been playing with Rust in my spare time for a bit, and I have to say it's a very nice language. Nice tooling and generally nice language design. It takes a while to get your head completely around how the borrow checker exactly works, and how to design software around it, but once you get an understanding of it, it becomes a very powerful tool.

Loved the little spectrogram at the bottom. Such a nice touch.

Well that’s past. 2022 will be the year of Rust.

At this point, it might be in that phase "like high schoolers and teenage sex: everyone talks about it, nobody really knows how to do it, everyone thinks everyone else is doing it, so everyone claims they are doing it."

But seriously, I'm seeing more job postings for it. Unfortunately too many are in crypto.