My opinion, hopefully I don’t get downvoted into oblivion lol: Rust is great for lots of things and its to be commended for forward thinking on so many neglected areas of software development from the last 20 years. I use it almost every day for hobby stuff and have used it from time to time professionally (among Java, python, typescript, c++).

That being said amongst many of its users it has an almost cult like belief in its supremacy and imho attracts some bad people (not all). Because of how much it protects you, many bad developers find it and fall it love with it because it forces them to code correctly and then they can’t imagine that anybody else doesn’t need the guard rails they do. They also see that some of the smartest and best developments in software engineering happen in this space and want to attach themselves to it, and then use it as a bludgeon against others. Lots of very important software was written in languages that are not rust and they work just fine, were able to meet deadlines / be profitable Etc etc. but there is this attitude from many that if you aren’t picking Rust these days what are you even doing???

Rust is great but it’s sometimes messy and not the right tool for the job. The whole “slower to develop but faster to correct” (which I’d say needs some real data to prove out, but for the sake of argument let’s say is true) is a trade off, not something that automatically makes it better. Sometimes due to circumstances way beyond your own control as a developer, you won’t know what the right answer is until halfway into development and there are languages that accommodate that scenario much better (imo). This is one of many of rust’s short comings. For a website, it’s just an unusual tool that even if equally useful from a language standpoint doesn’t have as much tooling and community support around it as other web languages. But I’d say it’s not equal even from a baseline level (again, my opinion. I’ve used rust plenty but I’ve never used it for web dev so I’m talking out my butt). Philosophically, does it make sense to over engineer a super powerful Ferrari of a website when a Toyota Camry will do? Especially when the Camry is tried and true and will likely let you be more agile.

You can do anything in any language, but should you?

I had a bunch of stuff typed here (probably too much), clicked a damn icon on this UI and POOF when my entire comment…

These are my opinions, probably not shared with others and surely not the end all be all to ‘why not Rust?’

Rust is hard. Rust is slow to iterate with and compile. Here’s a highlevel overview of the things you’d need to learn to effectively understand Rust code; not even speaking to learning enough of that to write it. Rust gets touted as secure, and it is more secure than other low level languages like C/C++. That does not make it invulnerable to exploits. It gives a false sense of security to developers who think My app can’t be hacked, it’s written in Rust!!. While Rust is better at memory management and protecting against run time errors related to memory issues, that doesn’t make it 100% safe. That removes almost one class of potential exploits, not all of them, and can’t protect the developer against other developer created issues. Rust code is still written by people. People still write insecure code even in Rust. Computers are dumb as hell; but fast. People are smart as hell, but SLOW. Combine the two and you get stupid things faster; not smarter things better.

• Rust development is hard, hard to learn, very hard to do right
• Rust is not suited for a web application. Would you tell someone to go write the web application and web page in C/C++? Nope. There’s a reason for that. Not suited to it. Square peg, round hole
• There’s always exploits being discovered. Rust handles some things better, but uhhh… Go look at some Lemmy Rust code. Definitely still has vulnerabilities; Rust won’t save you from yourself.

Something like Golang is much better choice for development of a web service that has sane API handling. By the time to add in more error handling, more type checking, more passing around of this function or that data, and more checking it on the sender and receiver side…etc. By the time you’re writing Rust safely and correctly; it is much slower than what you may be lead to believe.

Go is primarily designed for speed of development (including compilation times), rather than speed of execution. Go programmers tend to value clear code over fast code. Why does a microsecond longer matter for a website? Maybe in some backend PLC land there’s a damn good use for that performance. For a networked web application; it’s a pointless metric. That is not going to be your bottleneck.

---

Rust is hard to understand just reading it let alone determine why it’s doing something.

---

Rust

fn does_what(n: u64) -> bool {
    match n {
        0...1 => false,
        _ => !(2..n).any(|d| n % d == 0),
    }
}

Golang

func doesWhat(value int) bool {
    for i := 2; i <= int(math.Floor(float64(value)/2)); i++ {
        if value %i == 0 {
            return false
        }
    }
    return value > 1
}

Not talking about the functionality merits of the two, but in comparing the _code itself. One of those is much easier to determine what’s going on and what it should be doing versus the other. I don’t feel like fighting my code. Programming is a tool to help. If it takes more work to use the tool to achieve your goal, it’s the wrong tool. Rust is the wrong tool for web development.

A long-running web thing like Lemmy doesn’t need the processing benefits of native compilation, and can avoid memory vulnerabilities with a garbage collector. Most things it does are IO bound (receive data from other servers, send data to other servers, occasionally render some HTML, interact with a database…) so you’re really not benefiting from anything specific to Rust, but you are losing a significant amount of developer effort into things like working with the borrow checker or the infamously long compilation times that could instead go into implementing functionality.

You could make something just as performant as Lemmy is today with Python or JS (JS would particularly work well given the prevalance of JITs).

The benefits of Rust turned out to be irrelevant for Lemmy. Then the downside kicks in. To give you some context, sone people Rust is more difficult than C++, which was indeed one of the most difficult (if not the most).

Unless you have a Google-tier workload, it’s probably not worth the effort to deal with the learning curve and manual memory management of Rust. Not to mention that the language isn’t particularly common among web devs, so finding developers for it will be annoying compared to something else. Logic errors will be a more relevant issue with a web app (things like not setting your JSON Web Tokens to expire) and Rust won’t save you from that.

Rust is great if you’re building something like a browser engine where there’s big performance requirements, a huge attack surface, and you’d benefit from explicitly marking where memory errors can occur (also compiler-managed concurrency/parallelism).