7 ms·

Ask HN: Should I learn Rust or Go?

• t-3 4y ago
  Reading the Go spec will only take an hour or two if you don't get distracted. If wasting time is your concern, it's such a small amount that you've probably recently wasted more time on a number of trivial things. Reading the Rust Book takes a bit longer, but it's still just a handful of hours. https://go.dev/ref/spec https://go.dev/ref/spec https://doc.rust-lang.org/book/ https://doc.rust-lang.org/book/
  • LecroJS 4y ago
    Thanks for sharing! That’s good to know. I’ll likely knock out the go spec in that case. Lmk if you have any opinions either way
  • vaylian 4y ago
    I agree that Go is a much smaller language and it can be learned more quickly. But I'm not sure if reading the spec is the right approach here. Shouldn't OP rather learn from a tutorial? The spec will explain the "how" part of the language but probably not the "why" part. https://go.dev/learn/ https://go.dev/learn/
    • t-3 4y ago
      The spec is very easy to read, and followed with some code examples can have you up to speed very quickly. Better to just spend the time up-front when it's cheap and then get the practice actually using the knowledge.
  • Munksgaard 4y ago
    I'm not terribly familiar with Go, but surely the comparison here must be with Rusts Reference[0]? It is a bit shorter than the Rust Book (a simple print-to-pdf says 435 pages vs. 664 pages, and 104 pages for the Go spec). 0: https://doc.rust-lang.org/reference https://doc.rust-lang.org/reference
    • spoiler 4y ago
      I think the Go reference was designed with learning users in mind, whereas the Rust one isn't. That's where the book comes in; it's a more structured way to learn the language than just reading the reference. The reference can be supplementary, thought.
  • KineticLensman 4y ago
    > Reading the Rust Book takes a bit longer, but it's still just a handful of hours. Speaking as someone who is really enjoying learning Rust, time taken to read the book isn't a good metric for understanding the language.
    • t-3 4y ago
      The book is just a first step. The really important thing is "how much work do I have to do to get a decent level of foundational knowledge about the language", which is relatively little for either Go or Rust (or most other languages).
      • KineticLensman 4y ago
        > The really important thing is "how much work do I have to do to get a decent level of foundational knowledge about the language", which is relatively little for either Go or Rust (or most other languages). I might have agreed with this before I tried using Rust's strings, borrow checker and lifetimes in anger. I had some real speed bumps with these even given my prior knowledge of C#, Common Lisp and C.
• xanathar 4y ago
  What a missed opportunity to title it "Should I Rust Or Should I Go?".
  • LecroJS 4y ago
    Touché. And to top off your comment, my DnD party is about to engage xanathar in his lair this week which doesn’t bode well..
  • karlzt 4y ago
    You should Go first and then Rust.
• anotherhue 4y ago
  IMO it's short term enablement versus long term. You will feel productive early on in Go, but it plateaus. Rust has a lot more CS concepts and I think will be the more fruitful learning experience. Also, Rust can lead you to WASM, which might work well with your web background.
  • stop50 4y ago
    Go has also wasm output.
  • makeworld 4y ago
    Go can also compile to WASM.
    • mejutoco 4y ago
      AFAIK since Go is garbage-collected, the WASM it generates probably needs to include a runtime, right? While in Rust since the ownership is verified at compile-time there is no need for GC. Please correct me if I am wrong. EDIT: s/runtime/compile-time
      • LecroJS 4y ago
        Can you say a little about what it means that since Rust has provable ownership at runtime, there is no need for GC? I’m familiar with Rust ownership on the surface, but lack the knowledge to see how it eliminates the need for GC. Is it just Rust’s way of guaranteeing that a program is memory safe, or is there more to it?
        • mejutoco 4y ago
          (A bit simplified)My understanding is that reference counting is one of the easiest way to deal with memory assignments and it needs GC. If the ownership rules determine at compile time that your memory assignments are fine (no double free, etc.), you can avoid using reference counting (and the associated GC).
• throwawaymaths 4y ago
  Learn elixir. The way you program elixir will push you towards better coding. There's a good chance you'll get better at testing, better at writing documentation. If you stick around long enough, you will learn about distributed systems (and their failure and recovery modes) and failure domain management -- this stuff is built into the stdlib
  • LecroJS 4y ago
    This is the first I’ve heard a recommendation to learn elixir. I’m definitely interested based on your description + a quick google. Is there anything that comes to mind in terms of what it does different from Go/Rust that makes you recommend it? My understanding was that I’d get these types of benefits from those two languages
    • leetrout 4y ago
      Painting with a broad brush... Elixir is like the new ruby where Go is like the new C and Rust is like the new C++. Elixir shines at concurrency so it will feel more like nodejs and similarly runs on a VM like Node or Java. Elixir, like Rust, will help with learning functional programming paradigms more than Go.
      • anonymous23801 4y ago
        I disagree here, Elixir looks similar to Ruby from a syntax perspective. But as soon as you dig into OTP it is a completely new world. It's true that as a beginner you can simply do web development with Phoenix and that feels similar to Rails (Or Django / Laravel / Spring / whatever web framework ). But OTP requires a different way of approaching problems.
      • throwawaymaths 4y ago
        I think your comparisons are at the superficial "what does syntax look like" level. If you're thinking culturally, roles, what they're expected to be used for, what hires look like: Elixir is the new Erlang. Ruby is dead (I used to <3 ruby). Go is the new python, zig is the new c, and rust is the new c++.
• sys_64738 4y ago
  Rust will be in the kernel shortly so it'll have longevity with that. Not that I'm saying GO won't but kernel inclusion suggest permanent support.
