Ask HN: Is it worth investing in learning Rust?

https://news.ycombinator.com/item?id=17280700

by hamza99 • 8 years ago

97 79 8 years ago

news.ycombinator.com

I'm interested in your feedback regarding my question,In my case, I'm planning to learn Rust, but I'm really struggling between going for Go or Rust. Thanks !

techjuice2• 8 years ago

Learn both, Rust is a great general purpose language that can be used to build almost anything. Go is a great general purpose language that can build a nice set of things.

If you need to, you can even use Rust to build firmware, boot loaders, kernel drivers, user mode drivers and operating systems. Basically anything that you want to run fast and have less errors Rust would be a pretty good choice to use, especially when speed, performance and app reliability is a high requirement.

I use Rust at work to help reduce error prone programs and speed up capabilities of our distributed apps (calculations and pre-processing of data from systems) that naturally run slow using their original language implementation. I use Go for writing our blazing fast web applications that provide an fast interface to our apps for our internal users.

hamza994• 8 years ago

Yes, on the performance side of things, Rust is blazing fast, but the learning curve is hard though, that's why I'm wondering if it's really beneficial for me as a programmer especially in the long run, since it's not used widely in the moment.

techjuice2• 8 years ago

It is worth learning about it, the biggest part of the learning curve is learning how to right programs better using the language guidelines. I use it daily and it has been a wonderful tool in the toolbox to improve performance, reliability and security of our systems and low level processing systems. You will more then likely still need to use C and C++, but learning Rust will help you program better in C and C++ along with other languages as Rust can call those C and C++ based programs.

The use of Rust is rising, especially for new systems level projects or rewrites of older programs. This is especially true where unexpected issue reduction is a high priority (high frequency trading systems, industrial systems, security systems, video transcoding, packet switching and routing systems, video monitoring systems, virtualization and emulation, web servers, other embedded etc.)

I would recommend getting started learning Rust by having a few projects. I would recommend starting off by building a multi-threaded web server. https://doc.rust-lang.org/book/second-edition/ch20-01-single... See how many concurrent clients it can handle and make adjustments to increase it's max capacity. After you have done that I recommend building your own daemon to handle log parsing and analysis from your web server to give you a nice table of stats. To spice thinks up I would recommend trying to do this without the dependency on external resources after you have downloaded all the resources you need: https://doc.rust-lang.org/cargo/reference/source-replacement... https://crates.io/crates/crates-mirror then try to build the projects.

You can also do some much needed checks on your programs input by using Valgrind and several other tools. Once you are satisfied with your program insure you use Rusts tools to also build the documentation and check your coverage: https://github.com/huonw/travis-cargo

oconnor663• 8 years ago

I'm wondering if it's really beneficial for me as a programmer

I'm biased since I love programming in Rust, but I think learning the ownership model (the trickiest part for most people) is beneficial for programming in any language. It builds up a really good intuition: If only one reference exists to an object, or if shared references exist but they're all read-only, then that's "business as usual". But as soon as you have shared references and mutability at the same time, then you have "very interesting code". Even in a language other than Rust, where you don't need special types to let you do that, the situation probably deserves some beefy block comments where you warn everyone to pay attention.

jstewartmobile2• 8 years ago

If this is a career thing, it's usually better to be an expert in one language than an amateur in a dozen of them. Try them both, proceed with the one you like best, because in the end, you will be judged by what you produce with it.

No matter how much nerd-cred a language has, it is hard to be productive with a language that you hate.

edit: FWIW, we are commenting on a site by a billionaire who seeded his fortune by writing a program in LISP back when almost everyone else thought that LISP was long-dead and buried.

steveeq1• 8 years ago

Paul Graham is a billionaire?

TylerE• 8 years ago

If not, close to it. Very early investments in AirBNB, Dropbox, ...

hamza994• 8 years ago

I absolutely agree with you that it's usually better to be an expert in one language than an amateur in a dozen of them.It's not really for a career thing right now, but I like to expand my knowledge especially in systems programming languages, but if Rust become widely adopted, I will be more than happy that I made the right decision to learn it.

