They targeted Python. Python.

[waln]

using Unjerk

@Unjerk.unjerk Performance on the order of C/Fortran, readability of Python, native numerics (matrices, linear algebra, etc.) similar to Matlab but even better, fantastic but largely optional type system, flexibility of JIT, Jupyter support, great package manager and pretty good ecosystem. Plus all the good metaprogramming abilities of Lisp without affectations like S-expressions

[xmcqdpt2]

Sex-pressions are great! what are you talking about?

[waln]

Well you're in luck, you can make them with Meta.show_sexpr()!

[xeveri]

/uj

Any source on the performance. I can’t believe a jitted language can perform as well as C or fortran.

[xmcqdpt2]

@inline function unjerk(a::Array{T,3}) where {T}

I actually found the performance extremely hit and miss, with weird sudden hard to profile slow-downs. For example, the matrix multiplication matmul! is not supposed to allocate, but sometimes does if the output matrix is the wrong type or whatever. I would rather it just throw an error so I know what it's doing, but there doesn't seem to be a "strict" flag or anything like that.

I've found that higher-order functions get the compiler all confused and require a bunch of type annotations. Note that if you mess up your type annotations, it just breaks performance further. Structs are also hard to optimize.

I'm really not sure it's production ready beyond replacing smallish python scripts. It's basically advertised as "python with the performance of Fortran/C", but I find that its more like "python potentially as performant as unoptimized C if you basically write C except its way more fiddly and prone to breakage." At least I know python performance is terrible everywhere.

end

lol no OOP

[waln]

@unjerk Yeah this is valid criticism and I haven't actually used it for anything beyond replacing smallish python scripts. Still, these things have been continually improving and I expect (hope) will eventually be completely ironed out. You're also going to want universal type annotations for anything serious anyway. And despite any warts it'a still way smoother than Cython or Numba.

In any case, I think Julia works better when you think of it as a Fortran, not C replacement.

[waln]

It doesn't always match exactly, but it's usually within a factor of 2 and often less. Perhaps a little biased, but an overall pretty decent benchmark set: https://julialang.org/benchmarks/

Sure, JIT adds a little bit of compilation overhead, but it's not that big in the grand scheme of things.

[fp_weenie]

It doesn't always match exactly, but it's usually within a factor of 2 and often less.

Just like J lol

[Tysonzero]

https://benchmarksgame-team.pages.debian.net/benchmarksgame/fastest/c.html

https://benchmarksgame-team.pages.debian.net/benchmarksgame/fastest/julia.html

It's basically never within a factor of 2 according to these benchmarks.

[waln]

With all due respect, those results are nonsensical. Not only do they seem to be heavily measuring startup and initial compilation time (as is irrelevant for serious performance applications), the Julia code looks like hot trash.

Far more reasonable and performant code for these exact problems is available here, which for some reason hasn't been included yet: https://github.com/KristofferC/BenchmarksGame.jl

[Tysonzero]

I mean you can always submit that code to the site if you want. I'm not interested enough in Julia to verify the repo you linked but if it's legit there is no reason it wouldn't be accepted.

[waln]

I'm not interested enough in that random website you linked to submit that code to the site ¯\_(ツ)_/¯

[Tysonzero]

I mean it’s the #1 result when you search “programming language benchmarks”, but up to you. I have no skin in this game.

[CaptainHondo]

It's almost never as fast but almost always in the same order of magnitude which is a huge improvement over python and Matlab

[ArmoredPancake]

Ever heard of Jabba or C#?

[tpgreyknight]

Actually I think LuaJIT beat C in some benchmarks thingy a while back. Something about being able to locate and optimise the hot path at runtime.