We had an excellent discussion on Slack the other day where many people gave input to what they considered the “biggest things missing in Julia”. I thought it would be a shame if all the feedback just disappeared into the Slack memory hole. So here, I’m copy-pasting some answers from that thread. Please do respond with your own!
Note that this pertains to missing features that could plausibly be implemented, not existing bad design decisions. The top point from many people (including myself) was “Lack of third party packages”, but that’s hardly useful from a Julia dev perspective, so I’ve not included it here.
Static analysis tools
Interfaces:
Scott Paul Jones:
[We need] a way of explicitly indicating names which are meant to be public even if they are not exported. Many times you don’t want to pollute the namespace when people do using, but then the ecosystem becomes fragile when things aren’t exported, since there’s no consistent way of discovering whether something is part of the module / package API or not otherwise.
Jakob Nissen:
There is currently no way of knowing how to implement a subtype of e.g. Number, Char or AbstractDict. Our current system of subtyping has us rely on comprehensive, up-to-date documentation on abstract types to know what methods to implement, but this is unrealistic: Even in Base, most abstract types are not documented.
Static compilation
Michael Savastio:
Making it easy to produce a self-contained, reasonably sized binary executable is probably still the biggest limitation of the language […] being easy to get reasonable static binaries would greatly expand the number of reasonable use cases for the language, so I see that as being a necessity for going much beyond a numerical and scientific computing focused bunch
Compile time latency:
Ari Huttunen:
For me the biggest pain point has been the constant precompiling when I run notebooks, as I often re-start the kernel.
Jakob Nissen:
A multithreaded compiler would be nice
Documentation:
Ari Huttunen:
The second [biggest pain point] is quality of documentation and/or examples
James Doss-Gollin:
Documentation is general problem. There are lots of stable packages that other developers rely on that only have a GitHub README for documentation
Data types:
Scott Paul Jones:
[We should] be able to have a type that is a union between several pointer / bits types, that can be determined by the lower bits (this is a frequent low-level trick, even used by Julia itself internally).
[We need] “Memory buffers” (which could be used to implement arrays and strings 100% in Julia
Being able to specify a finalizer for a type, instead of having to use a 16-byte (on 64-bit machines) entry for every object.
Tagged Unions where the type could be determined by the instance itself (instead of the way it currently has to allocate a byte per element that is allocated at the end of an array, for the current implementation in Julia for small unions)
Jakob Nissen, on having Rust-like Enums in Julia:
I see two advantages […] it’s easier to make nested types […] but whatever, it’s just syntactic sugar. I think the real killer is the exhaustive matching. Consider Julia’s findfirst function. It infers to
Union{Int, Nothing}
. But it actually returns either/or. If that instead returned an enum of these two types, it would not be possible to ignore the fact that it can actually returnnothing
. […] It’s almost like a trap in Julia, that the type is inferred to be possibly aNothing
, but when testing it appears exactly like as if it returns anInt
, until it suddenly fails"