News for hackers. Stuff that matters.
Re:What's bad about Julia? by mountainriver on Monday July 26, 2021 @12:00PM (#27961065)
Great article, thanks for writing this, I’ve had a lot of frustration with the Julia community being unwilling to see faults in the language.

I really want to like Julia and I think I’m theory it has a lot to offer but due to much of what you listed I find it hard to develop in.

One thing I would add is that package management is also odd to me. It seems to have a lot of overhead and behave in unexpected ways.

In general I think Julia could learn a lot from Go. When I develop in Go most everything is simple. The type system is easy and just works, packaging is simple and usable, it compiles quickly. I fend writing the language seamless and productive.

Unfortunately Go also isn’t good for data science due to the memory model so Julia has a lot of room to step in there.

Re:What's bad about Julia? by ChrisRackauckas on Monday July 26, 2021 @01:13PM (#27962069)
>I’ve had a lot of frustration with the Julia community being unwilling to see faults in the language.

What? It's basically a meme at this point for major contributors to write a list of what they think is bad. The language's creator did a nice Youtube video "What's bad about Julia?" at JuliaCon 2019 (https://www.youtube.com/watch?v=TPuJsgyu87U), one of my most popular blog posts of all time is "7 Julia Gotchas and How To Handle Them" (https://www.stochasticlifestyle.com/7-julia-gotchas-handle/), etc. What the community pushes back about is things that are factually incorrect or just silly and repetitive, like the n+1th discussion about 1-based indexing. It's stuff below like, "I want to do an interactive workflow but not use the REPL, so it's not working well"... well the REPL is literally the interactive piece that caches the compilation so just use it if that's what you're trying to do? Yes, nobody has time for that nonsense, but everyone chimes in for real substantive discussions like changing the Base iterator API, programming patterns that would reduce recompilation, etc.

Re:What's bad about Julia? by jakobnissen on Monday July 26, 2021 @01:28PM (#27962293)
I don't think that's fair. Your blog post is not about what you think is bad - at least, it doesn't read like it. It reads like a list of stumbling blocks and how to get around them. This is not the same as listing the major problems with the language.

Jeff's talk is indeed great, but... it's not mostly about what he thinks is bad, either. That part is quickly swept aside with "just so you know we know". The talk is really about some very specific problems in the type system that are so obscure that I don't even consider them worth mentioning in a blogpost about Julia's weaknesses.

Re:What's bad about Julia? by ChrisRackauckas on Monday July 26, 2021 @01:49PM (#27962599)
>It reads like a list of stumbling blocks and how to get around them. This is not the same as listing the major problems with the language.

I mean, if by stumbling blocks you mean all of the things I thought was bad and all of the work arounds you have to know to get work done? I think the difference is that normally when I gripe I like to then elucidate why the bad things exist. To me that's more productive because digging into "why is it like that" starts to point towards "how do you fix it". But yes, giving the full detailed backstory behind what leads to the gripe naturally softens the blow because the reader then understands its purpose, but that's just reality. Very few things are truly and purely awful when you really see the full reason for them. Usually it's just an engineering trade-off.

Re:What's bad about Julia? by Certhas on Monday July 26, 2021 @02:50PM (#27963573)
Any language has stumbling blocks. That's _really_ different from fundamental issues with the language. There is no working around most of the issues mentioned here.

I think a million and one posts on 1-based indexing and "why no OOP" or some perceived weakness of the modules system and other silly things like that have led to a base defensive attitude.

But this post is criticism from someone actively using the language, well thought out, and things that you can not work around. It includes real currently unresolvable pain points.

And it doesn't sound like the Julia lang team has a plan for how to address them. Or it's not communicating that plan. After all, the talk you link by Jeff Bezanson name checks many of the issues raised here two years ago, to then continue to not talk about them ever again.

Re:What's bad about Julia? by mountainriver on Monday July 26, 2021 @02:24PM (#27963165)
This feels like classic feedback from the Julia community. It really stifles any hope I have of the language recovering. I know there are reasons behind things, but they also seem blind to fixing the obvious stuff because of them
Re:What's bad about Julia? by jakobnissen on Monday July 26, 2021 @02:33PM (#27963325)
And yet, would you not agree that the most important pain points do improve over time? Most of the things I mention in the post: Latency, stability, ecosystem maturity, static analysis and the IDE experience is notably better now than just 1 year ago.
Re:What's bad about Julia? by neolog on Monday July 26, 2021 @02:44PM (#27963487)
Yes "user experience" things like that are improving. And StaticCompiler/GPUCompiler is making good progress.

But I see no movement on the deeper problems, like the limitations of the type system (no effort on traits, function types, interfaces, etc).

Re:What's bad about Julia? by BadInformatics on Monday July 26, 2021 @04:37PM (#27965120)
I agree progress on the deeper problems is slow, and I also think that it is slow because 90%+ of the issues people have with Julia are "user experience" things (see any of the help forums as well as all of the previous HN discussions). Given a limited amount of resources, it's difficult to justify a deep dive into revamping the type system (AIUI multiple dispatch with complex types + traits is mostly unexplored territory) over improving latency and tooling. That's not to say it shouldn't be done, but in the absence of some significant (financial and development) support behind it I don't think the type system work will be prioritized.
Re:What's bad about Julia? by neolog on Monday July 26, 2021 @02:34PM (#27963348)
(No response needed, just something to consider.)

In any large system, there are many problems that could have technical solutions but they're missed for one reason or another. Design mistakes occur from time to time and we can choose how we respond when they do. I want experts from other communities to join us, and they need to see that Julia will take their feedback seriously. With all due respect to your major contributions, I think we'll be better off if people in leadership roles take a more critical view of Julia, especially in public.

Re:What's bad about Julia? by neolog on Monday July 26, 2021 @01:31PM (#27962335)
Yeah. Mike's "Iterate on it" [1] is a real "what's bad" post, as is OP's.

[1] https://mikeinnes.github.io/2020/06/04/iterate.html

Re:What's bad about Julia? by enriquto on Monday July 26, 2021 @04:34PM (#27965087)
>> I’ve had a lot of frustration with the Julia community being unwilling to see faults in the language.

> well the REPL is literally the interactive piece that caches the compilation so just use it if that's what you're trying to do?

This answer may be exactly the kind of hostility that the GP is talking about.

People may have legitimate reasons for not using the REPL. Instead of adressing these reasons you dismiss them. A textbook case of "holding it wrong".

Re:What's bad about Julia? by StefanKarpinski on Monday July 26, 2021 @05:43PM (#27965870)
The thing is no one is saying that starting a process every time isn't a valid way to work — it works great in most scripting languages. What people are saying is that since it's slow and annoying in Julia currently, you might want to consider a REPL-based workflow with Revise. If the response to that is "But I don't wanna use the REPL!!" then what can one do? Ok, don't use the REPL. But as everyone has agreed, it's going to be a bit annoying. If that's a dealbreaker for you then you may not want to use Julia just yet — which is totally ok!

That interaction unfortunately seems to often get characterized as "The Julia devs don't care about startup time! They insist on REPL-driven development and refuse to work on it." Never mind that improving startup time and package loading has been the number one priority of the compiler team since Julia 1.0 and that it's gotten about 10x faster. There's also ongoing work to make it even faster using system images.

Re:What's bad about Julia? by amkkma on Monday July 26, 2021 @05:55PM (#27965982)
Sounds like expanding this into a blog post would be helpful
Re:What's bad about Julia? by systemvoltage on Monday July 26, 2021 @12:13PM (#27961238)
As someone who has used Julia for production use, I basically agree with everything you've said.

IMO:

1) Julia rushed to v1.0, but its understandable - it is sort of a catch-22 issue. More developers won't join unless it is stable (v1.0). But it won't get stable unless a lot of developers use it and feedback is heard.