• DethNinja 4y ago
  Why no start with C? Then perhaps check C++ and Rust? If you want to understand internals of programming languages then Go isn’t a great choice because it abstracts away so much stuff.
  • vaylian 4y ago
    If you really want to understand how programming languages work internally, you should look at assembly language or possibly at the bytecode interpreters of some scripting languages. C is still fairly high-level.
    • shrimp_emoji 4y ago
      The definition of "low level" keeps changing over time. :p At this rate, Python will be called "low level" 50 years from now. But to the OP: Rust is just "C for the 21st century" (despite people often calling Go that). The UX is stellar -- `cargo run` can't be beat, integrated unit testing, safety concepts learned in the last few decades are applied by default, and the docs are great[0]. I don't think there's any reason to learn C first, especially if you're coming from a "high level" background like TypeScript, other than experiencing culture shock and legacy braindeath horror. 0: https://doc.rust-lang.org/stable/book/title-page.html https://doc.rust-lang.org/stable/book/title-page.html
      • LecroJS 4y ago
        Yeaaaa hearing c called high level makes me wonder what word would even describe the js/ts/Python I’m familiar with…
  • stop50 4y ago
    The advantage of rust is that it protects you from common errors in c. if i had to choose between c and rust as someone who likes go, i always would choose rust.
    • rgoulter 4y ago
      Well, I'd much rather maintain an application written in Rust or Go, than written in C. But for gaining understanding, I think because C is so 'raw', I think that makes it useful for developing further understanding as a programmer.
• mudrockbestgirl 4y ago
  I think you have the right idea already, so it just depends on what you want. I believe that learning Rust has made me a better programmer because I am now explicitly thinking about ownership rules and references no matter what language I'm using. Types and memory allocation are also more explicit in Rust than in Go, adding to learning aspect. I don't think learning Go has made me a better programmer. It was just another pretty standard language. But I already knew a range of other compiled languages previously and Go wasn't sufficiently different. Like you said, for "getting things done" that is not low-level, systems, or game programming, Go is the more reasonable choice. It's more straightforward, faster to iterate in, usually more concise, has easy concurrency primitives, and is more widely adopted in the industry. TLDR; I'd go for Rust if you want to optimize for learning and Go otherwise.
• timcavel 4y ago
• jpcapdevila 4y ago
  I write JS 99.9% of the time. I would definitely pick Rust as it is more different than JS. Yes, there is a higher learning curve. But it will broaden your perception on programming languages. As an added bonus, rust is very popular to create WASM stuff. So you can apply it to the JS world. Happy 4th
• crabbygrabby 4y ago
  Learn both. Go takes about 10minutes to write code in, a week to figure out harder stuff. Rust takes a few weeks. Both are good to know and fun to learn
• chrisoverzero 4y ago
  Yes.
  • LecroJS 4y ago
    This from the guy who divides himself by zero
• PragmaticPulp 4y ago
  I personally enjoy Rust more than Go, but if you’re considering the career angle then Go has a huge advantage of more jobs. Rust has a steep learning curve, like you said, which is one reason why it won’t be nearly as common as Go in the workplace.
• rr808 4y ago
  I think if you're in the front end world and likely to do more full stack work go is perfect for this, so its likely to lead to jobs in the next year or so. Rust I like it but worry it hasn't really taken off as I expected. C++ seems resurgent. The C++ world is vast, perhaps you'll learn more with that and the skills will be more useful. Either C++ or Rust dont get used in full stack though so it really is a different world.
• fithisux 4y ago
  If you look to glue systems and add some new code at system level (not confuse it with OS level), the Golang is a better option. E.g. microservices, talk to databases, implement some distributed algorithm in your code. Now if you plan to do number crunching, low level algorithm or scientific computing, Rust by all means. Unless you glue algos, then Python or Julia
• SaulJLH 4y ago
  Something that I'm very much interested in, too! Tangential & important/useful to this question is: "Ask HN: Great visual or other breakdowns of PL's & their categories/sub-c's?" https://news.ycombinator.com/item?id=31919255 https://news.ycombinator.com/item?id=31919255 Posted over 5 days ago, sadly, there was zero responses. Should I try reposting from scratch, or 1st w&s if this bump sparks things? Ty
• andrewaylett 4y ago
  "Yes" I personally find that even spending a little bit of time in a programming language with a different paradigm is incredibly helpful. So I'd suggest that Go is probably too similar to be maximally helpful, Rust is really good, but something like Haskell might give your brain a better workout even if you never actually use it for anything concrete. If your priority is to get things done, do them in TypeScript unless you've a really good reason to learn another ecosystem at the same time. If your priority is to learn and get better at programming in general, digging into pretty much anything else will help. Just don't necessarily expect to get anything done.
  • LecroJS 4y ago
    Very pragmatic perspective. I find this helpful in that it defines a line between getting things done vs investing in my own growth. Before reading this, my thoughts on Go were that it was a better way of “getting things done” than how I do it now in TS, but you’ve shifted my perspective to it being more of a middle path. I am perfectly able to get things done in TS and then could supplement that with Rust for growth purposes. Thanks for taking the time to reply Andrew!
