5 ms·

It's not quite a fully formed argument, but I'm coming to the view that Rust mostly requires less cognitive load than other languages. I'm coming at this from t

by K0nserv 10mo ago

It's not quite a fully formed argument, but I'm coming to the view that Rust mostly requires less cognitive load than other languages. I'm coming at this from the perspective of "cognitive load" meaning, roughly "the measure of the number of things you need to keep in working memory". Rust is no doubt difficult to learn, there are many concepts and a lot of syntax, but when you grasp it cognitive load is actually lower. Rust encodes so much more about the program in text than peer languages so there are fewer things to keep in your head. One good example of this is pointer lifetimes in Zig and C which you have to keep in your head, whereas in Rust you don't. My own appreciation for Rust is rooted in humility. I know I'm an overgrown monkey prone to all kinds of mistakes. I appreciate Rust for helping me avoid that side of me

zozbot234 10mo ago
> Rust is no doubt difficult to learn, there are many concepts and a lot of syntax People love to say this, but C++ is routinely taught as a first programming language to novice programmers (this used to be even more clearly the case before Java and Python largely took on that role) and Rust is undoubtedly simpler than C++.
- tehjoker 10mo ago
  That's true, but as someone that doesn't do much rust, C++ is a language where there are fewer restrictions and you can use little parts of the language, whereas Rust is supposed to be a simpler language overall, but with more concepts to learn up-front to prevent things that happen where there are no rules....
  - zozbot234 10mo ago
    You can use "little parts of the language" in Rust too; the cleanest and most foundational part of Rust is pure value-based programming with no mutability or referencing at all, much like in a functional language (but with affine types!). Everything else is built quite cleanly on top of that foundation, even interior mutability which is often considered incredibly obscure. (It's called "interior" because the outer cell's identity doesn't really mutate, even though its content obviously does.)
  - bsder 10mo ago
    Precisely. You can subset C++ and still knock out a program. You cannot subset Rust and still create a program.
    - simonask 10mo ago
      You can absolutely make a complete, featureful program in Rust without naming a single lifetime, or even without dealing with a single reference/borrow. But Rust is a dramatically smaller language than C++. The various subsets of C++ people usually carve out tend to be focused on particular styles of programming, like “no exceptions” or “no RTTI”. Notably never things like “signed integer overflow is now defined”, or “std::launder() is now unnecessary”.
      - filleduchaos 10mo ago
        Discussions about Rust sometimes feel quite pointless because you can be several replies deep with someone before realising that actually they don't know much about the language and their strongly-held opinion is based on vibes.
        bsder 10mo ago
        Exactly. Claims like "even without dealing with a single reference/borrow." When you have this stuff in "Hello World": Egui Hello World: ui.add(egui::Slider::new(&mut age, 0..=120).text("age")); Ratatui Hello World: fn render(frame: &mut Frame) { or fn run(mut terminal: DefaultTerminal) -> Result<()> { loop { terminal.draw(render)?; if matches!(event::read()?, Event::Key(_)) { break Ok(()); } } } And I didn't even break out the function chaining, closure and associated lifetime stuff that pervades the Rust GUI libraries. When I can contrast this to say, ImGui C++: ImGui::Text("Hello, world %d", 123); if (ImGui::Button("Save")) MySaveFunction(); ImGui::InputText("string", buf, IM_ARRAYSIZE(buf)); ImGui::SliderFloat("float", &f, 0.0f, 1.0f); which looks just slightly above C with classes. This kind of blindness makes me wonder about what universe the people doing "Well Ackshually" about Rust live in. Rust very much has an enormous learning curve and it cannot be subsetted to simplify it due to both the language and the extensive usage of libraries via Cargo. It is what it is--and may or may not be a valid tradeoff. But failing to at least acknowledge that will simply make people wonder about the competence of the people asserting otherwise.
- vablings 10mo ago
  I gave up on a C++ after trying to learn on and off for years. LNK1009 still haunts me in my sleep. I am now an avid self-taught rust programmer and I feel like I have the power to create almost anything I can imagine using rust. This is great for hobby people
- tialaramex 10mo ago
  C++ as First Language seems like an especially terrible idea to me. Maybe I should take a few months and go do one of those courses and see whether it's as bad as I expect. The nice thing about Rust as First Language (which I'm not sure I'd endorse, but it can't be as bad as C++) is that because safe Rust ropes off so many footguns it's extremely unlikely that you'll be seriously injured by your lack of understanding as a beginner. You may not be able to do something because you didn't yet understand how - or you might do something in a terribly sub-optimal way, but you're not likely to accidentally write nonsense without realising and have that seem to work. For example yesterday there was that piece where the author seems to have misunderstood how heap allocation works in Rust. But, in safe Rust that's actually harmless. If they write their mistake it won't compile, maybe they figure out why, maybe they give up and can't use heap allocation until they learn more. I haven't thought too hard about Zig as first language, because to me the instability rules that out. Lecturers hate teaching moving targets.
  - AnIrishDuck 10mo ago
    As somebody that "learned" C++ (Borland C++... the aggressively blue memories...) first at a very young age, I heartily agree. Rust just feels natural now. Possibly because I was exposed to this harsh universe of problems early. Most of the stupid traps that I fell into are clearly marked and easy to avoid. It's just so easy to write C++ that seems like it works until it doesn't...
- vips7L 10mo ago
  I don’t know anyone that learned C++ first. Maybe I’m younger in generations, but Java was the first thing everyone learned at my university.
  - ekidd 10mo ago
    I belonged to the generation that graduated into the rising dotcom boom. Around that time, lots of universities taught C++ as the first serious language. (Some still started with Pascal.) The main thing a lot of had going for us was 5-10 years of experience with Basic, Pascal and other languages before anyone tried to teach us C++. Those who came in truly unprepared often struggled quite badly.
  - Keyframe 10mo ago
    Just after Pascal vs C craze in mid to late 90's for sure. That is quite a different C++ than the one of today however.
  - brabel 10mo ago
    I did. Though a few years earlier I had attended a class where Pascal was used (however, it was not the main topic, it was about robotics). C++ was what I learned first in a "real" computer science class. In later years, we did move to Java. And I initially hated Java :D but ended up making a career using it. Java in the 2000's was a poor language, but after Java 8, it has become decent and I would say the latest version, Java 25, is a pretty good language. This thread is about Zig though! I want to like Zig but it has many annoyances... just the other day I learned that you must not print to stdout in a unit test (or any code being unit tested!) as that simply hangs the test runner. No error, no warning, it just hangs. WTF who thinks that's ok?! But I think Zig is really getting better with time, like Java did and perhaps as slowly. Some stdlib APIs used to suck terribly but they got greatly improved in Zig 0.15 (http, file IO and the whole Writergate thing), so I don't know, I guess Zig may become a really good language given some more time, perhaps a couple of years?!
  - K0nserv 10mo ago
    I learned C++ first. Like many I wanted to make games so I started programming before high school. I think our first high school classes were also in C++ tbf.
com2kid 10mo ago
The mentality around lifetimes is different in Zig if you are using it for the correct types of problems. For example, a command line utility. In a CLI tool you typically don't free memory. You just allocate and exit and let the OS clean up memory. Historically compilers were all like this, they didn't free memory, they just compiled a single file and then exited! This ended up being a problem when compilers moved more into a service model (constant compilation in the background, needing to do whole program optimization, loading into memory and being called on demand to compile snippets, etc), but for certain problem classes, not worrying about memory safety is just fine. Zig makes it easy to create an allocator, use it, then just free up all the memory in that region. Right tool for the job and all that.
- dnautics 10mo ago
  I'm not convinced that you can't borrow check in zig... (disclaimer, i'm working on compile time memory safety for zig)
  - DetroitThrow 10mo ago
    I had no idea you were working on Zig dnautics. If you were to add borrow checking to Zig, it would make it much easier to justify using it at my current workplace.
    - dnautics 10mo ago
      clarifying: It's just an experiment for zig PL, not affiliated with zsf: http://github.com/ityonemo/clr http://github.com/ityonemo/clr was where i got last year. this december im doing a "prototype" which means its going to be done in zig and im going to clear sone difficult hurdles i couldn't do last year.... also accepting sponsors, details on page. also disclaimer, im using heavy amounts of ai assistance (as implied in the preview video)
      - bertmuthalaly 10mo ago
        rad! sponsored
DetroitThrow 10mo ago
>My own appreciation for Rust is rooted in humility. I know I'm an overgrown monkey prone to all kinds of mistakes. I appreciate Rust for helping me avoid that side of me I think we've heard these arguments ad nauseum at this point, but the longer I use Rust for ensuring long-term maintenance burden is low in large systems that I have to be absolutely, 10,000% correct with the way I manage memory the more it seems to reduce the effort required to make changes to these large systems. In scenarios where multiple people aren't maintaining a highly robust system over a long period of time, e.g. a small video game, I think I'd absolutely prefer Zig or C++ where I might get faster iteration speed and an easier ability to hit an escape hatch without putting unsafe everywhere.
hndc 10mo ago
> I'm coming to the view that Rust mostly requires less cognitive load than other languages. This view is only remotely within the bounds of plausibility if you intended for "other languages" to refer exclusively to languages requiring manual memory management
- tialaramex 10mo ago
  I don't think so? In languages like Java their version of the Billion Dollar mistake doesn't have arbitrary Undefined Behaviour but it is going to blow up your program, so you're also going to need to track that or pay everywhere to keep checking your work - and since Rust doesn't have the mistake you don't need to do that. Likewise C# apparently doesn't have arbitrary Undefined Behaviour for data races. But it does lose Sequential Consistency, so, humans can't successfully reason about non-trivial software when that happens, whereas safe Rust doesn't have data races so no problem. Neither of these languages can model the no-defaults case, which is trivial in Rust and, ironically, plausible though not trivial in C++. So if you have no-defaults anywhere in your problem, Rust is fine with that, languages like Go and Java can't help you, "just imagine a default into existence and code around the problem" sounds like cognitive load to me. Edited: Fix editorial mistake
  - GoblinSlayer 10mo ago
    This was linked below: https://github.com/DioxusLabs/blitz/pull/292/commits/e539f523664940eeb9127fa44776855d5aba5904 https://github.com/DioxusLabs/blitz/pull/292/commits/e539f52... guess I'll call it Cheap Cloudflare Mistake.
    - tialaramex 10mo ago
      The problem Cloudflare had, and from what it seems, still have is that they don't actually test software at small volumes before global deployment. I would guess that two outages in quick succession means the voices saying "You need to test everything properly" might win, but perhaps not. The Billion Dollar mistake is about not even having the distinction shown in the commit you linked. In languages with this mistake a Goose and "Maybe a Goose or maybe nothing" are the same type.
filleduchaos 10mo ago
Oh, I do have a fully-formed argument for this that I should probably write out at some point :) The gist of it is that Rust is (relatively) the French of programming languages. Monolingual English speakers (a stand-in here for the C/C++ school of things, along with same-family languages like Java or C#) complain a lot about all this funky syntax/semantics - from diacritics to extensive conjugations - that they've never had to know to communicate in English. They've been getting by their whole life without accents aigu or knowing what a subjunctive mood is, so clearly this is just overwrought and prissy ceremony cluttering up the language. But for instance, the explicit and (mostly) consistent spelling and phonetics rules of French mean that figuring out how to pronounce an unfamiliar word in French is way easier than it is in English. Moods like the imperative and the subjunctive do exist in English, and it's easier to grasp proper English grammar when you know what they are. Of course, this isn't to say that there are no parts of French that an English speaker can take umbrage at - for example grammatical gender does reduce ambiguity of some complex sentences, but there's a strong argument that it's nowhere near worth the extra syntax/semantics it requires. On top of all that, French is nowhere near as esoteric as many monolingual Anglophone learners make out; it has a lot in common with English and is easier to pick up than a more distant Romance language like Romanian, to talk of a language in a more distant family (like Greek or Polish). In fact, the overlap between French and English creates expectations of quick progress that can be frustrating when it sinks in that no, this is in fact a whole different language that has to be learned on its own terms versus just falling into place for you. Hell, we can take this analogy as far as native French speakers being far more relaxed and casual in common use than the external reputation of Strictness™ in the language would have one believe.
- xeonmc 10mo ago
  I suppose Rust users are indeed the Frenchmen of programmers, on more aspects than mentioned.
  - filleduchaos 10mo ago
    Oh yes, there is definitely a reputation of snobbery and rudeness. But I was trying to be somewhat fair/neutral :)

by K0nserv 10mo ago

zozbot234 10mo ago

> Rust is no doubt difficult to learn, there are many concepts and a lot of syntax People love to say this, but C++ is routinely taught as a first programming language to novice programmers (this used to be even more clearly the case before Java and Python largely took on that role) and Rust is undoubtedly simpler than C++.

tehjoker 10mo ago
That's true, but as someone that doesn't do much rust, C++ is a language where there are fewer restrictions and you can use little parts of the language, whereas Rust is supposed to be a simpler language overall, but with more concepts to learn up-front to prevent things that happen where there are no rules....
- zozbot234 10mo ago
  You can use "little parts of the language" in Rust too; the cleanest and most foundational part of Rust is pure value-based programming with no mutability or referencing at all, much like in a functional language (but with affine types!). Everything else is built quite cleanly on top of that foundation, even interior mutability which is often considered incredibly obscure. (It's called "interior" because the outer cell's identity doesn't really mutate, even though its content obviously does.)
- bsder 10mo ago
  Precisely. You can subset C++ and still knock out a program. You cannot subset Rust and still create a program.
  - simonask 10mo ago
    You can absolutely make a complete, featureful program in Rust without naming a single lifetime, or even without dealing with a single reference/borrow. But Rust is a dramatically smaller language than C++. The various subsets of C++ people usually carve out tend to be focused on particular styles of programming, like “no exceptions” or “no RTTI”. Notably never things like “signed integer overflow is now defined”, or “std::launder() is now unnecessary”.
    - filleduchaos 10mo ago
      Discussions about Rust sometimes feel quite pointless because you can be several replies deep with someone before realising that actually they don't know much about the language and their strongly-held opinion is based on vibes.
      - bsder 10mo ago
        Exactly. Claims like "even without dealing with a single reference/borrow." When you have this stuff in "Hello World": Egui Hello World: ui.add(egui::Slider::new(&mut age, 0..=120).text("age")); Ratatui Hello World: fn render(frame: &mut Frame) { or fn run(mut terminal: DefaultTerminal) -> Result<()> { loop { terminal.draw(render)?; if matches!(event::read()?, Event::Key(_)) { break Ok(()); } } } And I didn't even break out the function chaining, closure and associated lifetime stuff that pervades the Rust GUI libraries. When I can contrast this to say, ImGui C++: ImGui::Text("Hello, world %d", 123); if (ImGui::Button("Save")) MySaveFunction(); ImGui::InputText("string", buf, IM_ARRAYSIZE(buf)); ImGui::SliderFloat("float", &f, 0.0f, 1.0f); which looks just slightly above C with classes. This kind of blindness makes me wonder about what universe the people doing "Well Ackshually" about Rust live in. Rust very much has an enormous learning curve and it cannot be subsetted to simplify it due to both the language and the extensive usage of libraries via Cargo. It is what it is--and may or may not be a valid tradeoff. But failing to at least acknowledge that will simply make people wonder about the competence of the people asserting otherwise.
vablings 10mo ago
I gave up on a C++ after trying to learn on and off for years. LNK1009 still haunts me in my sleep. I am now an avid self-taught rust programmer and I feel like I have the power to create almost anything I can imagine using rust. This is great for hobby people
tialaramex 10mo ago
C++ as First Language seems like an especially terrible idea to me. Maybe I should take a few months and go do one of those courses and see whether it's as bad as I expect. The nice thing about Rust as First Language (which I'm not sure I'd endorse, but it can't be as bad as C++) is that because safe Rust ropes off so many footguns it's extremely unlikely that you'll be seriously injured by your lack of understanding as a beginner. You may not be able to do something because you didn't yet understand how - or you might do something in a terribly sub-optimal way, but you're not likely to accidentally write nonsense without realising and have that seem to work. For example yesterday there was that piece where the author seems to have misunderstood how heap allocation works in Rust. But, in safe Rust that's actually harmless. If they write their mistake it won't compile, maybe they figure out why, maybe they give up and can't use heap allocation until they learn more. I haven't thought too hard about Zig as first language, because to me the instability rules that out. Lecturers hate teaching moving targets.
- AnIrishDuck 10mo ago
  As somebody that "learned" C++ (Borland C++... the aggressively blue memories...) first at a very young age, I heartily agree. Rust just feels natural now. Possibly because I was exposed to this harsh universe of problems early. Most of the stupid traps that I fell into are clearly marked and easy to avoid. It's just so easy to write C++ that seems like it works until it doesn't...
vips7L 10mo ago
I don’t know anyone that learned C++ first. Maybe I’m younger in generations, but Java was the first thing everyone learned at my university.
- ekidd 10mo ago
  I belonged to the generation that graduated into the rising dotcom boom. Around that time, lots of universities taught C++ as the first serious language. (Some still started with Pascal.) The main thing a lot of had going for us was 5-10 years of experience with Basic, Pascal and other languages before anyone tried to teach us C++. Those who came in truly unprepared often struggled quite badly.
- Keyframe 10mo ago
  Just after Pascal vs C craze in mid to late 90's for sure. That is quite a different C++ than the one of today however.
- brabel 10mo ago
  I did. Though a few years earlier I had attended a class where Pascal was used (however, it was not the main topic, it was about robotics). C++ was what I learned first in a "real" computer science class. In later years, we did move to Java. And I initially hated Java :D but ended up making a career using it. Java in the 2000's was a poor language, but after Java 8, it has become decent and I would say the latest version, Java 25, is a pretty good language. This thread is about Zig though! I want to like Zig but it has many annoyances... just the other day I learned that you must not print to stdout in a unit test (or any code being unit tested!) as that simply hangs the test runner. No error, no warning, it just hangs. WTF who thinks that's ok?! But I think Zig is really getting better with time, like Java did and perhaps as slowly. Some stdlib APIs used to suck terribly but they got greatly improved in Zig 0.15 (http, file IO and the whole Writergate thing), so I don't know, I guess Zig may become a really good language given some more time, perhaps a couple of years?!
- K0nserv 10mo ago
  I learned C++ first. Like many I wanted to make games so I started programming before high school. I think our first high school classes were also in C++ tbf.

com2kid 10mo ago

The mentality around lifetimes is different in Zig if you are using it for the correct types of problems. For example, a command line utility. In a CLI tool you typically don't free memory. You just allocate and exit and let the OS clean up memory. Historically compilers were all like this, they didn't free memory, they just compiled a single file and then exited! This ended up being a problem when compilers moved more into a service model (constant compilation in the background, needing to do whole program optimization, loading into memory and being called on demand to compile snippets, etc), but for certain problem classes, not worrying about memory safety is just fine. Zig makes it easy to create an allocator, use it, then just free up all the memory in that region. Right tool for the job and all that.

dnautics 10mo ago
I'm not convinced that you can't borrow check in zig... (disclaimer, i'm working on compile time memory safety for zig)
- DetroitThrow 10mo ago
  I had no idea you were working on Zig dnautics. If you were to add borrow checking to Zig, it would make it much easier to justify using it at my current workplace.
  - dnautics 10mo ago
    clarifying: It's just an experiment for zig PL, not affiliated with zsf: http://github.com/ityonemo/clr http://github.com/ityonemo/clr was where i got last year. this december im doing a "prototype" which means its going to be done in zig and im going to clear sone difficult hurdles i couldn't do last year.... also accepting sponsors, details on page. also disclaimer, im using heavy amounts of ai assistance (as implied in the preview video)
    - bertmuthalaly 10mo ago
      rad! sponsored

DetroitThrow 10mo ago

>My own appreciation for Rust is rooted in humility. I know I'm an overgrown monkey prone to all kinds of mistakes. I appreciate Rust for helping me avoid that side of me I think we've heard these arguments ad nauseum at this point, but the longer I use Rust for ensuring long-term maintenance burden is low in large systems that I have to be absolutely, 10,000% correct with the way I manage memory the more it seems to reduce the effort required to make changes to these large systems. In scenarios where multiple people aren't maintaining a highly robust system over a long period of time, e.g. a small video game, I think I'd absolutely prefer Zig or C++ where I might get faster iteration speed and an easier ability to hit an escape hatch without putting unsafe everywhere.

hndc 10mo ago

> I'm coming to the view that Rust mostly requires less cognitive load than other languages. This view is only remotely within the bounds of plausibility if you intended for "other languages" to refer exclusively to languages requiring manual memory management

tialaramex 10mo ago
I don't think so? In languages like Java their version of the Billion Dollar mistake doesn't have arbitrary Undefined Behaviour but it is going to blow up your program, so you're also going to need to track that or pay everywhere to keep checking your work - and since Rust doesn't have the mistake you don't need to do that. Likewise C# apparently doesn't have arbitrary Undefined Behaviour for data races. But it does lose Sequential Consistency, so, humans can't successfully reason about non-trivial software when that happens, whereas safe Rust doesn't have data races so no problem. Neither of these languages can model the no-defaults case, which is trivial in Rust and, ironically, plausible though not trivial in C++. So if you have no-defaults anywhere in your problem, Rust is fine with that, languages like Go and Java can't help you, "just imagine a default into existence and code around the problem" sounds like cognitive load to me. Edited: Fix editorial mistake
- GoblinSlayer 10mo ago
  This was linked below: https://github.com/DioxusLabs/blitz/pull/292/commits/e539f523664940eeb9127fa44776855d5aba5904 https://github.com/DioxusLabs/blitz/pull/292/commits/e539f52... guess I'll call it Cheap Cloudflare Mistake.
  - tialaramex 10mo ago
    The problem Cloudflare had, and from what it seems, still have is that they don't actually test software at small volumes before global deployment. I would guess that two outages in quick succession means the voices saying "You need to test everything properly" might win, but perhaps not. The Billion Dollar mistake is about not even having the distinction shown in the commit you linked. In languages with this mistake a Goose and "Maybe a Goose or maybe nothing" are the same type.

filleduchaos 10mo ago

Oh, I do have a fully-formed argument for this that I should probably write out at some point :) The gist of it is that Rust is (relatively) the French of programming languages. Monolingual English speakers (a stand-in here for the C/C++ school of things, along with same-family languages like Java or C#) complain a lot about all this funky syntax/semantics - from diacritics to extensive conjugations - that they've never had to know to communicate in English. They've been getting by their whole life without accents aigu or knowing what a subjunctive mood is, so clearly this is just overwrought and prissy ceremony cluttering up the language. But for instance, the explicit and (mostly) consistent spelling and phonetics rules of French mean that figuring out how to pronounce an unfamiliar word in French is way easier than it is in English. Moods like the imperative and the subjunctive do exist in English, and it's easier to grasp proper English grammar when you know what they are. Of course, this isn't to say that there are no parts of French that an English speaker can take umbrage at - for example grammatical gender does reduce ambiguity of some complex sentences, but there's a strong argument that it's nowhere near worth the extra syntax/semantics it requires. On top of all that, French is nowhere near as esoteric as many monolingual Anglophone learners make out; it has a lot in common with English and is easier to pick up than a more distant Romance language like Romanian, to talk of a language in a more distant family (like Greek or Polish). In fact, the overlap between French and English creates expectations of quick progress that can be frustrating when it sinks in that no, this is in fact a whole different language that has to be learned on its own terms versus just falling into place for you. Hell, we can take this analogy as far as native French speakers being far more relaxed and casual in common use than the external reputation of Strictness™ in the language would have one believe.

xeonmc 10mo ago
I suppose Rust users are indeed the Frenchmen of programmers, on more aspects than mentioned.
- filleduchaos 10mo ago
  Oh yes, there is definitely a reputation of snobbery and rudeness. But I was trying to be somewhat fair/neutral :)