As to (1), all the bugs Yuri filed seem to be fixed, save https://github.com/JuliaLang/julia/issues/39385, for which there is a largish PR that's still wending it's way to being merged.
All the bugs he listed as "filed by others" also seem to have been fixed, again save for one: https://github.com/JuliaLang/julia/issues/36069.
I'm not sure I understand what you're getting at with (2).
In Calculus with JuliaJuliaLang
julia
Julia2012–2026
JuliaLang / julia
julia
The Julia Programming Language
178Distinct people
335Mentions
5Explicit recommenders
49.3KGitHub stars
What to know before exploring
What it is
The Julia Programming Language
GitHub
Where it is used
What people are saying
There's another approach for doing this: generate a random number between 1 and 2 (they all have the same exponent) and then subtract 1 (that's the default implementation in…
FabHK used a recommendation phrase. 5 indexed comments match. This is a phrase match, not a verdict.
No classified warning is attached to this page. Read the discussions before treating silence as approval.
Also in these discussions
- juliastats/distributions.jl · linked in 3 of the same discussions
- juliastats/statsbase.jl · linked in 2 of the same discussions
Mentioned in the same Hacker News threads. That is not proof they are substitutes.
This week on Hacker News
Nov 7–Nov 14 UTC · Direct repository links and separately labeled related project stories. Indexed through 11/14/2026, 3:56:07 PM UTC.
No direct repository links were found in the indexed HN discussions over the past seven days. Older discussions are available below.
Mentions over time
HN mentions by year335 dated mentions
Observed mentions: 2012-02-18 12:55:37 UTC to 2026-10-12 16:48:37 UTC.
* An incomplete calendar period is marked with an outlined bar. Its count is not directly comparable with a full period.
Counts come from the repository’s dated source evidence. Index cutoff: 2026-11-02 08:16:59 UTC.
View mention counts and date ranges
| Period | Start (UTC) | End (exclusive, UTC) | Mentions | Submissions | Comments |
|---|---|---|---|---|---|
| 2012 | 2012-01-01 00:00:00 UTC | 2013-01-01 00:00:00 UTC | 12 | 1 | 11 |
| 2013 | 2013-01-01 00:00:00 UTC | 2014-01-01 00:00:00 UTC | 13 | 1 | 12 |
| 2014 | 2014-01-01 00:00:00 UTC | 2015-01-01 00:00:00 UTC | 42 | 7 | 35 |
| 2015 | 2015-01-01 00:00:00 UTC | 2016-01-01 00:00:00 UTC | 26 | 4 | 22 |
| 2016 | 2016-01-01 00:00:00 UTC | 2017-01-01 00:00:00 UTC | 26 | 4 | 22 |
| 2017 | 2017-01-01 00:00:00 UTC | 2018-01-01 00:00:00 UTC | 19 | 5 | 14 |
| 2018 | 2018-01-01 00:00:00 UTC | 2019-01-01 00:00:00 UTC | 29 | 5 | 24 |
| 2019 | 2019-01-01 00:00:00 UTC | 2020-01-01 00:00:00 UTC | 31 | 4 | 27 |
| 2020 | 2020-01-01 00:00:00 UTC | 2021-01-01 00:00:00 UTC | 22 | 3 | 19 |
| 2021 | 2021-01-01 00:00:00 UTC | 2022-01-01 00:00:00 UTC | 37 | 2 | 35 |
| 2022 | 2022-01-01 00:00:00 UTC | 2023-01-01 00:00:00 UTC | 38 | 1 | 37 |
| 2023 | 2023-01-01 00:00:00 UTC | 2024-01-01 00:00:00 UTC | 22 | 4 | 18 |
| 2024 | 2024-01-01 00:00:00 UTC | 2025-01-01 00:00:00 UTC | 8 | 0 | 8 |
| 2025 | 2025-01-01 00:00:00 UTC | 2026-01-01 00:00:00 UTC | 6 | 0 | 6 |
| 2026 (partial) | 2026-01-01 00:00:00 UTC | 2027-01-01 00:00:00 UTC | 4 | 1 | 3 |
From the project README
An excerpt from the repository, fetched Nov 12, 2026.
Read the project’s introduction
Documentation
Continuous integration
Code coverage
The Julia Language
Julia is a high-level, high-performance dynamic language for technical
computing. The main homepage for Julia can be found at
julialang.org. This is the GitHub
repository of Julia source code, including instructions for compiling
and installing Julia, below.
Resources
Homepage: https://julialang.org
Install: https://julialang.org/downloads/
Source code: https://github.com/JuliaLang/julia
Documentation: https://docs.julialang.org
Packages: https://julialang.org/packages/
Discussion forum: https://discourse.julialang.org
Zulip: https://julialang.zulipchat.com/
Slack: https://julialang.slack.com (get an invite from https://julialang.org/slack/)
YouTube: https://www.youtube.com/user/JuliaLanguage
Code coverage: https://coveralls.io/r/JuliaLang/julia
Contributing to Julia
We welcome contributions from developers of all experience levels, including bug fixes,
documentation improvements, tests, and performance enhancements.
New contributors are encouraged to start by reading CONTRIBUTING.md.
ImportantIf your pull request contains substantive contributions from a generative AI tool, please disclose so with details, and review all changes before opening. This also applies to other content, such as issues, discussions, and comments.
Learning Julia
Learning resources
Binary Installation
The recommended way of installing Julia is to use juliaup which will install
the latest stable julia for you and help keep it up to date. It can also let
you install and run different Julia versions simultaneously. Instructions for
this can be found here. If you want to manually
download specific Julia binaries, you can find those on the Manual Downloads
page. The downloads page also provides
details on the different tiers of
support for OS and
platform combinations.
If everything works correctly, you will get a julia program and when you run
it in a terminal or command prompt, you will see a Julia banner and an
interactive prompt into which you can enter expressions for evaluation. You can
read about getting
started in the
manual.
Note: Although some OS package managers provide Julia, such
installations are neither maintained nor endorsed by the Julia
project. They may be outdated, broken and/or unmaintained. We
recommend you use the official Julia binaries instead.
Building Julia
First, make sure you have all the required
dependencies installed.
Then, acquire the source code by cloning the git repository:
git clone https://github.com/JuliaLang/julia.git
and then use the command prompt to change into the resulting julia directory. By default, you will be building the latest unstable version of
Julia. However, most users should use the most recent stable version
of Julia. You can get this version by running: (replace [tag] with the desired tag)
git checkout [tag]
To build the julia executable, run make from within the julia directory.
Building Julia requires 2GiB of disk space and approximately 4GiB of virtual memory.
Note: The build process will fail badly if any of the build directory's parent directories have spaces or other shell meta-characters such as $ or : in their names (this is due to a limitation in GNU make).
Once it is built, you can run the julia executable. From within the julia directory, run
./julia
Your first test of Julia determines whether your build is working
properly. From the julia
directory, type make testall. You should see output that
lists a series of running tests; if they complete without error, you
should be in good shape to start using Julia.
You can read about getting
started
in the manual.
Detailed build instructions, should they be necessary,
are included in the build documentation.
Uninstalling Julia
By default, Julia does not install anything outside the directory it was cloned
into and ~/.julia. Julia and the vast majority of Julia packages can be
completely uninstalled by deleting these two directories.
Source Code Organization
The Julia source code is organized as follows:
Directory
Contents
base/
source code for the Base module (part of Julia's standard library)
cli/
source for the command line interface/REPL
contrib/
miscellaneous scripts
deps/
external dependencies
doc/src/
source for the user manual
etc/
contains startup.jl
src/
source for Julia language core
stdlib/
source code for other standard library packages
test/
test suites
Terminal, Editors and IDEs
The Julia REPL is quite powerful. See the section in the manual on
the Julia REPL
for more details.
On Windows, we highly recommend running Julia in a modern terminal,
such as Windows Terminal from the Microsoft Store.
Support for editing Julia is available for many
widely used editors:
Emacs,
Vim,
Sublime Text, and many
others.
For users who prefer IDEs, we recommend using VS Code with the
julia-vscode plugin.
For notebook users, Jupyter notebook support is available through the
IJulia package, and
the Pluto.jl package provides Pluto notebooks.
Read the full README on GitHubWhat Hacker News says
335 sourcesCorner cases like `prod([Int8(100), Int8(100)]) != prod((Int8(100), Int8(100)))`? Both returned integers, but the left was 10000 while the right was 16. [0]
Which, apparently, sat in the standard library for almost four years after it was introduced before it was fixed. [1]
Even if there was some merit to your argument, I would still find the attitude disqualifying. While it may be technically true that all programming languages have bugs, software and software communities for numerical computing should take responsibility and treat those bugs seriously, not downplay them by pointing to the fact that other software probably has bugs too.
FWIW I don't have a horse in this race. I've used both before, and I currently make money using neither. I liked Julia. I find that article concerning. And I find the attempts by Julia users to discredit
Read the rest
that article in this thread, without addressing its substance, even more concerning and disappointing.
Well, bugs can be fixed. But ideally not by a culture that dismisses them as inevitable or unimportant.
[0] https://github.com/JuliaLang/julia/issues/39183
[1] https://github.com/JuliaLang/julia/blob/26f2333686ce90331548...
I also just added these to Julia for 1.14 (https://github.com/JuliaLang/julia/pull/60311).
In C++ Details of Asymmetric FencesNot adding it until complete, but https://github.com/JuliaLang/julia/pull/60439 is the draft.
In Zmij: Faster floating point double-to-string conversionAlso Julia, https://github.com/JuliaLang/julia
And https://github.com/ZigEmbeddedGroup/microzig or e.g. https://github.com/haydenridd/silvia-pid-board
In Migrating the main Zig repository from GitHub to CodebergPlease note that the post didn't mention the word benchmark a single time ;) It does a "basic performance measurement" of "our csmith example". Anyway, thanks for your notes, they are very welcome and valid.
Comparing TPDE against the default optimization level in ORC is not fair (because that is -O2 indeed), but that's what we get off-the-shelf. I tested the explicit FastISel setting and it didn't help on the LLVM side, as you said. I didn't try the command-line option though, thanks for the tip! (Especially the -pass-remarks-missed will be useful.)
And yeah, csmith doesn't really generate representative code, but again that was not stated either. I didn't dive into JITLink as it would be a whole post on its own, but yes feature-completeness prevailed over performance here as well -- seems characteristic for LLVM and isn't soo surprising
Read the rest
:)
Last but not least, yes multi-threading isn't working as good as the post indicates. This seems related to the fix that JuliaLang did for the TaskDispatcher [1]. I will correct this in the post and see which other points can be addressed in the repo.
Looking forward for your OrcCompileLayer in TPDE!
[1] https://github.com/JuliaLang/julia/pull/58950
The incorrect example of julia's documentation was fixed 2021:
https://github.com/JuliaLang/julia/commit/f31ef767ef9cb0eb1d...
As an experiment, I would be interested to see if somebody would make a 1-based python list-like data structure (or a 0-based R array), to check how many 3rd party (or standard library) function would no longer work.
In Correctness and composability bugs in the Julia ecosystem (2022)There's another approach for doing this: generate a random number between 1 and 2 (they all have the same exponent) and then subtract 1 (that's the default implementation in Julia [0]).
But I think it also just gives you 2^53 different numbers.
So, between .5 and 1 you miss out on every second representable number, between 0.25 and .5 you miss out on 3/4 of them, and so on.
I guess for many cases that's good enough, but the article seems like a nice improvement.
ETA: Lemire has some thoughts on this [1] and links to what might be a prior solution [2]. Vigna (of xoroshiro fame) writes about it at the bottom of [3] and also links to [2]. So, presumably the implementation described in the article is faster? ("There have been some past attempts to fix these flaws, but none that avoid a huge performance penalty while doing so."
EDIT2: BTW, one
Read the rest
of the things I love about HN (well, the world, really) is that there are people that care deeply that we can uniformly sample floats between 0 and 1 correctly, and all of them, and do it faster.
[0] see https://github.com/JuliaLang/julia/blob/master/stdlib/Random...
rand(r::AbstractRNG, ::SamplerTrivial{CloseOpen01_64})
= rand(r, CloseOpen12()) - 1.0
[1] https://lemire.me/blog/2017/02/28/how-many-floating-point-nu...
[2] https://mumble.net/~campbell/2014/04/28/uniform-random-float
https://mumble.net/~campbell/2014/04/28/random_real.c
[3] https://prng.di.unimi.it
https://github.com/JuliaLang/julia/issues/57483 yes, yes it should.
In New horizons for JuliaIt also turns out that it allows for a bunch more compiler optimizations to be implimented with a lot less pain. I got very nerd sniped on this this week leading to https://github.com/JuliaLang/julia/pull/56030 and https://github.com/JuliaLang/julia/pull/55913 which allow allocation removal in a number of cases and saves ~4ns (~10ns->6ns for Memory{Int8}(unef, 4)) for constructing Memory objects.
In Julia 1.11 Highlights> 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/
In From Julia to Rust (2021)Julia's random number generator does this. See https://github.com/JuliaLang/julia/blob/94a0ee8637b66ab67445...
In Zero Tolerance for Bias> You clearly didn't understand the statement you are replying to.
You sure about that?
https://github.com/JuliaLang/julia/blob/af545b90c5657e0e210a...
In Calculus with JuliaJulia is not so different, implementation started in 2009 (I don't know how far before it was planned). Why is it new and Python 3 old?
https://github.com/JuliaLang/julia/commit/a9cbc036ac62dc5ba5...
In You probably don't need to validate UTF-8 stringsShowing the 15 most recent of 335 sources. Enable JavaScript to search and browse every indexed mention.