Hacker News Reader

Comment by leke | Hacker News Reader

Nice - Sampling a couple of the videos, the topics are explained really well.

This makes it even harder for me to decide what to learn for my next programming language. Go, Rust, or Julia.

Go is low-hanging fruit. You can pick it up in a weekend pretty easily. Rust is a much steeper learning curve, but it will also deepen your understanding of type systems and memory management. Julia seems like it hasn't broken out of the data science niche in full yet, and even there it seems like it hasn't made a ton of headway with respect to marketshare--it doesn't seem like it appeals much to me.

If you want something halfway between Go and Rust, I'd look at Gleam--it seems like a garbage collected Rust, so you get a nice ML-inspired type system without the pedantry of the borrow-checker (sometimes that pedantry is helpful, but rarely so for the applications I write). This would be next on my list of languages to learn.

Also, my favorite way to learn a new language is to write a static site generator. It will take you through a tour of the standard library as well as the third-party library ecosystem. It's a simple project without being a toy.

Julia is more for Scientific Computing than Data Science, think weather prediction and fluid simulations vs data visualization and gradient boosted trees. In that niche Julia is doing pretty well in fact. Also it's an interesting language in general, with a nice macro system and a powerful multiple dispatch one, it's definitely worth learning IMO.

Fair enough. I’m pretty far from scientific computing or data science, so I tend to lump them together.

If you'll forgive me creeping around in your comment history, it looks like you work with PHP? I don't know Julia, but between the other two I suggest you should learn Rust.

Don't get me wrong: Go is a really good language, and eminently practical (and I am ATM working on getting productive with it myself) , but it doesn't have anything particularly novel to teach you, and part of what makes it good is that it's really easy to pick up, so it's something that you can just learn on the fly if you need to.

Inversely, Rust requires a fair bit more ramp up time if you ever need to use it in anger, and there's a lot of fairly novel stuff to learn there that is generally useful, so you'd benefit more from learning Rust as a project.

Julia is also a pretty good language, though Rust is definitely the more unique of the two in terms of how it changes the way you approach problems. Julia has some uniqueness in that it allows for metaprogramming via macros and has multiple dispatch as a first class concept. However, Rust makes you think a lot more about how you lay out data while also covering stuff like pattern matching (and the combination of the two ends up being pretty interest as well even if you already have experience with a language like Haskell or ML).

However, Rust is a very difficult language and so Julia or even Go might be a better second programming language (definitely not a good first language). While Go is pretty standard as languages go, it does have static typing which PHP lacks (at least by default).

Go's main benefit is that it makes you a better coder, simply because the language offers you only basic (but well thought) tools. This constraint makes you think deeply about what exact problem you're trying to solve, and reduce your problem down to its core.

This is an underrated benefit of go, but to me it is by far the most important aspect of the language.

Yep, I'm a PHP dev and often do simple JS/jQuery to support my backend code. I have a very general interest in data science and embedded programming, meaning one day I might start doing something with them, but for now, I'm interested in those languages for web development. The following frameworks were especially interesting

Go: https://github.com/gin-gonic/gin

Rust: https://rocket.rs/

Julia: https://genieframework.com/

Depending on your current language, I might recommend Rust because it integrates really well for writing high-performance extension modules for other languages.

For example at $WORK we're slowly rewriting our entire data processing pipeline in Rust, but for awhile we've had a hybrid Rust / Python setup using PyO3, which makes it really easy to build your Rust code into a shared library and call it from Python, with the entire API specified declaratively using derive macros and the GIL handled for you using typestate tokens. Really cool stuff.

How do you handle deploying the rust code that's embedded in your python code? Do you have multiple deployment targets for the code (mac, linux, windows)? This is the sticking point for me with embedding rust into my python projects.

Build Python wheels on CI with the statically-linked Rust binary?

We use Maturin to build. You can either build manylinux / Windows / OSX wheels and upload them to PyPI / your preferred distribution method, or easier, use `maturin develop` to build and install a wheel into the currently-active virtualenv.

I'm not a huge Go fan, but I do have to give it a lot of credit at its very linear learning curve. You get a few basic concepts, and you're pretty much good to write a great many things. It can really frustrate you if you've done other languages - and you're used to being able to solve problems in many different ways. Rust on the other hand has a what I'd call a factorial curve. You get Hello World, you get into learning how most things return a Result monad... and then you're hit with some really complex stuff. It can be deflating unless you really stick with it. The language is pretty vast, so you won't be re-inventing things like many often do with Go. Both are worthwhile tools to have in your toolbox. I will say that if you're into web-dev, Go will get you results with less "pain". But even that's debatable.

This is a Rust thread about learning Rust. I believe you will mostly get advice to learn Rust, as would be my advice, but that’s because Rust fits into the work environments that I enjoy.

Databases, distributed systems, backend web systems, webassembly, low level systems programming. Rust is fantastic at these things.

When aiming to learn something new, I find it best to ask myself what I want to accomplish with it. Each of the languages you’ve listed have made significant inroads in various areas, learn the one that fits your use cases the most.

Many people are rightfully recommending Rust and Go, so I'll weigh in under what circumstances you should learn Julia.

If you regularly find yourself solving problems with Matlab, numpy/torch/pandas or R, you'll be delighted to learn Julia. R and Matlab were great at the time, but really show their age. Python was never meant to be fast, so all the algorithms are in C/C++, making them very hard to inspect, modify or build upon. Julia excels at bridging the gap between high-performance numerical algorithms, great composability through it's type system, and a great syntax for vectorized programming, which makes it straightforward to inspect and change code for very complicated algorithms. For instance, check out Octavian.jl for a pure-julia (fast) alternative to BLAS - or try reading the DataFrames.jl source code (and compare it to the source code of pandas).

Note also that the mentioned applications go beyond data science into general machine learning (+deep learning), simulation science, optimal control, decision making under uncertainty, and many other fields leveraging custom numerical algorithms.

BUT, Julia is (imo) only worth learning if you need to write sophisticated numerical algorithms. If you're more of a systems level programmer, web dev, etc, you might not appreciate what sets Julia apart. Julia and Rust target somewhat different niches, with Rust being much more aimed at developing applications with many interacting components that may not fail. Go doesn't really target numerical programming at all and is instead great for multiple-instruction-single-data (MISD) applications (as opposed to SIMD applications like matrix multiplication).

Maybe you should start with "why" you want to learn a new language?

Job? I'd say Go

Command line tools with complex logic for fun and community support? Rust

Julia? Julia.

Minor quibble, but Rust engineers are in wildly high demand - even beyond normal engineering levels.

Many of the majors are hiring a ton for rebuilding backend stacks and crypto still wants as many as it can get as well.

Well, one obviously should evaluate local market (or the global market if this is a valid option) for jobs offerings.

I should've been more careful about this in my statement :)

> Job? I'd say Go

If you want to work in the learned language, then sure. But if you just want to increase your general employability then Rust is probably a better bet. You'll learn more, and it will make you a better engineer in every language you use. My JavaScript has been greatly improved by learning Rust.

> If you want to work in the learned language

That's what I mean, yes. Obviously you should broaden your horizons to learn or discover something new and improve your skill in a general way.

Definitely Go, you can crank out stuff with it over a long weekend or a few hours a night for a week. You won't be a senior Go programmer but if you know another language, you'll pick it up quickly. You will not pick up Rust and Julia quickly (as compared to go) :) .

Reply on news.ycombinator.com