• praptak 4y ago
  Depends on what do you mean by being a better coder. My take on what you can gain from learning each of these languages: Go - concurrency with channels (that's a big one, gives you a good tool to think about concurrency even outside Go), appreciation of language minimalism Rust - what it takes to have memory safety without garbage collector Speaking of mental tools for dealing with concurrency I recommend looking at Clojure with its concurrency based on software transactional memory and immutability.
• adrianN 4y ago
  Hot take: Learning languages doesn't make you a better programmer. Solving real world problems makes you a better programmer. Whether you do that in Rust, Go, or Shellscript is a lot less important. Perhaps find a book or a series of talks about a topic you've struggled with in the past, say, maintainability, and see how you could do better in that area. Or learn more about the domain of your customers so that you understand their requirements better.
  • chrismorgan 4y ago
    For the typical developer familiar with one or more C-style languages (Java, Ruby, JavaScript, Python, C, C++, Go, shell scripts, that kind of thing) and not much more, learning Rust will make you a better programmer, because it makes various kinds of sloppiness harder or impossible and forces you to be more careful about things like shared mutability, in a way that does transfer to your style in other languages, so that you’re much less likely to perpetrate various kinds of errors, among other improvements. Source: myself and literally every other person that I’ve talked to about the matter.
  • erik_seaberg 4y ago
    Languages that change the way you think about expressing algorithms (e.g., Forth, Haskell, Lisp, Prolog, Smalltalk) are worth learning. Others are just reskins of languages you probably already know.
• PhantomBKB 4y ago
  Learn Crystal https://crystal-lang.org/ https://crystal-lang.org/
• ankrgyl 4y ago
  If your goal is to be a better coder long term, I’d suggest learning both. As many have pointed out, Go is quick to learn, and I think learning both will only take a small amount of extra time (compared to learning Rust). They each present trade offs that make them a better tool under particular circumstances. While Rust exposes you to more sophisticated typesystem features, Go's M:N scheduler is an incredible piece of technology that is (IMO) unmatched by any other mainstream language. Finally, regarding the garbage collector, if you learn both languages, you'll get to viscerally experience the tradeoffs of having the garbage collector (try writing the same program in each language). There are some projects where it makes sense to use one and others where you shouldn't. Trying out both is the best way to build up intuition for this kind of trade off.
  • pizza234 4y ago
    I've tried both and failed. It really depends on the goal. If one wants to end up with an elaborate hellow world, probably yes, one can learn both. Learning Rust to make it applicable to mid/large-scale projects, and potentially for a professional transition (my case), is a one-of-a-kind commitment, in my opinion, hardly compatible with learning another language at the same time.
    • ankrgyl 4y ago
      In that case, I'd suggest learning Go first, as a kind of "step up" to learning Rust. If you haven't already, I'd also suggest learning C. I think there's some linearity to these tasks. Rust (and C++) are an amalgamation of many complex features that are present in simpler predecessors. Learning C for example will not only speed up your ability to learn Rust, but also leave you with a deeper understanding of the core principles.
      • LecroJS 4y ago
        Just replied to another comment recommending C. Can you help me understand which core principles C would help to refine i.e. what am I leaving on the table if I go with a Rust or C++?
• akagusu 4y ago
  I think it depends on your goals. Do you want a job in the short-term? Choose Go. Do you want a job in the long-term? Choose Rust.
  • speed_spread 4y ago
    But what if you already have a job?
    • akagusu 4y ago
      If you already have a job and you don't want a new job neither on the short-term or long-term, you could: - choose Go because: - it is easy to learn - it is fun - it is productive - it has good performance - it has good maintainability Or you can: - choose Rust if: - you have the time to learn the ins and outs - you have time to keep up with the never ending new features - you have interest in write software that is usually written in C or C++ What you need to have in mind is that both languages have benefits and trade-offs. Go for example is easy to learn because is a small language but because of that you will need to write more code. Modern developers are usually averse to write lots of code. But write the amount of code that Go requires you to write will make you think better about what you are writing and at the end this will make you a better developer. Rust takes time to learn and features keep bubbling up from time to time and some times development with Rust can be slow compared to other languages, but it is an excellent replacement for C or C++ if you are writing software for a supported architecture, because you will have the C/C++ performance without lots of bugs related to manual memory management. Another thing to keep in mind is not to use Go or Rust when you should not use them. For example, you will see a lot of people using Rust for the sake of using Rust just because Rust is "memory safe", but Go is "memory safe" too; the difference is Go is garbage collected and Rust is not. If you can afford a garbage collector in the software you are writing, don't waste your time with Rust if the software domain is one that Go excels, like networking programming. But don't use Go for the sake of using Go as many people do, for example, trying to replace C or C++ with Go, because Go is not a replacement for C and C++.
• karpierz 4y ago
  I've been learning Rust for the past few weeks and have been enjoying it a lot. - The community is very helpful on Discord (https://discord.com/invite/rust-lang-community https://discord.com/invite/rust-lang-community). - The package ecosystem (crates.io) makes it very easy to find and import things, and they're consistently documented. - There's a path to compiling on web via WebAssembly (https://rustwasm.github.io/wasm-pack/ https://rustwasm.github.io/wasm-pack/) In a few weeks of learning the language, I managed to put together this visualization: https://twitter.com/admiralakk/status/1542560489091350529 https://twitter.com/admiralakk/status/1542560489091350529 But realistically, either Go or Rust will be fine. You should pick the one you're more likely to stick with and learn, even when it gets tough. I've found the community aspect to be very helpful, because then at least I know I'm not the only idiot out there.
• bradhe 4y ago
  Learn both. Go in particular is quite simple. Rust will take a bit more time.
• Shadonototra 4y ago
  This kind of question is the reason why you'll never be good a good developer > I am a full stack TypeScript dev looking to broaden my skill set by learning a new language. I’ve been weighing Rust vs Go for a long time but can’t really decide which would be a better use of my time. I often hear that people who try one of these languages after coming from something like TypeScript feel that they really level up their abilities/understanding. I don't know if that's a joke or just misinformation
  • LecroJS 4y ago
    Hey thanks for the reply. This was really insightful and I really appreciate you taking the time! The most helpful part was definitely where you tell me I’ll never be a good dev because I ask questions I don’t already have the answer to :)
