Rust is metaphorically marketed as a better systems programming language that focuses on performance-sensitive applications, especially for memory safety and concurrency. But, all of this is not very transparent, inaccessible, and hidden from the developer. Not to mention, it all comes with a steep learning curve. So, the question to ask, is it really worth it?
Ownership and Borrowing: This feature helps prevent memory leaks and data races. But, it is difficult to understand and profile especially if you are used to garbage collection.
Lifetimes: This helps ensure memory safety. But, again it is complex and difficult to reason about.
Complex Type System: It comes with a sophisticated type system to catch errors at compile time. But, again it can be difficult to understand.
Steep Learning Curve: It simply has a steep learning curve that requires time to learn. Time that is spent being less productive in actually delivering on work. This means it is more an academic language for people that have all the time in the world to learn a new language. If it takes so much time to learn than is it really worth it in the end. By the time you become competent at it there is likely a better programming language with a simpler approach to doing things. Complex languages are more difficult to test.
Compilation Time: It can be slow, very slow as a result of extensive checks to ensure memory safety and prevent data races, all happening under-the-hood. Should you trust it? This will lead to longer compilation times. Time that could be better spent like maybe getting a cup of coffee?
Verbosity: It is explicit that leads to more code. More code leads to more tests! This means more development time and larger codebases.
Ecosystem Maturity: Let's just say it is growing. This means fewer readily available libraries and tools for certain tasks. And, more than likely tons of undiscovered and unresolved bugs in the backlog.
Cognitive Overhead: Developers have to think more explicitly about memory management, even when it doesn't require manual memory allocation. This means a lot of cognitive overhead making the whole development process more challenging. You are surrounded by complexity. Defeating the whole premise of "Keep it simple, stupid". And, the often quoted in complexity circles: "Complexity is the root of all evil".
Not Suitable for All Tasks: This language is still very much domain-specific. Tasks that it can be good for are systems programming, embedded systems, and other performance-sensitive applications. Especially, if you are akin to making things more complex than they need to be. In most workplaces, agility matters in getting things done, where this programming language will not be useful for majority of development tasks.
Error Handling: Very verbose error handling that requires more code.
String Handling: Way too many string types.
IDE Support: Let's just say it is improving and not as feature-rich.
Debugging: Imagine a language that focuses on memory safety but is a challenge to debug. Most things in this language just go against the grain of being productive and focus on academic rituals of memory safety. It will make you pull your hair out of frustration.
