Starting Rust programming language is 11/30/2025 is good?

community
1

Hey Rustaceans!
I’ve been considering learning Rust and wanted to get some honest feedback from the community.

A few things I’m curious about:

  • What made you choose Rust, and why should a beginner pick it up today?
  • How steep is the learning curve for someone new to systems programming?
  • Is experience with languages like C/C++ or Go helpful before starting Rust?
  • How relevant is Rust in real-world projects and career opportunities right now?

I’m mainly interested in systems programming, backend development, and high-performance applications.
Would love to hear your thoughts, experiences, or even warnings before I dive in!

2

We had to develop lots of tools that should work on different OSes. These tools have to be native to minimize dependencies and be fast. We used to use C (even link some tools with musl to make them work on Alpine), and then we decided to choose Rust:

  1. It is safer
  2. It is much more ergonomic (ironically, error handling is even better than, say, Kotlin or C#)
  3. Toolchain is nice and easy to use.

If you are an absolute beginner, I wouldn't start with Rust: it is not the easiest language, but obviously easier than C++.

How steep is the learning curve for someone new to systems programming?

Well, if you understand how memory works, what are heap and stack, what are references, then you can grasp it. If not, it might cost time.

Is experience with languages like C/C++ or Go helpful before starting Rust?

Yes. Sometimes I feel Rust like "C++ with all bad practices disabled at compile time", so if you know C++, it helps a lot.

Both, C and C++ forces you to understand aforementioned memory concepts. People with scripting background, or those, who used GC-based languages, usually have problems trying to understand that, but not C and C++ developers.

How relevant is Rust in real-world projects and career opportunities right now?

Rust is mature enough to be used for real projects. Even Linux kernel accepted it (Torvalds doesn't accept C++, but Rust is ok for him).

Microsoft generates crates for Win32API, so you can access any Windows feature with Rust.

In Python community, there is a company named Astral. They created tools for Python that work much, much faster than those, written in Python.

Since, I believe, late 90s, people were trying to create a "better C". Something that works fast (unlike like scripting languages), doesn't require a huge runtime with GC (unlike Java) and safe (unlike C). Rust is the first successful attempt (IMHO).

One can even use Rust without std making it usable for tiny embedded devices (although I am not sure how stable is it)

Last time I checked, Rust didn't have a stable ABI, so it might be difficult to create and sell closed-source libraries.

5 Likes
3

yes - do you already have that?

C is the most useful - because it is a smaller language with the
least amount of abstractions. It is important to understand the
machine underneath - there is no language better than C for that.

If you want to learn C you could follow Salvatore Sanfilippo's youtube C course - it is in Italian, but yt can dub it into other languages. He starts from scratch and ends up live coding a Forth interpreter in C.

3 Likes
4

If you have experience with C/C++ you will appreciate rust more.

2 Likes
5

Hi there!

What made you choose Rust, and why should a beginner pick it up today?

I was always fascinated by computer graphics but never really liked C++, not exactly because of memory safety but more about developer ergonomics. Dependency management in C++ is terrible; the language has a number of package managers but most of them don't work properly and can't interop. Of course, there's a reason why C++ is dominant in graphics: we need a native language that allows us to create all sorts of performance-sensitive stuff, and this has serious constraints. Rust, for me at the time, looked like the obvious choice. Different from Go and C, where the language is small and you solve problems by writing more Go/C code, Rust looks more like C++, where the language is packed with features which allows me very high expressiveness but without the pain points that I noted before. I don't believe that Rust is the best language for beginners though.

How steep is the learning curve for someone new to systems programming?

I came from a 6-year C# backend background. The pain goes away after the first month, at least for me. The more Rust code you write, the easier it becomes.

Is experience with languages like C/C++ or Go helpful before starting Rust?

No doubts about it. There are a lot of Rust features that came from other languages that you will recognize. For a person like me that came from a Garbage Collected language, your major pain will be the borrow checker, but this is a matter of writing more Rust code, you will master it eventually.

How relevant is Rust in real-world projects and career opportunities right now?

I can't say about other markets. In Brazil, it's growing but with fewer opportunities than other languages for now. The good thing is that the salaries are way higher than other languages. I don't know if you will find the same thing where you live, yet companies that use Rust as I see normally are very friendly with remote work, so maybe this is an option. When talking about real projects, you can easily pick great use cases beyond obvious things like the Linux kernel. For example, substantial parts of serverless services in AWS run on Rust. AWS Lambda and Fargate Serverless all use a microVM software written in Rust called Firecracker.

1 Like
6

I've worked on graphics and compression. In these areas higher-level languages were limited to primitives that have already been implemented in native languages. Rust has massively improved my ability to write multi-threaded code and support dependencies on multiple operating systems without endlessly fighting fragmented build systems.

Today Rust still gives you access to the full speed of your CPU, lower-level parts of the OS, so instead of searching for a command/tool/library to do a thing, you can do the thing (and also get a library for it — easily).

Rust can be hard and annoying in the beginning, but it's probably the easiest systems programming language if your goal is to write robust, stable, fast programs.

C will feel easier in the beginning, but eventually you'll discover all the hard parts of systems programming yourself (related to dealing with the complexity of programs, memory management, multi-threading, library interfaces), and that a compiler limited by a bunch of decisions from 1970/80s can't help you with many of them.

C++ will be hard and annoying like Rust, but for wrong reasons (mainly fighting its C roots and other past mistakes it can't/won't fix).

No. C and C++ are similar enough that you will see analogies between them and Rust, but they're different enough in the details that it will cause you to make invalid assumptions.

For example, I've seen many C devs notice that Rust references are very similar to pointers, and cause themselves headaches when they try to use references like pointers to make linked lists or use in an observer pattern.

C is sometimes called "portable assembly" and said to be the lowest level language teaching you "how the machine works", but that hasn't been true for decades. CPUs have gotten weird: they have out of order execution, branch prediction, cache hierarchies, hyperthreading that don't exist in C! Often don't even exist in their own assembly! There's also a ton of quirks of multicore programming, SIMD, signals, ABIs, memory allocation, VMM, process isolation, OS and other hardware interfaces. It's all way bigger than C, and can be learned directly, not through tiny lens of an old language.

Depends what's your target. There are companies where Rust is already the standard. There are companies where Rust is a new thing for some green-field projects. But also there are whole areas like AAA gamedev and Python-framework-dominated machine learning where Rust barely exists.

4 Likes
7

Sometimes it might be good to use clear statements, but this "No" is really a bit strange.

First, the exact question was not, if it makes sense to learn C/C++ before Rust, but if experience in it is helpful. And of course it is -- I think most people would agree.

If learning C before Rust just to use later only Rust makes sense is a more controversial question. Personally I would say yes, as C is such a tiny and primitive language, that it is quite easy to learn the basics of systems programming with it. And knowing C is always a good thing, as most libs are written in C, and we might have to interface to it by FFI.

Of course one can start with Rust without any prior programming experience, or with only a background in a language like Python. I think I would have not been able to do that -- as a young boy I started with some Basic on the C64, later with Pascal at first year at university, and parallel with Modula-2, some C, and later Oberon on the Amiga. Well, of course today the people are all much smarter than me, and have Internet and AI as support.

Still, my impression is that most people with a C or C++ background have not too much problems with Rust, while absolute beginners in programming, or people with only a Python background, have much more problems. I observed the same for Nim over a period of 9 years -- while Nim had syntactically some similarity with Python, people knowing only Python had some problems with Nim, as the systems programming background was missing.

As we discussed already in much details, it depends a lot on learning resources. For C there exist a few very basic beginner courses, that explains all the low level stuff -- bits and bytes, number encodings, internal working of a CPU, data- and address bus, RAM, stack and heap, pointer use, linked lists, and all that in much detail. For Rust we do not really have that.

PS: I think you are the one who said that Rust compares more to C than C++. I thought about it, and for me Rust is still more an equivalent to C++, not so much for C. Well, C++ is object orientated, and Rust not. But Rust is a complex languages, with all the advanced data types like vectors and hash maps, and some form of automatic memory management without a GC like RAII in C++. While C is a tiny, quite primitive language, more a portable assembler as you said. So for me Rust compares to C++.

4 Likes
8

The impression I've gotten from a previous time this came up here is that it's something of an open question if it's a net positive or negative to have learned C before Rust, specifically because you're going to be bringing in assumptions about what you should be able to do, and so you're more likely to attempt things that are bad ideas in Rust and get yourself in a twist. I guess the assumption there , though, is that you can as easily use a "dumb Rust" subset to learn the same things as you would in C, which may very well not be true!

I don't think C or C++ makes that much of a difference in this context, honestly; at most you have a few more comparison points for things like "Box = unique_ptr" etc, but there's at least as many things that are not actually the same and are more misleading than helpful (eg move constructors vs moved-from semantics)

9

AIUI unique_ptr is more like Option<Box<T>>> because it doesn’t guarantee that the pointer it holds is not null.

I don’t know if there are other subtle differences between them, too, but I’m curious to hear about them if so.

10

I have spend most of my career working on software that needs the performance and predictability of a compiled to native code language. Things like real time control systems, embedded systems, things on micro-controllers. But also server side services that need the performance and low latency. After years of using all kind of languages that are now mostly obsolete that left us with little choice, C and C++. Rust fulfils all those requirements whilst also offering features that ensure correctness and robustness that no such language has offered before.

I believe that a total beginner to programming could be introduced with Rust. Yes, Rust is a complex language with many features but one could start with baby steps that are interesting and useful. I have this belief because as young teenagers we were introduced to programming with BASIC and expected to be able to learn and use assembler at the same time.

Problem is I see little in the way of teaching materials for introductory programming using Rust targeted at absolute beginners.

See above. But if we are talking "systems programming" that is a huge and complex thing no matter what language. Do you mean writing operating system kernels or databases or what?

Fore sure experience with almost any other language will be helpful for someone new to programming coming to Rust. Personally I would encourage a look at C as it is a fairly simple language. C will show all the problems that Rust has been built to solve. I would not suggest C++, it's huge and complex, suffers all the same problems as C and is generally a waste of time to learn all that id what you want is to use Rust.

No idea really. But I notice in the last year or so all kind of big companies are getting into Rust. The likes of Google, Microsoft, Cloudflare and so on.

We, as a five man company, have been using Rust for 6 years now. It has been working out very well. Still can't get half my partners off of Python though :frowning:

1 Like
11

This firm "No" is my honest opinion. I've known C very well before learning Rust, and IMHO it's been more of a problem than a benefit.

Rust has its own concepts and design patterns that don't exist in C, or are applied quite differently. Rust is pretty firm about doing things the "Rust way", so learning Rust involves unlearning incompatible habits and assumptions brought from C (e.g. viewing things from C's perspective of by-value vs by-reference is counter-productive when Rust's by-move vs by-borrowing syntax looks similar, but the meaning is different enough to cause fighting the borrow checker). When you know how to do stuff in C, and ask how to do it in Rust, you'll get "well, it depends…" and be asked to take three steps back in your XY problem.

The commonalities are actually small. C being a "simple" language doesn't give you much, and what it has analogous to Rust turns out to be still quite different in the details, so you still have to learn Rust's flavor of everything in detail. There's a lot to know about systems programming and programming in general, but that's not just C.

I understand that knowing C in addition to Rust can be useful (and even necessary in practice), but strictly from perspective whether knowing C before Rust is beneficial, I think "No". It's fine if you disagree. I'm just sharing my experience.

I think the reverse can be true: it is beneficial to know Rust before learning C. For me understanding memory management through the lens of ownership and borrowing has been enlightening, and helped me understand data flow in C better than just a challenge of strategically putting free() so that it neither leaks nor crashes. Similarly with Send/Sync instead of C's ad-hoc per-function arbitrary conditions.

4 Likes
12

It took me a long time to realize this myself. Over the years I've argued that knowing C before learning Rust was beneficial. But when I think back, the biggest mental blockers I've had to overcome was my brain trying to get me to write C-in-Rust.

Obviously knowing other languages is good, but I wrote C code almost every day for 20+ years, and I'm pretty sure that caused a fair bit of hard-wiring in the brain that didn't serve me well when I started using Rust.

1 Like