Birbla

Join the discussion

Write your take first — we'll ask for email only when you're ready to publish.

Sign in
  • Hacker News
  • Julia is going to overcome Python in usage, any decade now.
    by rgavuliak
  • The Julia type system is also great for AI, it makes code generation more robust. I also liked that some Julia code (such as matrix multiplication) can be executed on a GPU with no change and will be almost as fast as possible, although complex algorithms still require writing specialized kernels (which can be done completely in Julia as well).
    by dandanua
  • I'm curious, does anyone use Julia for Operations Research/Optimization/Supply Chain/Logistics? I am trying to learn more about the use of the language in that space. Thx.
    by Syper
  • Yes! This is a beautiful use-case, thanks to JuMP.

    https://jump.dev

    by mbauman
  • Safe for BASIC I believe it's very difficult to make a programming language which is easy-to-learn like the creators of Julia proclaim. It may be somewhat easier to implement specific scientific functionality in the language but does that warrant the creation of yet another language?

    Scanning the language it doesn't strike me at all as "simple."

    by hn_submit
  • Julia abstracts entire programming paradigms in single characters.

    https://juliahep.github.io/Hands-on-Julia-for-particle-physi...

    BASIC "made simple things easy, and hard things impossible..."

    Julia is the first language I've seen in years that implicitly abstracts parallelism cleanly. =3

    by Joel_Mckay
  • Do you think the criticism in the article "Why I no longer recommend Julia" about correctness is still valid? * there are too many correctness and composability bugs throughout the ecosystem to justify using it in just about any context where correctness matters *

    https://yuri.is/not-julia/

    by radiator
  • I do. It pairs nicely with this quote from the article:

    > “With Dyad 3.0, you can upload data and design documents and the system will design an entire aircraft for you,” Shah says

    by yurivish
  • Programming languages have bugs. These things happen, and this tired article blows them totally out of proportion.

    Some languages are less permissive, and have a culture of searching harder for corner cases and dealing with them than others, that is true. I would expect to find less cases like this in Rust, but more cases like this in Python.

    Julia is an extremely flexible and permissive language, which means that generic code needs to be written carefully and contracts between interfaces need to be thought through.

    When you combine funky package types like OffsetArrays with functions from a package where the authors didn't think about OffsetArrays, bad things can happen. Those things were then reported and the community has learned a lot about how to deal with those sorts of things.

    I'm sure an AI agent can crawl through and find a new big list of weird bugs in julia, but that's true even of a language like Rust.

    by eigenspace
  • As someone who could be tempted by Julia but isn't involved in the community this was a very helpful read, thank you for sharing.
    by ainch
  • I think that article has been discussed to death and there's not much value in resurrecting it on every single post that mentions Julia. ultimately if you think the language might be a fit for your use case, I'd recommend trying it out and see how you like it first-hand.
    by postflopclarity
  • Julia is my go-to when I need a fast language that I can reason about in a functional way. The type system is fine, the pattern matching is pretty darn good, the metaprogramming story could be significantly better but it’s not bad and boy howdy it’s fast. So stinking fast.
    by ashton314
  • When I was a grad student at MIT, my desk was across the hall from the Julia people. We even shared a lunch table. Julia is most famous for its optimizing compiler, but many people may not notice the careful work that went into designing the language itself. Matlab this was not! I remember one long conversation where one of them was teaching me about the different types of normalization of unicode. They had to pick one to canonicalize unicode variable names (more useful for a mathy programming language), and they were carefully considering the consequences of the options.
    by drhagen
  • I don’t know if experience has just damaged my brain or what, but I really like matlab’s syntax for what it is. Nice for writing 100 line experiments or using in the REPL. Sort of like the Python of linear algebra, haha. It also has a nice feature where you start getting headaches to let you know you’ve tried to extend it past its comfort zone.

    Julia seems to sit in this area between Matlab and Fortran where I can’t ever find a reason to learn it instead of just using one of the other two. But people seem to love it (and the GPGPU support sounds like it is good?) so I should probably just make up a reason.

    by bee_rider
  • Julia is really fun to use, and I think they are onto something with the type system: Complex types interact much better across module boundaries than in most other languages; here's a good talk on this by one of the creators:

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

    The biggest drawback of the language in my view is that Julia is an LLVM toolchain "pretending" to be an interpreted language (it is, technically), this often leaks as very slow first execution latency (and almost forces you to keep the interpreter open instead of just calling it on the file you're editing).

    by myrmidon
  • Yeah I think if Julia had a plain interpreted mode or a base template JIT that could tier up to LLVM's, they could drive that execution latency down a lot.
    by smasher164
  • I really want to like Julia. It has a nice type system, a good ecosystem, reasonable syntax, and it’s far faster than Python. But there are several issues with its DX that prevent me from using it: the most severe of which being the complete lack of a cache for the JIT (or JIT like system), inducing multi second compile times for scripts that run in <100ms. There are some external packages that try to solve this issue, but they are far from first-party quality, and, in my experience, are quite buggy.

    (I last tried Julia a few years ago; perhaps this has been improved since?)

    by maxall4
  • I imagine this will only become more important as we have more agents working on codebases in parallel; so a clean solution would be extremely valuable.

    On the flip side, the rise of agentic coding means that the library/batteries mismatch against python will largely stop mattering. It should be very easy to have an agent implement large libraries -- especially if they can be just a translation from one language to another (esp. one with with better primitives!)

    by ssivark
  • > tried Julia a few years ago; perhaps this has been improved since?

    The pre-compiled binary outputs are much smaller, and load a lot faster. =3

    by Joel_Mckay
  • a between session cache had been merged for 1.14 (release expected within 6-12 months).
    by adgjlsfhk1
  • Also the module/import system is still quite painful/hacky. Which is partly due to the long compile times.

    https://docs.julialang.org/en/v1.13-dev/manual/workflow-tips...

    by jampekka
  • I did some Julia benchmarking over the weekend against a bunch of languages if anyone is interested. The workload is an EKF on an Apple M1, I'm trying to do as many as possible in parallel:

    https://raw.githubusercontent.com/mech-lang/mech/codex/taich...

    Compared against Taichi, Halide, Futhark, Rust', Lua, LuaJIT, Numpy and pure scalar Python. Julia holds up great it can run basically as fast as you'd like! (These are not apples-to-apples comparisons, picture this as a basket of fruit)

    'The Mech results should be understood to be a lower bound on how Rust would perform.

    by cmontella
  • Nice. Suggestion: Add PyPy too.
    by Qem
  • I'd like to see how Mojo performs here
    by fhn
  • Julia is fantastic if you do numerical work and want to write out your inner loops explicitly without sacrificing too much performance, either for pedagogical reasons or because you want to fiddle with the algorithm.

    It is a lot of fun to start from an empty file, add maybe an import LinearAlgebra, and develop things like a convolutional neural network or a Markov-chain Monte Carlo algorithm completely from scratch. And then it is very rewarding to have such a program be fast enough (looking at Python here) to train on the MNIST dataset or find reasonable estimates for critical exponents.

    I am not sure there are languages better suited than Julia for these kind of things.

    by prof-dr-ir
  • And if you don't want to code your own HMM it also has the best (AFAIK) HMM library out there (HiddenMarkovModels.jl).
    by Staross
  • Julia also has some of the nicest GPU abstraction frameworks of any language, achieving pretty low friction portability over a decent subset of CUDA, Metal, ROCm and CPU. KernelAbstractions.jl, AcceleratedKernels.jl etc.
    by guiriduro
  • Julia is such a great language, it's what really made me care about end enjoy programming. I think it's the modern language which has taken the most lessons from lisps, and has come up with some great ideas of its own too.

    There's lots to like, but I think the thing I love most about it and find it so interesting is that it's almost uniquely good at taking a piece of code and transforming it's meaning in various ways, and has so many tools for doing so. There's

      * Multiple dispatch allowing very flexible writing of generic code, and multiple dispatch isn't some tacked on, opt-in extra. Every function in the language is overloadable, and there's no performance penalty for using multiple dispatch

  * Parametric typing allows for a huge amount of abstraction over common 'base' types

  * Lispy macros let you do metaprogramming that changes the meaning of a piece of syntax

  * Generated functions let you intervene at compile time and lets you essentially take over the compilation pipeline and customize the code generation for any given input type signature

  * The abstract interpreter interface which lets one essentially take over the compiler and customize your code generation and analysis passes to your heart's content. This is used for instance to support GPUs and automatic differentiation as package offerings.
    by eigenspace
  • I love multiple dispatch and I wish more languages had it
    by aqme28
  • It was a great idea for a language. In practice though,it's hard to recommend. Great pet project for some mit professors to make a bunch of side money on top of their salaries though. Everyone else riding it is pretty much trying to niche their career rather then build something people can rely on unfortunately. It's the most unstable language I've ever used. In production I watched companies spend millions of dollars, not large companies, dealing with that aspect of it. The ecosystem surrounding it, though it's old enough, is also incredibly weak.

    It's a shame. So hard to recommend it to anyone outside of an academic environment.

    by lalalanananana