• yakubin 4y ago
  If you want to build web services, I'd go with Go. It has an http library in its standard library. It generally has a bigger standard library. Rust has a bigger stdlib than say C++, but it's still pretty anemic by the standards of modern languages. Go also compiles a lot faster than Rust, which is a major point. If you like functional programming, or want to write embedded software, or high-performance software, I'd go with Rust. All those things are a lot easier in Rust. Personally, I use Go for scripting and Rust for big projects, because Go compiles fast enough, has a nicer stdlib and dependency management than Python; while for big project my natural tendency to think functionally would make it too annoying having to translate simple concepts into programs twice as long as they need to be, expressing what they're doing very indirectly. But I don't write web services, so that's a different story.
  • drogus 4y ago
    I worked mainly in web dev for almost 2 decades now and having programmed both with Rust and Go, my vote would be to default for Rust, so I guess you everyone's mileage may vary. Also the argument about the stdlib is kind of weird. It's a deliberate choice to keep the stdlib small, also because adding a new package to the projects takes a few seconds. If you were tasked to do a web backend with a limitation of "you can't use any external libraries" then yeah, I'd say Go might be easier, but otherwise there's almost no difference in practice
• dmytrish 4y ago
  Disclaimer: I have no TypeScript experience. I'd say poking at both languages is useful. The choice of ecosystem can come later, according to the taste and tasks. Rust: - makes you a better coder indeed, Rust is pretty clear and organized about its abstractions. Sum types, honest traits, no nil values, disciplined approach to errors and generics, the right amount of niceties and syntax sugar. The idea of borrow checking (and when to avoid it) is a valuable insight into programming in itself. Straightforward RAII instead of wanton `defer`s everywhere. - fearless concurrency (no global mutable variables, Arc, Send + Sync, ownership of objects by threads) with reliability heads and shoulders higher than everything else. - first-class support for WebAssembly (wasm-bindgen, js-sys, wasm-pack, etc). Interfaces with other languages well (PyO3, Node bindings, C/C++ via bindgen/cbindgen). - fine-grained, low-level control over memory allocations and layouts. - requires quite a bit of effort and dedication to use it effectively. The standard library is extensive in volume (not functionality), takes time to learn, has its own conventions and context-dependent, non-straightforward idioms. Golang: - a language to get things done, with very decent and extensive ecosystem. - a perfect choice for backend servers, microservices, everything working over the network. - teaches about perils of freely mixing shared memory with concurrency. Goroutines are so easy to spawn, until they are not. Channels seem like a good idea, until dive into a real code base with mutexes and shared memory. Still, both goroutines and channels are solid, practical tools that work well. - writing new code is objectively faster and easier with GC. - compared to TypeScript, still teaches to manage memory layouts and has structs as values. - doing pretty basic things like iterators, sum types, custom data structures, even tuples of values can be painful, but this is changing with the newly introduced generics. - I still try to come to terms with the wild abuse of programming language theory terms in Go, where an "interface" is not just a trait, but also a set of types and behaves almost like a supertype.
• jrms 4y ago
  Try both and pick the one you like the most
• LecroJS 4y ago
  Adding for context: I don’t have a degree/background in CS. I majored in Math back in college and learned Python followed by a js bootcamp. I’m now years beyond that and have developed what I’d deem is enough of an understanding of CS fundamentals to the point that I can comfortably speak about/implement most things in the leetcode/technical interview space. My college didn’t have cs and I definitely feel like I missed out on learning about some really interesting things and now have an understanding that can only go so deep across the stack. Based on this, let me know if you think rust is the better choice, or if you have any other thoughts as to how might be good to spend my time e.g. maybe I’m just in the wrong space entirely and should be reading a book on Postgres… I love learning new stuff, but I sometimes find that I don’t invest my time in the wisest thing at a given moment. After thinking on the replies, I am now supplementing this post with a request for whatever you think would help someone like me
  • prirun 4y ago
    My degree is in Applied Math & Computer Science, at an engineering school, but the CS aspect was rather lame and the applied math part was basically useless for computers. But I got the piece of paper, which was my main goal. So like you, I've taught myself pretty much everything I know about computers. You mentioned reading a book on Postgres. If you don't know SQL, I'd recommend learning that, either with Postgres or maybe more simply with SQLite. Whatever you pick as a toy project, make sure it has lots of data to help you understand indexes. With small data, everything will be fast. With large data, like a few million rows, you have to become very familiar with how the database actually executes queries so you can add the correct indexes to make things run fast. And you can't just add indexes for every query, because that slows down inserts and updates; there's a trade-off there that you'll have to balance.