2) I personally found that Julia community is slightly hostile to feedback and negativity. May be it is just me but it has way too much hype-driven-positivity that leads to delusion.

3) A lot happened between v0.2 to v1.0 which IMO should have been carefully and slowly done.

4) Developer experience should have been one of the major focuses. Stack traces should be beautiful and absolutely transparent. Debuggers are clunky - I used the Atom (Juno) debugger and wanted to toss the laptop off the window - just shows how frustrating it was. Compile times and smoothness of dev experience pays dividends and it was largely ignored.

5) I really like official libraries, not SomeBasicFunctionality.jl dependency. I am spoiled by Python.

6) Marketing around speed is misplaced IMO. It lures people like me into fanboys of Julia. There is so much more to a programming language than speed.

I don't want to be overly negative. The language and the original paper is beautiful - and this is all hard stuff. Kudos for the progress made so far.

Re:What's bad about Julia? by pdeffebach on Monday July 26, 2021 @02:06PM (#27962867)
> 2) I personally found that Julia community is slightly hostile to feedback and negativity. May be it is just me but it has way too much hype-driven-positivity that leads to delusion.

I want to push back on this a bit, which I acknowledge is very ironic. In the past few years people consistently post on Discourse asking for fundamental changes to the language to make it more resemble python, C++, or whatever their preferred language is.

