Would you consider replacing Ruby with Rust instead of Go?

Go would be decent for applications asymptotically approaching web browsers if the user interface options were better. It's UI library support that makes Go such a bear for desktop applications, not any fundamental property of the language.

In general, I find Go works really well for anything I would normally code in C in userland.

A better way to put it: if you can reasonably write it in Java, you can almost definitely write it in Go. Nobody calls Java a "scripting language".

I agree in that you wouldn't write a driver in Go, but you would in Rust. It simply feels very strange to consider that Rust intention is limited to those areas. It could, but I have a feeling it can have a larger scope than the one it has somewhat imposed on itselve because it can effectively replace C/C++.

It's semantics are somewhat more complex that something like Go, but using it shouldn't prove much more complex that Go one you are used to the language basics. This could be of course my errors anaylising the problem, maybe it's way slower/complex and without any great benefit when precise memory management can be spared in favor of development speed. But even then I wonder if the existance of immutability, exhaustive pattern matching and an expressive type system don't increase heavily the realiability of Rust code hence providing stability reducing bugs.

> If you want a replacement for Ruby, and don't want to use Go (for whatever reason), then I'd really advise asking "Why?", first.

I'm slightly tired of not having a type system, I keep shooting myself in the foot and introducing little bugs that a type system would often get. In ruby heavy testing is very important and I find myself wanting things like immutability and pattern matching to ensure I handled exhaustiveness in my logical assertions during the program flow.

Also, my company pays way to much for not so much concurrent users because Ruby consumes a lot of memory. We have to think to much about deployments and horizontal scaling and I'd prefer something simpler to scale.

This are all problem that we have solved. They are natural to the dynamic character of Ruby, but the beautiful syntax and simplicity of DSLs come at a price in development and deployment.

Go feels a very poor language. Channels are nice and expressive, but the lack of a larger type system, error handling, it's mostly imperative semantics and excessive simplicity make it unattractive. I don't want a compiled Javascript, I want the quality of abstraction that simple tools can bring even though they may not be the easiest.

Javascript is very unrealiable and full of quirks. Go is too simple to offer level of abstraction we want to invest heavily in program correctness without too much testing. Ocaml has an interesting balance but I want statically linked binaries at all times and have no interesting in dealing with what seems a messy standard library and compiler flags to get the exact result I want. Haskell's too complex to learn for any practical use. Purescript seems interesting but suffers from the same complexity as Haskell. Many other languages are not safe even though they're fast and compiled and many JVM languages are way to close to Java which I would love to see disappear during my lifetime.

It's very picky, but hopefully the downsides of every language appear clear as to why I'd consider Rust instead of Go as a replacement to ruby.

> The threading model in Go is very attractive as well, please refer to this article: https://swtch.com/~rsc/thread/

That's a nice overview of CSP. It's not a selling point for Go over Rust. Rust threads are in fact a purer implementation of CSP than Go goroutines are.

Thanks for the link. It was a great read to understand in more detail what go channels really are from a theoretical perspective and how that could actually be matched within Rust.

I agree many people use Go for it's simplicity for new developers which is understandable but not the only way to measure why a language should be adopted.

I'm yet to verify this, but it seems that Rust is closer to Haskell in that it intends to enhance the likeliness of program correctness as it's being written and not only through testing. In go you still get runtime errors and I don't think it's all that rare, Rust should reduce those greatly.

I do share that adoption through libraries and widespread acceptance is very important and when you compare Rust to Haskell you make a nice point, the language could be great but not generate adoption.

However besides adoption I don't see anyone who seem to dislike the process of writing Rust itself. Apparently people think it's viable if more libraries are out there. The natural presentation of the arguments made me feel that people are open to it should the right libraries be there.

It's not my intention to close the conversation but to try to make it richer by not focusing on the historical advantage that Go has over Rust. You are correct in that it's possible that not much more open source will exist in rust since it could simply fail to acquire any massive adoption.

I do think there will be space for both and I would prefer to consider them as raw tools, hence the language themselves, and take the risk of having a community in the future sharing libraries for common things. It's a risk but not a crazy one I'd say and probably helpful for the analysis.

Building on your reply, I'd say prove of adoption is one downside for choosing Rust. This however ignores the merit of Rust as a language which hints me into what I have begun to see more often: that it's the newness and relative absence of production use cases that don't seem to validate it viability, not some inherent complexity or downside to the language itself.

I agree that you can address the scalability problem in every architecture in different ways. In ruby you'll typically have a mix of vertical and horizontal scaling that often results in a significant consumption of memory. This even though feasible comes at a higher price on cloud resources. I have experience this first hand and I think it's similar (at much minor scale of of course) to what companies like Shopify have experienced as motivations to change to something like Go.