jstewartmobile2• 8 years ago

If by systems you mean drivers/kernels/etc, that kicks Go out of the running anyway.

segmondy• 8 years ago

If you are a C++ programmer, learn rust. If you are a C or other programmer, learn go.

If you are doing this for job prospects, pick go.

hamza994• 8 years ago

Can you explain please why is that ? btw I'm coming from a JS/Node background, but I worked with C and C++ before (mainly school projects, nothing serious).

kristoff_it4• 8 years ago

Maybe I can try to chime in:

Go is not an OOP language, you get the dot notation on structs and that's pretty much it.

Rust is all about advanced OOP and very fussy static type checking.

That said, IMHO, Go to me feels more like a replacement for Node more than a replacement for C.

juststeve• 8 years ago

learn both until you know which one is your favorite.

hamza994• 8 years ago

I think learning both languages to figure out what's my favorite is a bit hard to do, I don't want to actually learn some basics then switch to another language to explore.

smt882• 8 years ago

Learning and using multiple languages is absolutely vital to being able to choose the right tool for the job. You have time to learn both and switching is a necessary skill if you want to program professionally

bjourne• 8 years ago

yes

sriram_malhar• 8 years ago

Forget about the language. What kind of systems do you want to build, or want to learn to build? If it is networked systems, Go gets the job done pretty well. If you want to build a game, or want a superior c++, go for Rust.

movedx2• 8 years ago

If you want to build a game, or want a superior c++, go for Rust.

Does Rust have the libraries, frameworks, engines, and communities for developing games? In my opinion, development of any software, whether it's a REST API or a AAA 3D game, isn't just about the language but is actually about 10 other things.

suby• 8 years ago

I feel that it has a good and growing game dev community, but all the tools and engines need more time in development. There are a few game engines and frameworks being built with rust, but (someone correct me if im wrong) they all either dont have a stable api or have bugs which i wouldnt want to have in production.

I do think Rust is an ideal languange to build games in though. It just needs some time.

See http://arewegameyet.com

guu• 8 years ago

If you want to make a 3D game you can get started much quicker by using an existing engine like Unity and C#.

If you’re interested in building a game engine then C++ will have the most resources.

sairamkunala• 8 years ago

Both are great languages.

I learned Golang about 2 years ago and have done a small web app in it to understand and learn about the libraries.

I recently started reading the Rust book and its an eye opener. Its important to understand how the language is designed and with Rust, its different concepts compared to Go. I would suggest to read the documentations/manifestos of both the languages and decide to go ahead based on what you want to do.

Community and ecosystem is an important requirement when choosing a language.

glangdale• 8 years ago

To answer your question, it would be good if you indicated what your experience is already and what you want to do!

Just my opinion (given my own experience and goals; if your experience/goals are different the below may be irrelevant):

As a constant waverer, my answer to the "Go or Rust" question was, after much time, "no".

Instead I'm returning to C++ and trying to learn how to use modern C++ idioms and finding this very productive.

It's a bit frustrating, as C++ is a bloated mess of a language with way too many dark corners, but good discipline can allow you to use a version of it that is really nice. As someone who learned C++ in 1992 (when much of the language wasn't even really there yet) and has only fitfully engaged with good C++ practices over the years, the payoff from learning new parts of C++ has been really much better than a new language.

Plus, neither Rust nor Go are particularly mind-expanding if you're a native C++ speaker (as compared to Python, Prolog, Forth, assembly, Haskell, Lisp, ...).

rhodysurf• 8 years ago

I write modern C++ as my day job and work on mobile apps in swift/objc/kotlin/dart, and services in python for fun on the side.

I don’t know if it’s just cuz I code modern C++ so much, but I’ve learned to love c++, even when compared to much easier and theoretically more productive languages like swift and kotlin.

ufmace• 8 years ago

What are your goals? Are you trying to find a job, get into some sub-field of development? Do you have some particular thing you want to build? Or just satisfy some personal itches?

ilikehurdles• 8 years ago