People often say Go is great because there is "only one way of doing things", yet people are very resistant to being told "the way" to do something in Julia. This has happened enough that it's prompted a pinned PSA on discourse: https://discourse.julialang.org/t/psa-julia-is-not-at-that-s...

It gets tiring! And i'm not sure how the community should handle these requests, but I don't think it's fair to blame all of the negativity on the Julia community when these somewhat misinformed, or even bad-faith posts are so frequent.

Re:What's bad about Julia? by chestertn on Monday July 26, 2021 @12:30PM (#27961470)
Completely agree with 4 and 5. I use Julia regularly and while it is great for scripts and proof of concepts of mathematical stuff it might be too complicated to implement in Python or in C++ once one starts to grow an application it is tremendously frustrating.

I have clear and satisfying workflows in C (vim + make + gdb + valgrind) and Python (vim/vs code, pdb) but I cannot say that debugging and tracing errors is a comfortable experience in Julia. Essential development tools are relegated to third-party libraries (e.g. Revise.jl and Debugger.jl) and are often clunky or responsiveness is limited (e.g. Revise.jl won't work when you change a struct)

I believe the problem is that, because of Julia is marketed towards scientific computing and HPC, it draws mostly from an academic user base which is not that interested in software development.

Re:What's bad about Julia? by huijzer on Monday July 26, 2021 @02:33PM (#27963331)
> I believe the problem is that, because of Julia is marketed towards scientific computing and HPC, it draws mostly from an academic user base which is not that interested in software development.

Although you have a point regarding Revise and Debugger, the last paragraph makes no sense at all. As a counterexample, Haskell drew mostly from an academic user base and many Haskell idioms have ended up in other real world *production* languages like Python (e.g. map, filter, reduce).

Re:What's bad about Julia? by chestertn on Monday July 26, 2021 @02:56PM (#27963665)
> It does not make sense at all.

Please, I am open to see why you think so.

> As a counterexample, Haskell drew mostly from an academic user base

May I infer from this statement that you agree with me that Julia draws mostly from an academic user base? In that case, I do not see how your counterexample invalidates what I said. Perhaps some constructs from Julia end up in "real world production languages" but what I said is that the development experience in Julia is subpar and it shows when one is trying to develop larger codebases where software engineering practices become more important.

Re:What's bad about Julia? by thebooktocome on Monday July 26, 2021 @12:32PM (#27961506)
> I personally found that Julia community is slightly hostile to feedback and negativity. May be it is just me but it has way too much hype-driven-positivity that leads to delusion.

Part of the problem, at least from what I observed here and in other dev communities, was that Julia had a large number of bad faith critics (probably larger than the number of active users, at the time) from about 0.2 to 0.5 or so. I'm talking about everyone who compared the runtime of hello world in the REPL, with start up time, to that of a compiled executable. There were piles and piles of fake benchmarks that did little more than compare BLAS bindings as though the differences were intrinsic to the language.

Sure, the Julia community could have reacted better to such (and a few people did: BenchmarkTools.jl was an early win in this area), but few people do react that way in practice.

Re:What's bad about Julia? by jakobnissen on Monday July 26, 2021 @12:41PM (#27961619)
Yeah, that might be true. I've read very poor criticisms of Julia other places on the Internet. Most famously perhaps the "giving up on Julia" blog. In fact, the lack of good criticism was what prompted me to write this post.
Re:What's bad about Julia? by thebooktocome on Monday July 26, 2021 @12:42PM (#27961639)
I probably should have added that I certainly find your post to be good criticism.
Re:What's bad about Julia? by igouy on Monday July 26, 2021 @05:59PM (#27966014)
Re:What's bad about Julia? by neolog on Monday July 26, 2021 @01:50PM (#27962610)
Agree with all of this except

> 5) I really like official libraries, not SomeBasicFunctionality.jl dependency. I am spoiled by Python.

