Now Reading
Ask HN: Rust or C or C++ in 2023?

Ask HN: Rust or C or C++ in 2023?

2023-06-05 20:30:55

The key to any of embedded, system, or low-level programming is as much about learning how the computer actually works to a reasonable degree. You are not programming to an abstract computation model. You are moving bits and bytes around and generating assembly code and talking to the machine at quite a low-level.

So while Rust and C++ are higher-level languages with all kinds of nice features to be safer, concise, structured, etc. they are not good at all for learning how to work at this low-level. Wielding either of them well for systems code is quite advanced.

C and assembly are where you really need to start.

c doesn’t have any good game engines or physics libraries. missing other stuff too. otherwise it’s perfect.

passing structs to functions is probably the way, but a struct with functions works too.

C is an abstract computer as much as any virtual machine. Now this computer is quite simple compared to the abstract machines of Rust and C++ but is doesn’t have much to do with how a computer actually works.

It really depends on the kind of systems programming you are doing. As a rough heuristic, C for embedded because portability across odd silicon; C++ for complex software close to the metal, like database kernels; Rust for somewhat higher level software — not so close to the metal — where performance matters. Right tool for the job, and all that.

All are good choices in the right context. None is unambiguously superior for all systems programming use cases.

C. It’s the only language people writing bootloaders, writing kernels, and writing serious userland code kinda sorta agree on.

Maybe someday it’ll be rust, but if so that day isn’t this year or next. Plenty of time to pick it up for your next job.

For low-level programming in 2023 I would honestly start with Zig.

It offers the same system programming capabilities as C but makes it much easier to write correct programs.

(If Rust is the “better C++”, then Zig is the “better C”).

Learn enough C to encounter the pain points C++ & Rust are trying to solve. C is simple, but not easy.

Then learn enough Rust to be productive.

Then learn enough C++ to interact with the enormous amounts of existing C++ code.

Once you know a bit of all 3, decide where to focus based on the work you’re trying to do. Rust is the easiest, but least widely supported. C is necessary either way, unless you’re working for Microsoft where C++ fills that role.

> C is simple, but not easy.

I think I know what you’re trying to say, but unfortunately C is anything but simple. The semantics are riddled with surprises of all kinds. It’s unlikely the average C programmer has never written a program with undefined behavior, for example.

> It’s unlikely the average C programmer has never written a program with undefined behavior

I’d add that the average C programmer can’t spot UBs before they cause a problem, they are not your average bug. Unless you’re very well read or are just told about them, that is.

Right. But you can fumble through writing a lot of (maybe subtly wrong) C code. I certainly did for many years. You can’t fumble through writing Rust. Its an order of magnitude more difficult to learn because the compiler won’t compile “bad” code. Unlike C all the pain happens up front.

Rust hurts when you’re learning it. C hurts when you’re trying to debug your program.

If you’ve never written low level code before, I wouldn’t start with rust. Zig or C are both much better options when getting started. But learning rust eventually will make you a better programmer.

C is forever. It’s the only language where the community aspires to target as early a specification as they can. This keeps C in the hands of the programmers and not the compiler creators.

I would choose Rust because it has much better developer ergonomics than C. Even the little things like having a standard linter and package manager (Cargo) go a long way in writing idiomatic code. You can’t go wrong with either choice, so choose the one that makes you most productive.

This is an underrated advantage of Rust. And, I can expect code to compile (or compile + flash for embedded) by running `cargo run` on Linux or Windows, vice expecting a dependency mess with the C toolchains I’ve encountered.

+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.

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.

See Also

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.


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.

This question is bad. Learn all three. You’re not taking a class at school. There is no penalty for dropping out. Just start learning and if it’s boring, stop.

rust-analyzer, clangd, and clion are all fantastic. why not try both?

cpp feels better to me now, but that could easily change.

rust-analyzer is a good experience, and cpp is not exactly fast, just faster.

If you are targeting embedded devices, I’d go with C++. If you are targeting super efficient cloud services, I’d go with Rust.

rust, c++ and (to a certain extent) c are all quite high level languages. if you want to learn low-level programming, learn it for the assembly language for the processor you are interested in. this will make learing languages like c, and the others easier – i know it did it for me.

I assume this question is about which language to learn, rather than which language to use for a particular project assuming you’re at least somewhat familiar with all three.

C++ is not a bad place to start, as any decent course in it will, after the basic concepts of variables, loops, arrays, functions, pointers and memory, algorithms & data structures, introduce you to both classes and inheritance and encapsulation (the typical object-oriented paradigm) as well as how to write functions with nested lambdas (the basic functional paradigm). From there you can pick up almost any ‘higher-level’ language like Java, Python, etc. that utilizes some kind of virtual machine/interpreter to run the code, the various pure functional languages and so on.

Learning C and/or Rust is then a lot more accessible I think. You’ll have some grasp of why ‘memory-safe’ Rust became fairly popular, and of why C’s more low-level and simpler approach (no classes, inheritance, etc.) relying on structs, function pointers, etc. instead is still attractive, flaws and all.

The underlying theme though is that these languages all compile directly without any Python-like ‘bytecode’ intermediate, so probably at some point diving into the assembly output for specific platforms (x86-64, ARM, RISC-V) will be worthwhile, for which is the place to go.

Source Link

What's Your Reaction?
In Love
Not Sure
View Comments (0)

Leave a Reply

Your email address will not be published.

2022 Blinking Robots.
WordPress by Doejo

Scroll To Top