Yuri Vishnevsky

I don't think Julia really solves any problems that aren't already solved by Python. Python is sometimes slower (hot loops), but for that you have Numba. And if something is truly performance critical, it should be written or rewritten in C++ anyway. But Julia also introduces new problems, such as JIT warmup (so it's not really suitable for scripting) and is still not considered trustworthy: https://yuri.is/not-julia/

I'm working on a little website to summarize discussion trends across the podcast ecosystem. I wrote about an early prototype here[1] and also gave a presentation about it a few months ago[2] and now I'm working on an expanded "daily pulse" view across hundreds of episodes of top news podcasts from the last few days. My secret agenda is to explore how the "information supply chain" can be tracked across the data-processing stack all the way from the original audio through transcription, the processing pipeline, and UI. I'm using language models for multi-stage summarization and want to be able to follow the provenance of summaries all the way back to the transcripts and original audio. [1] https://yuri.is/n/podcast-vibes-prototyping/ [2] https://yuri.is/n/podcast-vibes-presentation/

https://yuri.is/not-julia/ is a good write-up of one person's opinion on the problems of Julia. I'm much less experienced with Julia but I somewhat agree. There's too much focus on "magic" instead of correctness for me to try building serious software using Julia. An amazing language in many aspects though.

You can read this excellent piece [0] written from experience. Julia is still far from ready for serious adoptation for heavy workflows. For libraries, the optimization cannot be trusted. And it cannot be said many times that best practices were followed. While you can trust NumPy or PyTorch, you cannot trust a Julia library at the same level. [0]: https://yuri.is/not-julia/

A few months back this article[0] was posted here (Why I no longer recommend Julia). Does anyone following the Julia community know if the situation is getting better? [0] https://yuri.is/not-julia/

Has there been any response to "Why I no longer recommend Julia" [1]. It has made me hesitate to dive into this language. [1] https://yuri.is/not-julia/

How a lib where you don't even know whether it computes correct results can be called "best"? Only because something spits out numbers really fast doesn't say anything about the quality of this something. Especially when considering that optimizing for speed comes most times with very hacky code! This, plus the fact that this code is usually written by laymen (scientist aren't software engineers!) makes such things very questionable. After looking into scientific computing and the usual software "quality" there I lost quite some trust in anything that comes out of there. This was actually very disillusionary and extremely sad to find out. This could even destroy the broader trust in science in general (as everything today in this field depends on statistics calculated by computers). This would be an catastrophic outcome! But most people would currently even deny the existence of an issue… Related (together with the parent): https://news.ycombinator.com/item?id=34224186 Also related as people (scientists!) got blinded by the promise of speed without considering correctness: https://yuri.is/not-julia/ A house of cards… :-(

I'm happy to admit mistakes (and correct them!) but this is inaccurate. We don't edit titles to put our own personal spin on a topic, which is what the word editorializing means. We look closely at the article itself to find what it is actually saying. If we do replace a title, we replace it with representative language from the article itself wherever possible. This has been the case for a long time: https://hn.algolia.com/?dateRange=all&page=0&prefix=true&q… That does involve some interpretive judgment—because why pick one phrase rather than another—but less than you might think, because nearly every article has a point where the author says what they're actually writing about. We never do this to convey an opinion of our own. We don't much care what people think or what an article says. We care whether the title accurately represents what the article is saying, and does so in a way that isn't baity, because that is the biggest influence on discussion quality. The submission you guys are bringing up (https://news.ycombinator.com/item?id=31396861) illustrates the point. "Why I no longer recommend Julia" is a baity title, because it doesn't say anything specific about why. It's just a pointer that says "I boo Julia". "Boo $language" is for sure flamebait on this site. Such titles generate threads that are just generic boo-vs.-yay ventings between people who like $thing and people who don't. The substantive…

https://yuri.is/not-julia/ > My conclusion after using Julia for many years is that there are too many correctness and composability bugs throughout the ecosystem to justify using it in just about any context where correctness matters.

IMO it just had too many rough edges. Very slow compilation, correctness issues (https://yuri.is/not-julia/), kinda janky tooling (not nearly as bad as pip tbf). Even basic language mistakes like implicit variable declaration and 1-based indexing (in 2012??). Yes 1-based indexing is a mistake. It leads to significantly less elegant code - especially for generic code - and is no harder to understand than 1-based indexing for people capable of programming. Fight me.

Deeply ironic for a Julia proponent to smear a popular language as "fundamentally broken" without evidence. https://yuri.is/not-julia/

the "technical note" link in the RLE bit vector section of the rust repo is broken (https://yuri.is/pdfing/weighted_range_quantile_queries.pdf 404s)

I am curious, have you run into any of the issues with Julia discussed here [0] (also discussed on HN [1])? Those problems would seem particularly troubling at a hedge fund to me, if you have to question the accuracy of your results after chaining multiple complex models together. Curious about your stance on / experience with correctness issues in Julia. [0] https://yuri.is/not-julia/ [1] https://news.ycombinator.com/item?id=31396861

> are not an issue with Julia (eg memory safety) Note that Julia does allow memory unsafety, for example you can mark array accesses with `@inbounds` to remove bound checks, kinda like how you can use `unsafe` in Rust except it looks much less scary. It also doesn't help that the official example for how to use it safe was actually not safe [1]. Granted, this is just a single example and has been fixed since then, but it doesn't give a nice impression of their mindset when dealing with memory safety. More in general there doesn't seem to be a strong mindset for correctness either. See [2] for a collection of such issues. [1]: https://github.com/JuliaLang/julia/issues/39367 [2]: https://yuri.is/not-julia/

https://yuri.is/not-julia/ HN discussion: https://news.ycombinator.com/item?id=31396861

well, after https://yuri.is/not-julia/, the above is a very valid statement.

I was initially quite keen on Julia but this critique rather put me off: https://yuri.is/not-julia/ and I've not seen a rebuttal.

Except for the fact that your Julia code will always suffer from correctness problems, something that would rarely if ever happen in Fortran. https://yuri.is/not-julia/

As someone who has used and contributed to Julia, I find Yuri Vishnevsky's arguments about correctness totally fatal [0]. I do mostly scientific computing. The idea that I might have to retract a paper because of a bug in the programming language is intolerable. And Yuri's examples are not obscure, they are totally realistic scenarios where Julia silently returns wrong results in ways that may be hard to detect. It doesn't matter how beautiful and fun to write and develop the language is if it can't be trusted to return correct results. [0] https://yuri.is/not-julia/

I bring up DifferentialEquations.jl specifically because it is supposed to be one of the flagship julia packages. When I paste their examples into my repl and get errors or infs where I should get well behaved values, that's their problem, especially when I have the exact version installed that the docs claim to be generated from. I'm not the only one with a similar take that julia has quality control issues, e.g. https://yuri.is/not-julia/

You are demanding a lot from the type system. Search for OffsetArrays in https://yuri.is/not-julia/ for practical problems encountered in trying to make this feature work in a language whose compiler does try to be smart.

That’s completely valid. I do the bulk of my work in my current internship in Machine Learning & Data Science codebases and there is no other language which has anything close to the ecosystem of libraries/tooling that Python has in this domain while also being a suitable general purpose programming language. I don’t have much experience with Matlab/Mathematica but I hear Matlab is decent for Machine Learning - but I don’t want to have vendor lock-in. That leaves me with C++ or Julia. C++ is not the most ergonomic language and adding manual memory management isn’t an ideal. Julia looked promising and I have heavily considered taking a deep dive, but ended up being deterred [0] - I feel like these are pretty major problems to exist for a language of this point in maturity. [0] https://yuri.is/not-julia/

Yeah, I agree, and I like C! I think the lack of bounds checks where they are not a problem is a massive design flaw nowadays. Zig should have made bounds checks universal and spent effort on compiler passes to elide them. Allowing people to remove bounds checks is not smart (though Rust's unsafe is a good compromise), especially in such a coarse way as a build option. In fact, a supposedly memory-safe language, Julia, has memory bugs because it allows users to turn bounds checks off. [1] This should never have happened. [1]: https://yuri.is/not-julia/

So this is now fixed: https://yuri.is/not-julia/ ?

Here is a blog post that was making the rounds recently. https://yuri.is/not-julia/ It has many concrete examples of low quality and buggy code making it into pretty core statistics libraries. Most of these bugs are a combination of 'sloppy' coding and lack of vigorous testing of all the corner cases that the language has. Many developers seem to take a more 'academic' approach to things (it works correctly in all the cases I care about) rather than caring about creating robust libraries that are rock solid under all conditions. From the blog: "My conclusion after using Julia for many years is that there are too many correctness and composability bugs throughout the ecosystem to justify using it in just about any context where correctness matters." The good news is that this blog post seems to have brought some light to this problem and hopefully the Julia community can start addressing it.

1. What's your own probability estimate that you'll be back to Lisp by, say, 2024? 2. Can you elaborate more on "they are very awkward to work with and only offer a subset of the abilities of the Emacs plugin" for vim? What did you find lacking about either slimv or vlime that you absolutely couldn't stand such that you forced yourself to use emacs? I'm most familiar with slimv and am aware of some quirks (and one bad still-open issue related to errors in threads which is annoying to deal with when it bites) and some limitations, but I'm fortunate to be mostly unbothered by them or in one case so far submitting a patch to fix one annoyance. At least, I'm not bothered to the level of abandoning vim -- I'll probably try the VS Code plugin before trying emacs again, or shell out for a LW license. Specifically it's things I see emacs users do like clicking a printed object's memory address to open the thing in the inspector, or having a slightly less ghetto code stepper. I'd rather have other things I miss from my Java life that as far as I know aren't even in emacs for CL. 3. Did you seek out any downer takes when evaluating Julia? What did you think of any of them? Some specific examples include https://yuri.is/not-julia/ or http://danluu.com/julialang/ where Yuri's post is linked at the bottom as a sort of update. If you read anything like that, have you been concerned? Any good "excuse" articles you found that address any downer points? Anyway, thanks for your work in…

I was an economist doing econometrics in excel when in 2014 the datasets went being a few 10,000's rows to a few 1,000,000's rows. I found R easiest to learn as a CS outsider because it was less strict about package versions and installation requirements, which made it easier for a beginner to setup and get going. I learned it by googling every little step ('how read in csv', 'how create new column in data.frame' etc) until I had a ~40 line R script that did what I was previously doing by hand in excel. It ran in a few seconds and did what took excel about 10 minutes. A few years later I wrote an open source economics library in R: https://github.com/stevecondylios/priceR#pricer- It converts between nominal and real prices, converts between 171 currencies, and has a few regex's for pulling numeric data out of text (e.g. salaries out of job descriptions). Some specific observations regarding the article: - Comparing computation speed seems a bizarre metric to care about. 6x faster matters on things that take minutes, hours or days, but less so for operations that already run in under 1000ms. Developer experience is usually more important IME. - The article mentions R library support is superior (which may or may not be true), but it would nice to see the most useful highly-regarded libraries from each language reviewed, or at least mentioned. - The statement "(Julia) does not have any historical baggage" seems odd since a language doesn't need to be old before people…