Python's standard library is full of bad code that nobody has time to improve [1]. Over time, Julia packages will surpass the standard library too but we'll still be hauling it around and spending core-dev time on it for for backward-compatibility reasons. We should have a much much smaller standard library.

[1] https://pyfound.blogspot.com/2019/05/amber-brown-batteries-i...

Re:What's bad about Julia? by systemvoltage on Monday July 26, 2021 @05:34PM (#27965787)
I think the only difference is whether something is officially supported or not. When it is officially supported, it tends to not break and has to run through a bunch of tests that ensure that std lib doesn't break with every programming language release. It tightly couples them. With off the shelf libraries, there is always a delay.

I also have an ideological take - I think of programming languages as a tool box and like a car mechanic, you want to have dependable tools that are robust, don't break and has good support. Basic algorithms and datastructures should always be included in the programming language - this is subjective but I firmly believe in it.

Re:What's bad about Julia? by BadInformatics on Monday July 26, 2021 @01:17PM (#27962120)
Others have commented on stacktraces, so I wanted to mention that the debugging experience in VS Code (the replacement for Atom-based Juno) is much improved as of the past couple of months. Worth a revisit if you're using it already.

Regarding stdlib support, I feel like it's a toss-up. For numeric and data processing code, Julia has a much richer stdlib whereas I need at least Numpy in Python (and even then, working with anything not array-shaped is a pain). For more systems-y stuff though, Python has a much fuller stdlib (e.g. reading/writing a bunch of archive formats). The end result for me is that scripting with Julia feels high friction, and doing anything which requires any kind of throughput with Python feels like pulling teeth.

Re:What's bad about Julia? by amkkma on Monday July 26, 2021 @12:33PM (#27961512)
Point 4 is going to get explicit dev time after the initial stages of the new general purpose compiler plugin infra is completed.

Then, proper debugging and introspection tools will be easier to build.

Re:What's bad about Julia? by oscardssmith on Monday July 26, 2021 @12:15PM (#27961279)
Note that stack traces are a bunch better in 1.7 (not yet perfect though).
Re:What's bad about Julia? by ChrisRackauckas on Monday July 26, 2021 @01:30PM (#27962320)
I like that they are colored now, but really what needs to be added is type parameter collapasing. In most cases, you want to see `::Dual{...}`, i.e. "it's a dual number", not `::Dual{typeof(ODESolution{sfjeoisjfsfsjslikj},sfsef,sefs}` (these can literally get to 3000 characters long). As an example of this, see the stacktraces in something like https://github.com/SciML/DiffEqOperators.jl/issues/419 . The thing is that it gives back more type information than the strictest dispatch: no function is dispatching off of that first 3000 character type parameter, so you know that printing that chunk of information is actually not informative to any method decisions. Automated type abbreviations could take that heuristic and chop out a lot of the cruft.
Re:What's bad about Julia? by gugagore on Monday July 26, 2021 @01:48PM (#27962589)
this would be beneficial not just for stacktraces but for printing values, too.
Re:What's bad about Julia? by mountainriver on Monday July 26, 2021 @12:28PM (#27961446)
Well said, point 4 really resonates with me, they seem to want to be different over just using things that work well
Re:What's bad about Julia? by bachmeier on Monday July 26, 2021 @02:02PM (#27962813)
> I’ve had a lot of frustration with the Julia community being unwilling to see faults in the language.