• sondr3 4y ago
  I've used both for a couple of projects, but my primary language of choice for most things nowadays is Rust so this will be a bit biased. However, Go is a fun language to use, it is incredibly easy to get up and running, it provides most of the tooling you need in a language (formatting, testing, linting etc) and compiles very fast (especially compared to Rust). It is a simpler language than Rust, and is missing a fair bit of more advanced features that other new languages has. Coming from TypeScript, I suspect Go will feel like a simpler version of it, the generic programming and type level magic you can do in TypeScript is far more advanced than the generics that Go (finally) has. Comparing this to Rust however is a different ball game, where Go is straight forward and fairly easy to use, with Rust it can feel like the compiler is your enemy. Learning how the borrow checker works, why there are a whole bunch of string types, how mutability and references work when passing them around and so on is a serious undertaking. But once you get somewhat comfortable with it Rust is great. The compiler will guide you along with very helpful error messages, you can use pattern matching, traits and a advanced type system to your advantage to build very performant and easy to maintain programs. In terms of getting "to the next level", I would highly recommend trying out Rust. Go is not a language that will challenge you the same way learning Rust will, the concepts and patterns from other languages map over fairly well to it (though the concurrency story in Go is really cool, definitely give it a good look!) whereas Rust will be more foreign. I had used Rust for a few years when I worked on a couple of programs written in Go and it took me a week or two before I felt mostly comfortable with it. With Rust however it took me a few months to stop getting compiler errors every time I saved, and a few more months to internalize why the borrow checker complains. But working on the projects using Go felt like a downgrade from Rust, I gotta be honest. So many times I sat there thinking about how features from Rust would've made things so much neater... though now I feel the same with Haskell and Rust.
  • LecroJS 4y ago
    Thanks! This helps and gives some great perspective. Given your thoughts on this, would you recommend I start with Go and transition to Rust, or dive right into Rust with the goal of looking back on Go and seeing the difference after 6+ months of Rust?
• pantulis 4y ago
  Good recommendations in the thread. I would ask myself: what would I expect to be building with Go or Rust? Of course, you can build anything with Go or Rust --or any turing-complete programming language for that matter. But *I believe* Rust programmers will be working mostly on foundational software --think caches, databases, compilers... while Go developers will mostly work building microservices and related tooling, stuff a little more business oriented.
• holografix 4y ago
  Learn go. It’s much more widely adopted with very significant open source projects written with it. You will become productive very quickly and it will help you make better use of multi core processors. Go just introduced generics which was holding back quite a few people from trying it. Now it’s the time.
• BobbyJo 4y ago
  Doing a few projects in Go will make you a better programmer in general, a it forces you to write simpler, more comprehendible code.
• schme 4y ago
  I'd go with C first. Rust would teach you everything C does and more, but C will lay the foundation in cleaner strokes. This will help you later no matter what language you decide to learn next. C is also in a way the language of the FFI, so you are very likely to need it in the future regardless.
  • LecroJS 4y ago
    Had a feeling a reply like this was coming. Could you help me understand a bit more about why C would be a better place to start and how it’d lead to me growing my skills in core areas vs something like Rust or C++? I hear about C++ and can’t wrap my head around the benefits of going with something like C that has less features. I recognize I’m asking what will help me grow/learn and am saying, “why use this if x has more niceties?” but hopefully you can humor me. One thing I hear a lot is that Rust is the language for the next few decades, and while I’m sure C isn’t going anywhere, I’d be very curious to hear from someone with more experience about why C would be the way to go here. I’ll admit I’m intrigued as I used to have a professor in college who was a wizard and did everything in C — especially since a game I like from 2001 has an active modding community so long as you know C/ASM. Explicitly: I’d be curious to know what the “cleaner strokes” are. I also have never even heard of an FFI so thanks for starting my next research binge! I always thought two langs could interact once they’re both compiled to machine code, but I’m guessing i took that for granted and that C does that heavy lifting..
    • schme 4y ago
      To list something: C teaches memory management, memory addressing, stacks and heaps, some disassembly, binary interfaces. Basically, you see the layer on top of machine language. Python, Go, etc. are a layer on top of that. Rust and C++ teach these things as well, but C keeps things minimal so you see the ideas more clearly. A lot of languages are written in C, forming a common way to think about implementation and problems, one you see glimpses of working in almost any other language as well. A lot of "why is it like this" questions have answers beginning "because in C..". The FFI part is due to the extremely stable and simple ABI. Compiling C produces predictable and known binaries, setting a lowest common denominator among languages (for bettet or for worse). Thus knowing the capabilities and limitations of C is useful even when working with other languages. A lot of this knowledge can be grasped quickly and you will get reminded of them for the rest of your programming life, so it's not necessary to dive deep into C to get the knowledge. C just provides the shortest and cleanest introduction, and you can quickly move forward without missing a beat really, since a lot of the stuff is so universal.
