Those case studies are great. I wish Julia lang’s website had something similar.
In addition to the case studies, I like how JuliaHub describes the importance of Julia 1.9 with such great quotes.
I wish Julia lang’s website would publish a similar blog post for each Julia release explaining its impact on daily workflows.
By the way, could Julia lang become more popular by becoming a foundation under the Linux Foundation like Pytorch did last year?
My assumption is that the JuliaLang.org (the open source community) and JuliaHub (the commerical organization) are trying to maintain their separation.
Anyone can create their own case-study blog post about how they use Julia at their company for julialang.org… but (speaking from experience) it can be hard to get sign-offs and approvals from legal teams for them to use their company name.
At JuliaHub we’re always trying to get more case studies from the companies we work with — both speaking to the language and JuliaHub itself — and it’s hard work to make them happen. Commercial relationships can sometimes make this easier.
Think one huge problem is Julia attracts a grad school crowd. The developers of a lot of packages graduate and then get python jobs. Then they have no time to maintain these libraries and they atrophy. Maybe someone decides to build a new package for the same thing – to get it to work in the contemporary Julia ecosystem – and with this, the process begins anew
This fills the ecosystem with many useful packages with a bus factor of 1
Then if you add in the fact that many packages change their API dramatically year to year, you end up with a toolkit where your wrench might not work tomorrow and your screwdriver might be missing by christmas
It seems that some of those case studies don’t use JuliaHub services, so it might be possible to have them on the Julia lang website as well. For instance:
By the way, when I click on the JuliaHub logo in the right column, it goes to a 403 page.
Anyway, at least the Julia lang website could have the case studies of JuliaHub and the Julia Lab.
A few years ago, the Rust community began toying with the idea of a foundation, and one of the reasons for creating one was to clarify Rust’s status as an independent project.
Unfortunately, there is sometimes a lingering perception that Mozilla “owns” Rust, which can discourage companies from getting invested, or create the perception that there is no need to support Rust since Mozilla is footing the bill. Establishing a foundation will make official what has been true in practice for a long time: that Rust is an independent project.
http://smallcultfollowing.com/babysteps/blog/2020/01/09/towards-a-rust-foundation/
Besides that, I think there’s just a refusal to accept that the Julia ecosystem often fixates on the wrong things. The Julia community is perfectionist when it comes to design, but not when it comes to execution. In some cases, sloppy execution in the ecosystem can be put down to a lack of investment (e.g. the statistics or ML ecosystems). But in other cases, there’s been far more than enough investment.
Stan built a world-class autodiff system with a team of two people in about a year, and TinyGrad is now mostly usable after 2-3 years of work by one programmer. Why have 5 years of research, including several paid full-time engineers and PhDs, failed to do the same for Julia?
From what I can tell, the problem in these cases is Julia users have the mindset of mathematicians or academics, not software engineers. If a mathematician proves a theorem but forgets to exclude the trivial case x=0, they think of this as a minor error, because the idea is correct. On the other hand, adding unnecessary conditions to the theorem is a big problem. So is providing a proof that is far too long, or otherwise inelegant. In Julia, building an autodiff system that is less than fully general, or with a design that is theoretically “incorrect” (tracing rather than source-to-source), strikes most people as boring.
A programmer thinks of this as a major error because the users inevitably complain after they plug in x=0, or because a fuzzer catches it and blocks them from merging. Bugs are not acceptable, unlike missing features, or lack of generality. PyTorch and Jax have far more limitations than Zygote (or at least did, before PyTorch 2.0. But in return, they were reliable and fast 3 years ago, while we’re still struggling.
It’s very reminiscent of writings on why Lisp never caught on, e.g. worse is better. (Although I think by now, we’ve proven that correctness is just as important as implementation difficulty.)
7 posts were merged into an existing topic: What lessons could Julia’s autodiff ecosystem learn from Stan?
30 posts were split to a new topic: Should the Julia language slow down its release pace?
Better online documentation. Take a look at the php online documentation.
Let take a simple example, if you want to look up the floor function. If you google Julia floor.
you are sent to Mathematics · The Julia Language, and then you have to find the floor function near the end of that page. Which take time. If you instead google Php floor. You get to a page dedicated to the floor function. With examples, similar functions and user notes. One of the best part about the PHP documentation is the user notes, where the users can add examples, hint or advice in using the function. Have a look PHP: floor - Manual
Also, I think there is something wrong with google indexing of this site. I tried to google one of the old post titles, and it didn’t show up. Only when I used site:discourse.julialang.org did it show up. I think the webmaster need to log in to Google Search Central and provide some info.
This is kinda what does jlhub.
But if every function could have some basic examples, that would probably help new users a lot.
Also, jlhub lacks syntax highlighting.
Is this a fair description of Julia? Are people outside the Julia community well aware of the pros and cons of Julia?
Julia is faster than Python, more suitable to write large systems in it than R and less expensive than Matlab. So, speed, scalability and being open source make Julia an attractive alternative. On the other hand, Julia requires more programming skills than the other 3 languages mentioned
https://www.tiobe.com/tiobe-index/
Why would Julia require more programming skills?
To use Julia well requires understanding several computer science ideas that the average say “biologist who picked up some R while writing their masters thesis” wouldn’t have. Among these:
There’s probably some other stuff. I don’t think any of these are really super demanding, but if you took a semester course in R for bioinformatics (or R for seismometry or intro computational statistics with Python or whatever) and have no other computer science background you’ll struggle with some stuff… Like what the **** are all these @ symbols doing? and Why can’t I just ] add FooPackage why do people tell me to ] activate . first instead?
etc etc
What of that would "biologist/seismologist who picked up some R while writing their masters thesis” really need on their level?
My estimation:
Metaprogramming and macros (just the notion that @ is a special kind of function)
Macro hygiene
Various choices of numeric types and binary arithmetic implementations (R uses doubles almost everywhere) you can just as well use doubles everywhere in Julia
User defined structs and the type hierarchy, and using structs for algorithm choice (multiple dispatch)
Duck typing and multiple dispatch - well, they would probably need some minimal notion of that
Looping and iterators vs vectorization, - it is an option, and looping is basics of programming
Packages and Environments - well, it is not that difficult, but the workflow is different, which can be a challenge
And if we compare not to R or Matlab, but to Python - OOP ideas (which are basic to Python and especially to its extensions like numpy & co) are not that easy too.
For my part I have not the faintest clue what macro hygiene is. It’s a phrase I’ve heard, that’s it. I wonder what a poll even among Discourse regulars would reveal.
I don’t think macros should be on the list, but with the rest I agree, otherwise the user will stumble with very slow code without understanding why.
Would that slow Julia code be faster than the Python/R code?
I also think numeric types are doubtful. If you don’t think about it, you will get doubles in most contexts, or if you do, then your non-doubles will be promoted to doubles, one way or another.
Perhaps integer overflow, though.
You can certainly get by without defining your own structs.
in many many cases that wouldn’t really be a problem:
Sure, those are things important on the intermediate level, but probably not that important for a majority of beginners
Agree. For instance, this basic R for bioinformatics workshop only explains tidyverse.
Does anyone have experience teaching Julia to students with no computer science background? What are the challenges of teaching Julia in this case? Is it really more difficult to teach Julia than R?
Next @mbaumann thread split upcoming in 3, 2, 1… 