A related thing that really turned me off in the early days was one of the main developers constantly criticizing other languages. That wouldn't be so bad by itself, but much of it was uninformed, and it told me at least one of the core devs was not going to learn from other languages. There was always an attitude that "I know what to do, unlike everyone else".

The reason I never moved heavily into Julia was that it was too easy to write slow code (back then, things may have changed) relative to compiled languages like Fortran. Maybe I'd have stuck with it longer if I found the community to be pleasant, but an unstable and often slow language plus an unpleasant core developer was more than I was willing to put up with.

Re:What's bad about Julia? by mirekrusin on Monday July 26, 2021 @02:34PM (#27963336)
Opposite experience here, it was crazy to me how fast I could prototype my number crunching on price series, how trivial it was to distribute it across multiple machines in my house and finally how easy it was to flip to gpu computation. On every step I was surprised how fast it was.

Community is great, met only kind people, exceptionally knowledgable bunch.

Re:What's bad about Julia? by neolog on Monday July 26, 2021 @02:59PM (#27963707)
A couple of very vocal individuals have an attitude, which reflects badly. But the community is getting bigger, so it's becoming less of an issue as most interactions don't include those people.

It's still easy to write slow code. But writing fast code is often easier than it would be in C++ or whatever.

Come try again if you like.

Re:What's bad about Julia? by StefanKarpinski on Monday July 26, 2021 @04:18PM (#27964879)
The announcement post for Julia was literally about all the things we love in other languages:

https://julialang.org/blog/2012/02/why-we-created-julia/

Re:What's bad about Julia? by neolog on Monday July 26, 2021 @04:33PM (#27965079)
There is a certain set of languages that the Julia team is experts in. But the world of languages is very diverse and big parts of it are lacking representation, so we miss out on their insights. Eg I think most core devs are experts in C, C++, Matlab, Python, but not as many experts in Haskell, OCaml, Rust, Racket, Common Lisp, Clojure.

I'd like to find ways of attracting those other experts into our community, and making sure we use their insights whenever we can.

Re:What's bad about Julia? by StefanKarpinski on Monday July 26, 2021 @04:47PM (#27965235)
Always good to attract experts from other languages. I was mainly addressing the claim that Julia core devs like to crap on other languages, not trying to claim that we're experts in every language — obviously we're not. But saying that we're uninterested in other languages or unwilling to learn from them is simply untrue — we're a bunch of huge programming language nerds and we love programming languages, even some of the notoriously flawed ones like C++, Matlab and Perl.
Re:What's bad about Julia? by leephillips on Monday July 26, 2021 @05:42PM (#27965857)
It’s easy to write slow code in any language. I wrote some slow Fortran before I learned how not to. Generally you need to know a good amount about not only the language, but about the machine you’re targeting, to write really efficient code.
Re:What's bad about Julia? by ummonk on Monday July 26, 2021 @02:30PM (#27963268)
I don't think Julia is trying to be anything like Go and it shouldn't be.

Probably Julia's best feature is the powerful metaprogramming support that allows you to, e.g., create array packages that automatically run code on GPU. You can't have such features with a simple language.

Re:What's bad about Julia? by mountainriver on Monday July 26, 2021 @05:01PM (#27965418)
That doesn’t mean it can’t learn from it. Yeah they are solving somewhat different problems but in sheer usability of a language Julia could take a lot from Go.
Re:What's bad about Julia? by d110af5ccf on Monday July 26, 2021 @09:26PM (#27967571)
> powerful metaprogramming support ... can't have such features with a simple language

