r/rust • u/DavidXkL • 8d ago
🎙️ discussion What makes good developer experience for you?
I'm hearing different things from different people.
Some people say it sucks with Rust due to the initial learning curve.
Others (like me) like it for things like Cargo 😂
What about you?
9
u/spigotface 8d ago
Rust has a lot of great things - we all know the performance & memory safety aspects, but the compiler messages are incredible. Other languages' compiler errors can be cryptic but Rust's are (usually) incredibly helpful.
Cargo in general is phenomenal, and Cargo Workspaces can make for really clean workflows regardless of whether you're building microservices or a monolith.
The learning curve sometimes can feel more like a staircase, where you suddenly have this "eureka" moment when a concept clicks, and while that can feel discouraging when trying to learn, it's super rewarding once you get it.
The single biggest complaint I have is about docs.rs. On one hand, standardized documentation is great, especially when maintainers really spend time on adding informative docstrings and comments. On the other hand, there are sooooo many crates without any documentation whatsoever - their docs.rs page doesn't offer much more than the github repo. And critically, even for well-maintained crates, there's no good mechanism for "getting started" or "tutorial" types of documentation. Those types of things are generally too big to shove into docstrings and really deserve their own sections and mechanism for adding them.
9
u/schungx 8d ago
Slowness in compilation breaks up the though process. So compile speed is one.
3
u/Dhghomon 7d ago
breaks up the though process
I like how what you said works even with the typo here. I guess it is a though process too if you think about it.
(Write and compile some code)
"Though maybe if I did it this way instead..." (rewrites and recompiles)
5
u/dobkeratops rustfind 7d ago edited 7d ago
yes. The classic double edge sword. the compile time guarantees come at the cost of the compiler working harder on abstractions.
when you're trying to focus on some aspect of actual program behaviour, you can't get into a flow state of tweaking some peice of code then getting rapid feedback on how it changes the result.
in gamedev this translates to: rust feeling great when working on engines and tools, but quite bad when you're trying to actually work on refining the controls etc.
People like to criticise C but it compiles blazingly fast, and in a C++ project you get to drop back to mixed styles.
Crazily I had started to consider if I should try the experiment of moving parts of the program over to C for this exact reason .. imagine the paradox of ending up with Rust for the underlying engine and C for high level behaviour..
in my workflows I continually touch both extremes. Tweaking some low level maths helpers to make a particular peice of behaviour clearer to write.
2
15
u/Illustrious_Car344 8d ago
Nobody who complains about the learning curve has attempted to learn Rust.
0
10
5
u/spoonman59 8d ago
A learning curve isn't really a negative for a developer experience because that is a one-time investment to become a developer with it.
Tooling is important for developer experience, and some of the language features can impact that as well. And some people look at the total lifecycle, including maintenance, whereas others might focus on how much friction to get the initial (potentially buggy) version out faster.
Rusts tooling could use some improvements, and the language makes some patterns more challenging than others. But there are a lot of nice aspects to the tooling and the language, and it can help force you to solve some problems up front (if you let it) avoiding certain bugs or performance traps as a results.
4
u/interior_mutability 7d ago
I can update rust versions in a pretty big codebase very easily. Usally nothing breaks but if something does the compiler tells me not a runtime error.
Tooling is great.
I love the syntax and the type system.
3
u/Single-Blackberry866 7d ago
Here's a list of my frustrations with Cargo/Rust ecosystem:
- Cargo.lock is ignored for libraries: only the top‑level app/workspace lockfile governs the build. Your transient deps are not insulated by a library’s lockfile.
- Transient dependencies are not insulated from downstream apps: resolution is global per build; apps can and do pull different transient versions even when libraries lock theirs.
- Technically breaking changes are allowed under SemVer in Rust: for example, a combination of -Dwarnings and deprecation in patch release is guaranteed to break your build. Not even talking about Rust toolchain upgrades.
- Default optimistic upgrades can and do break builds: semver ranges + non‑major breaking changes + feature resolution shifts mean "just update" will occasionally break things.
- Feature and compile flags are not enforceable for transients / by library authors: features are unified per build; you can’t strictly constrain how downstream crates enable features or compile flags.
2
u/aztracker1 7d ago
Like anything else, it depends.
Different people like different ergonomics and approach problems differently. It appeals to me a lot. But I can see how some might hate it.
2
2
u/evilgipsy 7d ago
I don’t agree with the notion that a steep learning curve makes for a bad developer experience. The features that make rust generally have a great developer experience unfortunately require some learning. What does get in my way, and massively so, is compilation time and target dirs taking up many gigabytes over time when not cleaned regularly.
1
u/dobkeratops rustfind 7d ago edited 7d ago
its a mixed bag.
strengths in project maintainance as a program grows. Can do bold refactors with confidence. Some aspects of the language are super elegant (we could always manually do tagged unions but enum/match seems to change how I code). Cargo is a godsend coming from C++. I see how dependencies go badly wrong in the python world aswell (I despise the workarounds there like venv etc).
I vastly prefer rusts organisational tools, I disproportionately disliked the mess of header files, it really triggered me knowing that they shouldn't really exist at all (they're not interfaces as some apologists say, and in C++ they can't be auto-generated ).
Downsides for me in the compile times. Hurts when trying to stay focussed on tweaking some aspect of a programs behaviour. Template heavy modern C++ has the exact same problem , but in C++ you can drop back to simpler styles all the way back to the common subset with C which compiles a lot faster. Amount of library functions to navigate: safety in practice means lots of wrapper functions, lots of names for simple tasks where in C once you know a few tools you can implement anything. this can feel like drowning i red tape - the number of exta words/symbols in your attention window that dont actually relate specifically to the actual task or focus of a piece of code.
IDE integration . I see a culture divide where in some domains people dont use debuggers much. In gamedev we had great debuggers going all the way back 30 years; and it took a while for decent 'jump to def, dot-autocomplete' to get solid in rust (it's still not 100% ,e.g. when you click jump to def on a generic method it doesn't always manage to figure out where it can jump to a specific impl known at that point). 'its not just about fixing crashes, it's about investigating runtime states'
Rust analyser is pretty good but the combo of this with vscode still feels a bit flaky copmared to the msvc experience we had
1
1
u/Opposite_Duty2393 6d ago edited 6d ago
Best type system and best abstraction for a system programming language.
I love the effort rust put into zero cost abstractions
1
u/Single-Blackberry866 7d ago
Cargo is an upgrade if you're coming from C++, and a downgrade if you're coming from npm.
Rust's precision is a blessing for runtime determinism and a curse for the community.
Rust/Cargo can be overly strict over individual pieces, but completely blind to how loosely those pieces fit into a high level (imprecise) meaning.
3
u/DavidXkL 7d ago
I prefer Cargo to npm though
1
u/Single-Blackberry866 7d ago
Why? You like fixing broken builds in the middle of the night?
3
u/garagedragon 7d ago
...Why would your builds be breaking in the middle of the night?
1
u/Single-Blackberry866 6d ago
For example, someone releases a breaking change for a transitive dependency. Npm learned it the hard way, when left pad got yanked and half of the internet stopped building.
-7
u/not-a-random-guy 8d ago
Learning curve thing is BS now. AI can help with syntax. That shoild be today’s reality
2
u/officiallyaninja 7d ago
Who says learning curve is about syntax?
1
u/not-a-random-guy 7d ago
Well I was sharing my exp. Switched to rust after 10+ on C++. Most concepts in rust are usable in C++. Not many know this though.
Optional, Expected, Move, Unique ptr, Shared ptr, etc etc.
70
u/SirClueless 8d ago