Learn a lisp like Clojure/Clojurescript, or a functional language like Elm or Haskell. Learning a lisp is quite mind opening.

nevi-me• 8 years ago

Many things are worth investing in, if you justify it.

The case between Rust and Go is an interesting one, as many of us have observed that the two languages seem to get paired together (for people wanting to learn).

I wanted to start learning both beyond the basics, about 2 years ago. A few weeks ago I decided to write my Hello World in Rust, and I've been hooked.

What I'd advise is for you to have a use-case that you work on while learning the language. You can spend a lot of time on the basics and std, but unless you start also picking up a few external libraries (e.g. SQL, web framework), you might find progress to be slow.

The other benefit is that you'll get more exposed to the community. It's important to know where to go when you need to ask for help.

In my case, I got comfortable with gRPC in Rust, then moved to Actix, and now (if I get diesel.rs to compile) I'm moving to SQL. Next will be "fearless concurrency", threading and futures, streams, integrating with NodeJS and other languages, etc.

A roadmap which gets one comfortable with the standard language while being productive.

eslaught• 8 years ago

My advice would be to not just focus on a use case, but actually have a small "starter project" in mind that you can prototype an MVP for.

My starter project[1] was a set of bindings for pandoc-types, so you can manipulate Pandoc ASTs in Rust. It's a very small library, but it's enough to plausibly do something interesting. It's also big enough to get me to play with serde and some serialization stuff in Rust. So it was a pretty good size to start with.

https://github.com/elliottslaughter/rust-pandoc-types

[1]: Technically, I did work in Rust prior to this, but it was all long before 1.0, so I had to relearn when I picked it back up.

tptacek• 8 years ago

Go is a much, much easier language to learn; it's one of the easier mainstream languages to learn.

If you really have to ask, like it's a headscratcher between the two, learn Go first and see if you're happy where you land with it. Go is the more popular of the two languages; there's not much "risk" to either of them, but there's marginally less risk for Go.

Rust is the more ambitious of the two.

vishvananda• 8 years ago

I've written fairly complex projects in both languages, but have a great deal more experience in go. I think tptacek nails it with this advice: go is much easier to learn. One of the things i really like about it is how easy go code is to read coming from almost any language.

It makes sense to get comfortable with go first because the time commitment to achieve basic competence with rust is much greater. Rust will definitely open your mind but it will take some time to get there.

axaxs• 8 years ago

If it's for learning, learn both. They teach you different models of thinking. As far as pure knowledge, Rust probably has an advantage. If you're looking to get things done quick, or for employment, Go would be the safer choice today.

amorphid• 8 years ago

I'm guessing Go is the more marketable skill. I imagine learning both would make you better at both, too.

oneweekwonder3• 8 years ago

I'm really struggling between going for Go or Rust.

If you want to pick a skill to put on your CV I would recommend Go.

If you want expand your knowledge of programming paradigms I would recommend Rust. As a side note you will also be able to put it on your CV.

edit: for the down voter, what boundaries in language design did golang push? Unlike Rust with its unique memory management?

Animats• 8 years ago

Depends on what you're doing. If you're doing web backend stuff, use Go. That's what it's for, and it has solid libraries for that because Google uses them internally. Go is reasonably easy to learn - it's just not that big.

Rust is fascinating, but there's just so much stuff in there. The borrow checker is a major advance, but unless you're doing heavy parallelism or can't use garbage collection, the complexity of the language is a problem. I'd hoped Rust would kill off C++, but that's not happening.

pcwalton2• 8 years ago

No language has ever "killed off" any language as popular as C++. Perl isn't dead yet. C hasn't even killed COBOL and Fortran.

Anyway, if Rust doesn't unseat C++, of all languages, it won't be because of language complexity. There's very little complexity in Rust that isn't inherent to the language goals anyway.

sudeepj3• 8 years ago

I have written non-trivial code in Rust and Go. The thing about Rust is that it needs a bit of perseverance and experience of writing a bit of non-trivial code in Rust to really appreciate it. Writing tutorial like code won't cut it.

