[thesuperbigfrog]

C is the best choice to learn systems programming.

C is the simplest of C, C++, or Rust and most other languages have C interop or foreign function interface.

First learn C and then you can learn Rust or C++ if needed. The concepts you learn in C programming will help you to better understand the more advanced concepts used in Rust or C++.

Recommended first book:

https://en.wikipedia.org/wiki/The_C_Programming_Language

[remexre]

Agree that C is easier to explore the concepts in, but knowing enough C to know why e.g. [0] gets the behavior it does is IMO not useful if the goal is to learn the _concepts_ before switching to a language that doesn't do this kind of thing.

So, IMO worth jumping to Rust as soon as you feel confident with the stack vs the heap, use-after-frees, etc.

[0]: https://godbolt.org/z/x7bf4edo9

[billforsternz]

You lost me here with p += (&ys[2] - &xs[0]);

I mean, why would I expect the parenthesised subtraction to do anything I can rely on? Or did you mean (&ys[2] - &ys[0]) ?

[remexre]

Because if memory is a big array of bytes and pointers are indices into that big array, that should be numerically valid. And indeed, if instead of making xs and ys separate arrays, one writes:

    int zs[20] = {0};
    int *xs = &zs[0], *ys = &zs[10];

then no perplexing behavior is observed.

Of course, any veteran C programmer will point at that being UB, but the big-array-of-bytes (with holes) model is what one sees in userspace assembly, and what I assume most systems programmers think about most of the time, rather than the C memory model.

I wouldn't recommend that someone trying to learn systems programming (as opposed to C or C++ as languages) spend, like, any time whatsoever memorizing the list of C UBs (and then learning about pointer provenance, exposed addresses, etc., I suppose?). Assembly, Forth, safe Go, and safe Rust don't have the same kind of UB, and (Linux) kernel C has a different set of UBs than userspace/spec-compliant C.

[scoutt]

Why always give the most contort examples? Jeez...

OP is asking about a language to learn. Let them fail, to learn and understand.

And after all, C was and actually is moving the world forward, and thanks to C you have the possibility to write and run programs in Rust. Rust can't do anything if not by calling C APIs. Removing C code from any system is removing the legs from the crab.

So why not choosing C? Seems wise to me. Think about the thousands of lines of C code executing across the world so you can just download a crate. It seems to me that your first interest, as a Rust user, is to have C programmers around so you can run your Rust code.

I'll contribute by telling my personal experience after 20 years of embedded and system C: the fear spread by Rustaceans (regarding UB) is uber-exaggerated, specially at learning stages.

Before you bring exploits up, not every C application is connected to internet or has a user interface or runs as root. Just a portion.

[bmcooley]

Same here. Embedded programmer, primary language being C. I sat here staring at that line for a solid 30 seconds trying to understand the intent - it’s nonsensical. I read your comment and see the intent you’re guessing at but… you would not generally write C like this. Pointer arithmetic is to be avoided, and this case is contrived. I don’t think a compiler warning would be thrown here though - maybe that is the point, that the language and compiler would not catch this issue and that typos or novice learners can make compilable mistakes too easily?

[remexre]

I mean, this surely wouldn't be written as obviously as this in real code. It'd be somewhere in a data structure that packs to be able to fit better in a cacheline, and has something like:

    struct edge {
        struct node* src;
        int dst_offset;
        int label;
    };

Knowing about integer overflow, the original programmer carefully wrote overflow checks where dst_offset gets computed, and the code was correct. Nodes were allocated into one contiguous array, and edges were allocated into another.

Later, someone else changed how nodes were allocated, so adding a new node would never trigger a realloc of the whole graph. Instead, a linked list of node arrays is allocated. Suddenly now, computing dst_offset is UB, and yet, the observed behavior of the resulting program is the same.

Even later, someone updated GCC on the CI machine, and now the inliner is more aggressive. Suddenly, mutations to node labels are unreliable, and edges are found to not refer to any node in the graph, except when debug logging logs the address they actually refer to.

This is the kinda thing that requires an understanding of UB that has nothing to do with the actual hardware to diagnose and fix, which I think is really unnecessary for a beginner.

[joseph8th]

Biases because that's how I learned, but yeah... I agree. Learning C will help you be a better programmer in any C-like language.

C forces you to think like a programmer. Once you grasp that, you can learn most other languages with relative ease.

Maybe not counting Lisps.

[bombcar]

I highly recommend learning enough C that you at least decently understand pointers. That’s a major stumbling block and worth overcoming.

[mr_00ff00]

+1 and I say this as a rust fan.

The rust programmers that learned C first always have very elegant solutions and have the least issues in their unsafe blocks.

C to learn how memory works and how to manage resources, then Rust to understand how to use a higher level systems language for more productivity in places where it helps.

I work as a C++ dev and there are jobs in it, but unless you are trying to work a C++ job, the other two are wayyy better.

[josephg]

Another rust fan here (with 3 years experience writing it full time at this point). I agree with all of this.

C knowledge also helps to understand what rust's borrow checker is actually doing. And it will teach you what Box / Rc / etc are for. Its surprisingly easy to write rust code that Box everywhere, and runs very slowly in practice. (I've seen rust programs run slower than their javascript equivalents). Learning C first will give you the right knowledge base to appreciate rust and use it well.

[jandrewrogers]

C is a good learning language for systems programming, no doubt about it. All of the elementary concepts are exposed in a simple way that will server you well in any systems programming language. It was also a language design that informed many of the systems language designs that came later, so the history is educational.

However, it is not a productive systems programming language these days compared to C++, Rust, or Zig.