Hacker News Reader

Comment by thanatropism | Hacker News Reader

When I first heard of Julia in 2016 it was sandwiched between R and Python and thought it had no chance whatsoever of succeeding.

I’m increasingly impressed by Julia. It’s a crowded space and they remain relevant. Maybe even best of class for some applications.

View on HN

It has a lot of potential. You can often write code in Julia that is really performant by just following a few simple rules. Most notably, keeping type stability. Libraries are now catching up. Some are great, some are unique, others are still missing.

I have generated SIMD code that outperforms C and C++, even after some hand optimizations. As a matter of fact, some people are re-writing a BLAS drop-in replacement in pure Julia, and the performance is not going to be too far off from BLAS [1]. If you work in scientific computing, you can probably appreciate how amazing that is.

The combination of multiple dispatch, a simple type system and an LLVM backend is wonderful. In the long run, Julia will probably grab lots of Python's and R's marketshare because having a single language instead of two languages (Python + Cython/Pythran/... or R + C++) is a huge advantage.

[1] https://discourse.julialang.org/t/we-can-write-an-optimized-...

Maybe Julia will become more popular, but I'd bet on the 800 pound gorilla Python getting faster through broader use of Dask, Cython, and Numba. I'll never bet against the network effects of language and library development.

People often talk about speed as an advantage of Julia (which is true), but the real secret advantage compared to any other language I've worked with is more of a network effect: composability

I didn't appreciate the importance of this (or the degree to which this just works as a result of multiple dispatch), but there's a good talk about this from JuliaCon 2019 [1] by Stefan Karpinski

[1] https://www.youtube.com/watch?v=kc9HwsxE1OY

One aspect that's underappreciated is that composability can actually lead to speed. If it's super easy to compose your algorithmic package with speed-improvement packages (parallelism, hardware accelerators, custom compilers), you're much more likely to be actually able to use them.

Pretty sure you can call Julia code from python, and vice-versa.

That's why Go will supersede Python. All the new cool and secure small shit is being done in Go.

Go is not gonna replace SciPy

No operator overloading, and scientists ain't gonna look twice at anything without that

Please no.

Elaborate?

Grassmann.jl is the library that made me take Julia seriously. It's an awesome library, and the author really gets one of Julia's most special and well integrated features, multiple dispatch.

Because the code is written in solid, idiomatic Julia, it's interoperable with tons of other libraries. I actually had success using this library with CuArrays.jl without any modifications. So yeah, you can use it to run geometric algebra computations on a GPU for algebras of dimension < 2^5 (in my case, I tried it with CGA3D).

<= 2^5

The same first impression for me. It's great people with more faith than me have pushed forward and actually I'm still waiting to make the jump. It was very similar with python for scientific computing in the beginning. When I wrote my master thesis in python in 2006 python was completely dwarfed by Matlab. I was more enthusiastic on those days trying new things and also had more time. It is yet to be seen if Julia displaces python but at least it has non zero chance of doing it.

I’ve wanted Scheme / Racket to make a showing in places where R and Python have dominated the data science and numerical computing spaces (for those of us not writing C/C++/Fortran).
But, I think Julia is the closest thing to an honest-to-goodness lisp that has a prayer of mainstream adoption. I quite like Julia and think the community has leveraged the meta programming strengths of the language well enough to convince me to relinquish my love of minimalist lisp syntax.
I do wonder if the biggest risk to Julia isn’t that it’s not extreme / superlative in any dimension. If you want raw performance, Rust seems to be capturing the lion’s share of excitement among “new” languages. If you want meta programming, Julia still feels like a compromise compared to Scheme/Racket/Clojure/Common Lisp. If you want libraries, Python is still king. If you want stats libraries, R is still king. Julia is impressively good at all of those things... but it’s not good enough to be the most compelling of any of them.
Still, it makes me think that it may be time to dive in head first rather than dabble my toes as I've been doing for the past few years. I guess my main barrier at the moment is compiler / deployment story—it still seems hard to build a deployable binary that fits in, say, a Lambda layer as far as I can tell.

Even if Julia never ends up being the very best at anything particular, Python has shown that being "generally the second best language for everything" has even more value for most people. Leveraging 80% of the flexibility and composability of Lisp, 80% of the "code that looks like pseudo-code" aspect and overall easy to use from Python, 80% of the speed of the fastest static languages and eventually the library and tooling maturity to support all use cases, it can definitely become an even better second best language for everything.

> it’s not extreme / superlative in any dimension. If you want raw performance ... good at all of those things... but
I guess the selling point is that being good at many things means you don't have to keep switching between all these languages, or glueing them together. Others have mentioned the composability benefits of this. But it also has a learning advantage, I think. You can incrementally learn to speed up the crucial piece of something. You can learn just enough metaprogramming to solve some problem you have.

Reply on news.ycombinator.com