Life-cycle of a Rust developer: https://imgur.com/kNkV7jm

Good, bad and the ugly: https://imgur.com/udNcZXa

With Go, in my head it is best explained in terms of the scene in the movie: Pursuit of Happyness

Boss: Chris. What would you say if a guy walked in for an interview, without a shirt on, and I hired him? What would you say?

Chris Gardner: He must have had on some really nice pants.

People (including me) find lot of issues with Go in terms of some choices in the language. But boy it does have some really nice pants and that is the ease of writing networking services + Go routines

adventured• 8 years ago

I recently started using Go for a bunch of small services a new product needed. I was amazed at how easy and fast it is to get up to a point of high productivity in Go. The language is really straight-forward to begin working in. Probably the most fun I've had learning a new tool in many years.

taneq• 8 years ago

What does "error management story" refer to in the second pic?

sudeepj3• 8 years ago

For some time the dominant error handling way was 'error-chain' crate and the comment was made in that context.

Now there is a failure crate https://github.com/withoutboats/failure. It is an improvement, but it still feels that one has to type a lot for something basic. Now, this is a matter of taste and many people will be ok with this.

sshine• 8 years ago

Good, bad and the ugly: https://imgur.com/udNcZXa

What does "Development experience is very intense" mean?

sudeepj3• 8 years ago

An example:

So suppose you have the following pseudo code:

   x = f()

In other languages you start using 'x' straight away. You can call member functions on it, compare it, etc. In Rust if x happens to be of type Option or Result (which are wrapper types i.e. they wrap the value), then you need to understand these first very well to write idiomatic Rust code. These types have combinator functions like 'map', 'and', 'and_then', 'or', 'or_else', 'unwrap_else', etc. if unwrap() is not suitable for your use case. If you are coming from a non-functional language, one cannot help get a feeling that all you wanted was to use the value and you have to learn so much upfront. At the end of it you are mentally exhausted.

My productivity increased a lot, once I realized that there is a pattern to these and knowledge gain with Option & Result is transferrable to using Future's combinators as well. It is very hard to explain it to someone as to how to get to this state. There lies the challenge with teaching Rust and I think Steve Klabnik and team has done really good job with documentation.

lathiat• 8 years ago

Having thought about this myself; the main thing I would note is that I am seeing more and more companies start to write things in rust. It seems on a definite uptrend.

So there is quite possibly work for you in the field, especially since its emerging, you could be in early.

Having said that golang is also on the up and up and probably currently there is more work I would guess; but obviously also more competition.

Lastly; to the average person like myself who is half-sysadmin half-developer (I'm not a software engineer, but I can read and write many languages "well enough") -- Rust is definitely more complex from my small amount of playing both in Syntax and basic things you need to do to "get started" -- I am sure these would evaporate quickly once you actually learn it properly early on but if you have little other language experience you may struggle with it a little as a 'first' language. Where-as go feels a little more script-like and a little easier to "bounce off the walls" in early learning.

So; is it worth learning? IMHO, yes. Is it the best choice? That may depend a little on your previous programming experience and what job market you are in (for example probably easier to find an onsite job doing rust in Los Angeles, USA than Perth, Australia)

kjeetgill• 8 years ago

Yes, it is worth investing in learning Rust. As is learning Go. Which depends on what you want to learn and what you already know.

I like to learn languages like building a toolbox. I try to pick up popular, well known tools that don't have a ton of overlap with my existing tools. My go-tos: Java, Python, and C can get you pretty far. Go is a great statically compiled, GC language, with decent memory layout control and with a good concurrency story and a nifty type system (coming from Java). Rust has novel borrow-checker that's probably worth learning and seems to let you solve tasks suited for C but with more structured types and a better/simpler multi-threading story.

sidcool• 8 years ago

I my humble opinion, Go and Rust will be the go-to programming languages for system software. Go has an edge, but Rust has its own strengths. Go is easier to get productive than Rust.

( But Rust has generics :) )

sologoub• 8 years ago

