Maybe Rust isn’t a good tool for massively concurrent, userspace software (bitbashing.io)

Article summary

The article discusses the challenges of using Rust for massively concurrent, userspace software, particularly with its async/await model. The author argues that Rust's attempt to balance high-level abstractions with low-level control can lead to difficulties in managing memory and concurrency. The article also touches on the trade-offs between using Arc (atomic reference counting) and garbage collection. Overall, the author suggests that Rust may not be the best tool for certain types of concurrent programming.

Main themes

• Rust async/await
• concurrency
• memory management
• garbage collection
• reference counting
• systems programming

What commenters say

• Rust's async/await model can be difficult to work with due to its complexity and the need for manual memory management.
• The use of Arc can lead to performance issues and is not a suitable replacement for garbage collection in all cases.
• Garbage collection can be beneficial for concurrency and performance, but it also has its own set of trade-offs and challenges.
• The choice between reference counting and garbage collection depends on the specific use case and requirements of the project.
• Rust's focus on memory safety and performance can make it a good choice for systems programming, but it may not be the best fit for all types of concurrent programming.
• The article's criticism of Rust's async/await model is valid, but it does not necessarily mean that Rust is not a good language for concurrency.
• The use of async/await in Rust requires a deep understanding of the underlying mechanics and can be error-prone if not used carefully.