• spion 4y ago
  If you're looking to get into the k8s space Go would be the way to... go. Purely as a language, Go is worse than TypeScript by a lot (yes, even with generics), yet has a really well made standard library that more than makes up for it in many regards, and tooling thats similarly much better and pleasant to work with. If you're looking to learn more about systems programming as well as a bunch of advanced PL features that make development a joy, go for Rust. Besides being an excellent language, the library ecosystem and tooling are really well made as well (great documentation culture, tools work predictably and cover both simple and complex / larger use cases e.g. monorepos, etc.) I've decided to learn Rust. I had some small amount of hobbyist C++ development experience before, and the learning curve isn't as bad as it looks, and its definitely better than something like Haskell due to the excellent documentation resources. It took a couple of weeks, about 1h-2h per day to get past the initial "wall-like" learning curve for borrowing and ownership (its important to preserve during this period) I've refused to get into Golang as a matter of principle for a long time. I saw the language as a step backwards that deliberately ignores a lot of things we've learned in the past few decades in the name of "simplicity". While I acknowledge that the ecosystem as a whole is powerful, I'd like a tool that doesn't deliberately limit me without giving anything in return (lack of algebraic data types means reduced safety and more bugs due to inability to make illegal states unrepresentable, for example), all while trying to paint that as some kind of benefit. However, I reserve the right to change my mind if the right opportunities present themselves (also, given that they fixed generics, once error handling is made closer to Rust/Swift I'll be hapy to give it another... go) I think Rust has a bright future in the JS ecosystem as its already growing as both the underlying-platform-language of choice (Deno), the main compile-to-WASM language as well as the lower-level tooling language (SWC, Turborepo server, Parcel components etc). In the last space Go is also popular but I predict ultimately Rust will win because of the other factors.
• pizza234 4y ago
  I've gone this path, and it ultimately depends on your goal. If you want to broaden your skill set for your personal enjoyment, both are options, although "enjoying" learning Rust has a slightly masochistic trait ;) I believe Rust is more of a calling, in the sense that it requires a unique motivation - it really is _so_ hard, especially coming from dynamic/high level languages - and those who want to go through this, kinda know it already. But of course, that doesn't mean that it's for an elite only. In a professional context though, Rust is hardly a productive choice. It has a very narrow market share. You can throw the stats out of the window; they don't match reality; reality is that lots of Rust work is in crypto, and that positions at Big techs seem to be filled internally. In short: you'll find very few available and appealing positions. The good side is that Rust is sort of in its infancy, so there are fun communities to be part of. Go... is simply the conservatively good choice. It's easy, and it's everywhere, and it's still a good step towards systems programming (independently of it being classifiable as systems programming language or not), if that's a direction you find desirable.
• keyle 4y ago
  > I’d like to learn whichever language will make me a “better” coder in the long term. Install every compilers available under the sun and learn the bases of every language. Then dig deeper in each in what is idiomatic and why. From prolog, to arc, don't limit yourself to the mainstream languages. You won't be able to eventually avoid them anyway. Some day, Java happens.
• tekbog 4y ago
  I recently had to look into Go for an interview and the question you just made it's on a lot of people's minds however I'd say Go and Rust have different user cases so the answer, like always, it depends. I'm unfamiliar with Rust, so I'm mostly going to address the little I know about Go. It's a great language if you want low memory consumption, concurrency and a fairly simple codebase - the language is minimalistic and C-like so it tries to shove complexity away. I'm someone who hasn't touched anything with pointers in ages and really loved it. Docker, Kubernetes, Terraform and from what I've heard a lot of Google services are being developed in Go, think about what they have in common and if you have a similar use case or you specialize in backend and devops then GO for it. However people are reporting that Rust is coming to the Linux kernel soon so it seems like a solid choice no matter what you pick. I think I have a similar background to you and learning Go definitely made me a better programmer and it barely took any time. (Self promotion ahead, skip to last paragraph) I even made an article[1] that's an introduction to Go where I talk about everything that seemed interesting to me and I follow up with a small project, it's meant for junior to mid level developers that want to start with Go or are undecided. Perhaps have a quick look (it's been well received and featured in Hashnode). Overall I'd highly recommend learning Go, it was a breath of fresh air for me after working mostly with Node and Spring Boot. If I had to make a backend system, depending on the requirements, Go would definitely be a top choice for me. --- [1]https://bognov.tech/introduction-to-golang-build-a-mini-twitter-clone https://bognov.tech/introduction-to-golang-build-a-mini-twit...
• blub 4y ago
  I agree with the other poster saying that learning programming languages doesn’t make you a better coder, just as learning natural languages doesn’t make you a better communicator. It’s much more efficient to pick a flexible programming language which allows using various concepts (functional, OO, etc) and constructs and then apply it in various domains which exercise those concepts/constructs. Coding can also be learned. Code complete (2nd) is one of the few books focusing on this area - the author calls it construction - and goes into detail about building functions, parameter passing and so on and so forth. Another interesting book I read was Martin Reddy’s - API design for C++. You could try finding something similar for your chosen language. Finally there’s a couple of books by Pete Goodliffe which are language-independent: Code Craft and Becoming a Better Programmer. Naming, comments, error handling - there’s tons of stuff in there. Now onto the topic of Rust and Go - I’ve recently learned both and am about average skills-wise. Go’s easy (the book Efficient Go covers it) and has many sweet spots like network, cmdline tools, heavy concurrency services. Rust is complicated but you can see that it’s a heavy duty language that you can use almost everywhere. Neither made me a better programmer, because I was familiar with most of the concepts they provided. And the new stuff doesn’t improve ones skills, it’s just tooling.
  • LecroJS 4y ago
    Code complete has been on my list for a while and this definitely bumps it up that list! I like your recommendation about finding a book on subject area in particular. Thanks!
• kaba0 4y ago
  Why are these two languages chosen? I would suggest thinking of a niche you want to fulfill - you mentioned web servers, for that use case Go is fair, but do note that Go is a managed language much closer to JS than to Rust. There is probably not even that many new concepts in Go compared to TS (both use the otherwise rare structural typing). If you want to instead learn about low-level programming, Rust is a great choice, but so is C for some basic concepts.