Don’t see anyone asking why are you learning either?

Your objectives should come first, then you figure out the tooling. Some have touched on what either is good for, but it really comes to what type of work you are doing/want to do.

In a comment, you mention that you are currently doing JS/Node work. Golang is going to be the closest in terms of use cases - it’s excellent for services. We’ve used it in production with great success, especially when you can leverage goroutines to make things happen in parallel very fast. It’s also fairly maintainable for the web services use case.

I don’t know much about Rust unfortunately.

yomritoyj• 8 years ago

I don't know Go, so I cannot make a comparison, but studying Rust has been very useful to me as someone interested in the principles of programming because it forces you to think deeply about pointers.

In C, pointers are used for many different things: they stand for arrays and strings (which IMHO is a questionable choice); they are used in types where the structure of an object changes at runtime (linked lists, trees); they provide a way for different parts of the program to refer to a common state; they allow subroutines to modify objects 'owned' by calling routines; they provide a cheap way to pass big structures as arguments to subroutines even when they won't be modified; they provide a way of incorporating large structures as elements of other structures which allows replacing one value with another without a full copy.

Some troubles with pointers are specific to the ways that C uses them: manual memory allocation means that you can use before alloc or after free; the NULL value means that you can dereference an invalid pointer; pointer arithmetic means that a valid pointer can be used to produce an invalid pointer. At possibly some small runtime cost we can eliminate these problems.

But there is one unavoidable problem at the heart of the use of pointers. When you are referring to something with a pointer, are you doing it just for convenience, to avoid copying large structures; or are you doing it to share state with other parts of the program? Things will go horribly wrong if you end up doing the latter when you just wanted the former.

Rust's type system is an attempt to keep track of different uses of pointers to catch such errors without compromising on efficiency. There have been other attempts ([1],[2]) but Rust finally has a rich enough language and library to attempt writing serious programs in.

I think it will be interesting to see whether the authors of such programs find the mental effort of keeping the borrow checker happy worth the efficiency gains of using pointers for both purposes on an equal footing, or whether they fall back to the extreme models of Python (and many other languages) where everything is a pointer which shares state or that of Haskell where there are no pointers by default and one has to switch to a explicit and cumbersome syntax (using the IO or ST monads) when one wants to use shared mutable state.

[1] https://en.wikipedia.org/wiki/Substructural_type_system [2] http://pauillac.inria.fr/~fpottier/slides/fpottier-2007-05-l...

greyman2• 8 years ago

Could I have a tangential question: I did learn what is Rust for, but if there is a steep learning curve, it is that much better comparing to C++? I worked about 15 years professionally in C++, it's a solid language, and it is used by many open source projects and companies as well. You can also do "anything" in it, like in Rust, and the abstractions don't incur performance penalties.

passiveincomelg2• 8 years ago

Are you one of the three people in the world who can write C++ code without security holes? If not, I'd say it's worth it. That was half joking. :)

The half serious answer I can give is: Do you have a job offer you want to take or at least a solid plan how you can use it professionally? There are so many C++ jobs, that you can most likely find another one that meets all your other requirements (location, salary, domain, etc.), should you decide to leave your current one. I don't think that is the case for Rust yet (But I'm rooting for it! :)

The second point is also my answer for OP.

greyman2• 8 years ago

Yes the second point is exactly what I was getting at - how exactly is Rust so much better that it justifies to learn it instead of C++. (but I don't imply it isn't, just curious to see some real points).

profalseidol• 8 years ago

Clojure and Datomic.

rdiddly• 8 years ago

Is it that big of an "investment" that you need to agonize over it? Flip a coin, learn whichever one. Then assuming you're not currently dying of cancer and don't get hit by a bus etc., learn the other one next. You've got plenty of time.

