[snystrom]

I have literally no skin in the game here, but here's another interesting group that totally bailed on a similar project because I guess they hated Julia so much. Good to see something else crop up.

github.com/JuliaOptics/About

[etik]

Ah, that's too bad, but I can't really blame them. Going from a fully-featured Python codebase they already had in https://github.com/brandondube/prysm and translating into Julia would need to be motivated by much more than speed - after all the limiting factor here is FFT and heavy computations like cis, so I'm pleasantly surprised they reported gains from their simple port compared to numpy. It's also much easier to go from a C/C++ computational code to Julia than it is from a Python one, because the mental performance models are more similar.

For reference, we (metalenz.com) have a large Julia codebase centered around optical design, simulation, and analysis. The motivation for that is more along the lines of composability and clarity of abstractions (aided by multiple-dispatch). We can differentiate through our physical optics solver code (forward or reverse) for optimization/ML, plug in our designs across a hierarchy of different E&M solvers, run on GPU, and write very efficient code when our profiling identifies a bottleneck. If we just had to perform one thing (physical optics simulations), then our investment wouldn't be as justified.

[ruph123]

Interesting! This really speaks to me. In my opinion your language can have the most foreign concepts or unusual ways how you should optimize code.

But only if it is well documented. And that is really the problem with Julia. Besides some video tutorials, which I don't find helpful, you only have the manual which is not that good.

I said this before here but if you look at Rust which has unique characteristics like the borrow checker and is often described as having a steep learning curve: I was never overwhelmed by it or even felt it was difficult because there is much high-quality material to help you: The amazing book, rust by example and a lot of great third party resources like cheats.rs or the "rust in simple language".

The other day I was trying to look for julia books. Most of them were outdated and people advised against buying them (or the publisher pulled them already).

[cbkeller]

I think people often underestimate (or just plain don't know about) the degree to which a multiple-dispatch-based programming language like Julia effectively implies its whole own dispatch-oriented programming paradigm, with both some amazing advantages (composability [1], and an IMO excellent balance of speed and interactivity when combined with JAOT compilation), but also some entirely new pitfalls to watch out for (particularly, type-instability [2,3]). Meanwhile, some habits and code patterns that may be seen as "best practices" in Python, Matlab can be detrimental and lead to excess allocations in Julia [4], so it may almost be easier to switch to Julia (and get good performance from day 1) if you are coming from a language like C where you are used to thinking about allocations, in-place methods, and loops being fast.

Things are definitely stabilizing a bit post-1.0, but it's still a young language, so it'll take a while for documentation to fully catch up; in the meanwhile, the best option in my experience has been to lurk the various chat forums (slack/zulip/etc. [5]) and pick up best-practices from the folks on the cutting edge by osmosis.

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

[2] https://www.johnmyleswhite.com/notebook/2013/12/06/writing-t...

[3] https://docs.julialang.org/en/v1.5/manual/performance-tips/#...

[4] https://github.com/brenhinkeller/JuliaAdviceForMatlabProgram...

[5] https://julialang.org/community/#official_channels

[queuebert]

As an avid Rust and Julia user, I often use Rust even when it's harder because I know I'll never get stuck. And when it finally compiles I'll be rewarded by ludicrous speed.

Hell, even C has decent man pages for the standard library.

Although in Julia's defense (or is it?), they've changed the language a lot over the versions from 0.4 to 1.5, so maybe it's hard to keep docs up to date.

[adgjlsfhk1]

The language has been pretty stable (no breaking changes) since 1.0. The bigger issue is that unlike many of the other newer programming languages (Go, Rust, Swift etc) Julia doesn't have a fortune 500 company sponsoring it, so there aren't any people who's job is documentation. It's all open-source. Hopefully this is fixable through Google Summer of Docs and/or the community sponsoring people to work on this.

[queuebert]

What does Julia Computing do?

[cbkeller]

They do what they can, including things like [1] recently discussed here, but they're not exactly a Fortune-500 company yet.

[1] https://news.ycombinator.com/item?id=26425659

[markkitti]

The last time I talked to him he was trying to write his own discrete Fourier transform so he could avoid shifting around his matrix.

https://github.com/JuliaOptics/Fourier.jl

[roflmaostc]

Solution might be ShiftedArrays.jl which allows to do a circshift with a view. However, performance is slightly worse than an allocated fftshift.

We're currently working on wrappers doing that