• dceddia 4y ago
  I’ve been doing mainly JS and TS the last few years and picked up Rust because I wanted to build a video editor. It worked out, the product is launched (used Tauri which is also nice) and I’d choose Rust again, even despite the initial pain. The basics weren’t too hard, but I definitely felt the learning curve! I used C and C++ professionally my first few years out of school, and in some senses Rust felt like coming home - thinking about memory again, references vs values, the short naming conventions… but in other ways (lol borrowing) it was a very different thing. Rust was the first language I learned in recent years where I couldn’t just cobble things together once I knew the basic syntax. The ownership system was at the heart of that, and I kept doing things that went against the grain and made the compiler unhappy. Having come out the other side though, I’m really happy with Rust. It’s fast, and the safety aspect is awesome because I can be pretty sure that as long as I avoid .unwrap()ing things, the program isn’t going to crash. There’s none of the “null or undefined” anxiety like with JS. It’s also interesting to see the difference in the communities. I really like how performance is a first-class citizen in Rust! A lot of libraries have benchmarks. People go out of their way to avoid allocating memory. Maybe overkill in some spots for sure, but it’s a stark contrast to the JS world where I often get the sense that talking about performance will attract cries of “premature optimization!” For learning I used the official Rust Book initially, then Programming Rust (the O’Reilly one) to get another explanation of some things, and then Rust for Rustaceans - which was great but way over my head at the time and I should probably revisit it again. I would say learning Rust needs a very hands-on approach. It wasn’t, at least for me, the kind of language where I could read a book and then go write Rust. It took practice and failure and mental shifts that I don’t think would’ve happened if I was reading or watching videos. Good luck with whatever you choose and happy 4th!
  • LecroJS 4y ago
    Wow, I can’t believe I’m seeing you in these comments! I was so inspired when I first saw Recut, and I’ve been using your interview questions for inspiration in my own interviews recently. My plan as soon as I get my next day job has been to sit down and start making products with the hope of launching on product hunt and the like to start earning money on the side. This post was mainly shopping for input on long-term conceptual growth, so it’s really nice to get this bonus anecdote on Rust in production from you. I definitely would wait to fully invest my time in it until I have my next job given this + the other replies. I am curious if you did any research on Go or other languages for Recut and why you ended up choosing Rust. Would you make the same decision again? Was it worth the time it took to learn Rust for both product/personal purposes, or would you go with something easier if you had to do it again? Recut was especially interesting to me since I’ve had a real time video chat based app on my mind for almost 2 years now and have known js just won’t cut it. Seems like quite the indicator that I should invest in Rust. Thanks for your reply. Means a lot getting feedback from you down here in the HN trenches!
• Saphyel 4y ago
  If you want to improve your code skills I think Rust is the best way and also you could help to the linux kernel now ^^ If you are looking to do async apps I'd recommend avoid Rust in the short term (the ecosystem about async in Rust is a mess at the moment, hopefully in a few years is in a better position and probably in the core)
• Barrera 4y ago
  > I’d like to learn whichever language will make me a “better” coder in the long term. Since the goal is to learn rather than to get stuff done, I suspect Rust will give you far more bang for the buck. If you're arrived at TypeScript voluntarily as an alternative to JS, Rust's type system will teach you a lot about types. You'll also be able to take advantage of a lot of what you already know. Rust will teach you more than you thought there was to know about memory. Unless you've worked with a manual memory management language before, this will be a big eye-opener regardless of where you go with Rust in the future. But I suspect you'll be most surprised by how approachable Rust is. It feels like a much higher-level language than its reputation might hint at. The single reason for Rust's difficult reputation is the "ownership model." If you own that and commit to figuring it out and practicing what you've learned, Rust will open up much more easily to you. That said, you can figure out a lot about Rust without ever using ownership.
• KingOfCoders 4y ago
  More Rust than Go experience. Both aren't perfect to me. I fight the borrow checker too much in Rust and everyone tells me to use Arc<> which is ugly. Go has a nice GC. Rust is a richer language than Go, Go is much simplier. Rust has a much nicer build system (rustup, cargo, ...). Go is fantastically fast when compiling. Go has currently the best async execution runtime with IO parking.
• nunez 4y ago
  start with go for employment opportunities then learn rust. if employment isn't a driving concern here, both are great languages.
• mardix 4y ago
  I have a Python and TypeScript background, and I worked with them on a daily basis as a web developer. Rust will be more familiar and easy on the eyes, as the syntax and concepts are close to friendlier languages. I just started to get into Rust as well, and so far I'm loving it. Here are some resources to help throughout the journey: https://fasterthanli.me/articles/a-half-hour-to-learn-rust https://fasterthanli.me/articles/a-half-hour-to-learn-rust https://stevedonovan.github.io/rust-gentle-intro/readme.html https://stevedonovan.github.io/rust-gentle-intro/readme.html https://learning-rust.github.io/docs/a1.why_rust.html https://learning-rust.github.io/docs/a1.why_rust.html And for Youtube: https://www.youtube.com/c/LetsGetRusty https://www.youtube.com/c/LetsGetRusty Good luck and have fun!
  • LecroJS 4y ago
    Thanks I appreciate the context and resources from someone with a similar background!
  • lcall 4y ago
    As someone with background in Perl, Java, Bash, Scala, and others (FoxPro anyone?, ...), for me the choice is also Rust. I want to spend my finite learning energy and time on what will give me the fewest limitations and most abilities, long-term. :)
    • mayormcheeseman 4y ago
      Had to learn FoxPro to support some legacy software. Fun times :)
    • lcall 4y ago
      (a ps: and some C/C++ which make me like Rust even more)
• dboreham 4y ago
  Either or both would be fine. They're both "proper" programming languages today. golang is the F-150 pickup truck of languages, while Rust is more on the V10 Lamborghini end of the spectrum. More difficult to work with, life is more exciting. golang has essentially no nonsense in it (due to guardianship by crusty old men at Google). No async ever happening there, thankfully. Rust, lacking a single corporate backer, has more evolutionary churn and a bit less pure focus of vision imho (concurrency implementation changed several times, it now does have async even though there's no need for it).
• rowanG077 4y ago
  If it's for learning choose Rust. Go has not much to teach you since it's such a basic language. Actually I would also choose Rust for getting things done. It just takes longer to master.
• thinkpad13 4y ago
  for what type of application are rust and go used nowadays? I know ruby has ruby on rails, python has django, panda, torch, keras and tensorflow, typescript/javascript has vue and react and express and etc.