Your thoughts as revealed by the question fall into a pattern I recognize from when I was younger, where I used to think (for example) 6 months was like this eternity, and (for another example) what I was gonna major in was super important because it would define my life for 40 years. Ha ha, I should've been so lucky! Or rather, unlucky, because reality is much more interesting. The reality is, in 10 years you'll be learning something else entirely, and when you've been at this game a while, you start to lose count of the languages and paradigms you've learned. You get so you can pick up a language in a couple of weeks, or a weekend. Each one of them is worth it, for the things you learn along the way, and the ways it teaches you to think. Any rock is sufficient for sharpening your knife.

SkyMarshal• 8 years ago

Think of Go as a better Python and Rust as a better C. Which type of programming do you do more?

Rust is harder to learn but solves some harder problems and arguably you'll learn more valuable concepts as a result.

sullyj3• 8 years ago

I think that anyone using even intermediate Python features is going to find moving to Go a bitter pill to swallow.

In what sense is Go a "better Python"? My impression of Go is that it (by design) is extremely minimalistic, leading to simple, verbose code, that is understandable by the lowest common denominator, allowing large scale collaboration. And also it has good concurrency.

majewsky• 8 years ago

Think of Go as a better Python and Rust as a better C.

That's an interesting position, because the Go designers specifically intended for Go to be a better C.

lvoovkkff• 8 years ago

That's an interesting position, because the Go designers specifically intended for Go to be a better C.

So what? Go is not a better C. The C interop overhead by itself is proof enough for that.

eb0la• 8 years ago

This looks like a Perl vs Python question from late 90s.

Back then Perl had a huge traction, mostly from sysadmins. Python got traction from web backend, and systems (redhat used to have a good python conde for starting-up servers).

I think both Rust and Go will coexist un different industries/use cases.

IMHO the killer app/use for GO are lambdas/cloud functions because they are cheaper to execute than python.

For Rust, I expect to see someday a unikernel that boots an app into a VM/light container.

nirse• 8 years ago

I really think it is about the kind of dev you want to be. Judging from your question you're early in your carreer / a student: so in order to choose between these two (I'd recommend both, by the way, or as many languages as you can, but do become an expert in one), you need to choose where you want to head. Rust is often (not exclusively) used for more low level stuff, down to firmware, where Go is generally used for higher level stuff, among others networking, web and such.

I think if you find what level of programming interests you, the tools will follow from that.

Dowwie• 8 years ago

The answer depends on who you are, what you've done, and what your goals are. Developing a Rust skillset is absolutely an investment-- but is it a worthwhile investment for you?

AnimalMuppet2• 8 years ago

To rephrase Dowwie's point: It's an investment. What would "return on investment" look like to you?

Knowing a new way to think about code? Rust is probably worth it for that, even if you never actually use Rust much. Go is less of a new way of thinking.

Increasing your ability to get hired (or you paycheck when you do)? I'm less clear that you'll get paid back in those terms. Go might be a better bet.

Scratch the itch that you like learning new things? Well, if you learn Rust (or any language), sure.

seba_dos1• 8 years ago

Yes. Understanding of concepts that make Rust's learning curve steep make you a better programmer regardless of which language you'll use later.

st1ck• 8 years ago

I spent around 30 minutes reading "Rust for functional programmers" [1] to get overall perspective and then around 3 hours more reading selected chapters from "The Book" [2] about borrowing, lifetimes etc.

Then I managed to write a simple program which reads a password from stdin, applies scrypt KDF to it and prints the result in hex encoding. It took me less than 2 hours. Mostly I just tried to do something, and when it didn't work, I'd find a solution for my problem on stackoverflow or r/rust. Compiler error messages were also quite helpful.

So I managed to write a useful (for me) simple CLI application in 1 day. The next day I added option processing (salt, scrypt parameters), split the code into functions etc. I didn't encounter any problem which I couldn't solve in under 1 hour. The biggest struggle was trying to return a reference to local variable from function, and it was covered in [3].

TLDR: don't try to master the language, just give it a try for a few days, writing a simple program.

[1] http://science.raphael.poss.name/rust-for-functional-program...

[2] https://doc.rust-lang.org/book/

[3] https://bryce.fisher-fleig.org/blog/strategies-for-returning...

Ask HN: Is it worth investing in learning Rust?

Related Stories