Various Scheme implementations are among the simplest languages I've ever used yet possesses some of the most powerful metaprogramming I know of. Perhaps I misunderstood you somehow?

Re:What's bad about Julia? by ummonk on Tuesday July 27, 2021 @03:54PM (#27976815)
Have you used Go? It exhibits a very different kind of simplicity than e.g. Scheme implementations.
Re:What's bad about Julia? by arkitaip on Monday July 26, 2021 @12:02PM (#27961106)
> I’ve had a lot of frustration with the Julia community being unwilling to see faults in the language.

How about just moving on? It's not like there is a lack of languages and tools out there.

Re:What's bad about Julia? by jakobnissen on Monday July 26, 2021 @12:05PM (#27961142)
All languages have problems. Don't take my post to mean "don't use Julia" - the very first words of the post is that it's my favorite language. Also do note that the webpage is built with Julia. Not a coincidence.

But even good systems need critique, otherwise there can be no improvement or growth.

Re:What's bad about Julia? by dochtman on Monday July 26, 2021 @01:58PM (#27962751)
Your praise for Rust combined with the list of Julia problems left me curious what you find redeems Julia even though it has all these problems.
Re:What's bad about Julia? by jakobnissen on Monday July 26, 2021 @02:45PM (#27963512)
Yeah, I guess only seeing one side of the argument can be a bit misleading...

It would probably take another 1,000 word blogpost to go through why Julia is amazing, despite all these problems. I'm sure I will make that post someday.

While I do like Rust, the basic design of Julia and Rust are just very different. They're intended to solve different problems, and the problems I have are the problems Julia is designed to solve. The love comes from just how well it solves those problems compared to every other programming language out there.

Compared to Rust specifically, Rust is a complete nonstarter for interactive coding, since there isn't a REPL. Even if there was, it's way too complicated to use interactively - a garbage collector would be a must, and a lot of these compile time checks that I praise would be a major pain in the ass when coding casually. It's also way too slow to write: Even after having written Rust for a few months, I estimate I can solve a problem using Julia 4 times faster than using Rust, using maybe 2/3 the number of lines, or less.

Re:What's bad about Julia? by mountainriver on Monday July 26, 2021 @02:26PM (#27963214)
Rust is too low level for most data scientists, the borrow checker interrupts the flow of thought and it doesn’t work well in notebooks.
Re:What's bad about Julia? by sitkack on Monday July 26, 2021 @12:09PM (#27961186)
> How about just moving on?

Things can have faults and be worth investing in, it doesn't need to be an all or nothing false dilemma. Nothing would get fixed if we all just self selected in this way.

Re:What's bad about Julia? by mountainriver on Monday July 26, 2021 @12:26PM (#27961431)
To do data science there kinda is; it’s python, Julia, R, c++ or a bunch of not well supported languages

Nowadays I’m doing my ML in rust which has been pretty nice, but the borrow checker does bite you a bit and there’s not much of a community.

Julia seems really promising, the community just gets their head in the sand a bit

Re:What's bad about Julia? by jefft255 on Monday July 26, 2021 @12:42PM (#27961643)
I think you just made OP's point.
Re:What's bad about Julia? by eigenspace on Monday July 26, 2021 @01:29PM (#27962306)
That was explicitly not the OPs point. His point was that there are warts on every tool and he wanted to clearly bring them up in a way that is productive and helpful.

He says julia is his favourite language in the very first sentence.

Re:What's bad about Julia? by neolog on Monday July 26, 2021 @01:33PM (#27962371)
jefft meant GP, not OP. When people complain about julia, they often get "maybe julia isn't for your use case" instead of "good point, we should fix that".
Re:What's bad about Julia? by jefft255 on Monday July 26, 2021 @04:17PM (#27964866)
Exactly; sorry for the confusion