• fiatjaf 4y ago
  Learn Scala.
• garren 4y ago
  If your goal is to become a "better" coder, doubling down on understanding the fundamentals rather than the specifics of a given language seems like an approach to consider. That said, others here have recommended C instead or in addition to Rust or Go; this makes sense to me. C is actively used and remains the lingua franca of low/system level programs (for the time being.) I'd also say that its relatively simple syntax and closeness to the underlying representation have a lot going for it (at least what you'd imagine the underlying assembly representation to be - hardware and clever compilers are doing a lot.) The C language is simple, more than either Rust or Go, and can be picked up quickly, in my view. But actually understanding and using it competently is an altogether different matter. Additionally, an absolute wealth of books introducing OS, drivers, and system and network programming topics using C exist. Projects like Xv6, Minix, and even Linux provide for code bases to run through and explore - Computer Systems: A Programmer's Perspective [0] - The Linux Programming Interface [1] - Advanced Programming in the UNIX Environment [2] - Dive into Systems [3] And the list goes on and on. You'll likely never write production code or push production projects in C (one hopes), but it seems to me that it remains a very useful language to be able to work with and to understand. [0] https://www.amazon.com/Computer-Systems-Programmers-Perspective-3rd/dp/013409266X https://www.amazon.com/Computer-Systems-Programmers-Perspect... [1] https://www.amazon.com/Linux-Programming-Interface-System-Handbook/dp/1593272200/ref=sr_1_1?keywords=the+linux+programming+interface&qid=1656955811&s=books&sprefix=the+linux+pro%2Cstripbooks%2C184&sr=1-1 https://www.amazon.com/Linux-Programming-Interface-System-Ha... [2] https://www.amazon.com/Programming-Environment-Addison-Wesley-Professional-Computing/dp/0321525949/ref=sr_1_3?keywords=advanced+programming+in+the+unix+environment%2C+2nd+edition&qid=1656955855&s=books&sprefix=advanced+progra%2Cstripbooks%2C140&sr=1-3 https://www.amazon.com/Programming-Environment-Addison-Wesle... [3] https://diveintosystems.org https://diveintosystems.org
• karmakaze 4y ago
  Here's a different take on the question based on my own experience. I learned Go from the online "Tour of Go"[0]. It was easy to read and learn with the interactive presentation. I came from a C/C++/Java background so the interesting things were all around concurrency (goroutines/channels), value types and struct layout, and the use of structural vs nominal interfaces. I'm glad I learned Go and use it for many small personal projects and on occasion at my day job. I've dabbled with lots of different programming languages/paradigms to learn what's out there that I haven't been exposed to. A sweet spot of my interests is around F# or OCaml. Pony looks like an ultimate language of a sort that includes Rust and Clean. I've also wanted to have a reason to learn and use Rust. Much like I appreciate static typing, I could immediately appreciate Rust's different reference semantics to make safe and correct concurrent software with higher performance than is possible with Go. But this is where I have to decide where to spend my time. I have a vague idea of the strong areas of Rust. I don't currently work in areas where those are prominent needs. I could justify it for any kind of low-level project I could come up with. Until I have that itch, it's on the back-burner as I don't consider learning Rust for the sake of learning Rust and its reference rules a big benefit to me. I can still spend most of my available time getting better at conceptualizing, shaping, and implementing monolithic APIs and distributed systems which isn't exactly tied to a particular language. [0] https://go.dev/tour/welcome/1 https://go.dev/tour/welcome/1
• cyneox 4y ago
  Speaking for myself: For someone who didn't have a software engineering background (for the last decade I was mainly doing offensive Security stuff) probably the main choice would be Python. However, at some point I've felt in love with statically typed languages: The compiler became my biggest friend and I learned about the benefits of having "contracts" (in form of interfaces, strict parameter types for methods etc.) between (software) components. That's why I've spent the last years learning Go. It taught me how to design bigger projects and how to tackle architectural problems in an easy/comprehensive way. I didn't try Rust yet because I didn't have to. I mainly code software/tools to work in cloud environments and HTTP/gRPC technologies. Under these circumstances Golang performs quite well. For me it's true that Go "is better for getting things done": You'll get one statically linked binary that can be executed almost everywhere (without further dependencies). I'm a big fan of serverless and I wrote simple applications that currently run in AWS Lambda and Netlify (they also used Lambda under the hood). And more recently I got into web development where Golang is again my main choice (at least for the backend part). For frontend I would rather go for VueJS/React. And that's one reason why I've started to learn TypeScript. I don't have that much experience in TS but I guess I could easily replace Golang by TS to do simple things (HTTP requests, JSON parsing etc.), especially in a Serverless environment. While my Golang journey was accompanied by this "Golang vs Rust" debate, I do plan to learn Rust as well. But as I've mentioned before, currently I don't have any needs to do so. My advice would be: Learn both (for backend) and some TypeScript (for frontend). Just my 2 cents...
  • LecroJS 4y ago
    Thanks! Interesting to hear from someone who started with Go and transitioned to TS
• taylodl 4y ago
  Given where you are now I'd learn Go. Go is a language born from the cloud. It solves modern-day problems featuring several networked machines with each having several processors. It's probably going to be the most useful language to you because it allows you to build systems solutions spanning several networked machines. Go is also an easier language to come up to speed with than Rust. I see Rust as a replacement for C/C++. It's for system programming on a single machine. Its claim to fame is having memory safety - it's a modern language. If you're wanting to build a more traditional app running on a single machine - use Rust.