JET.jl

The question here is are these merely just bugs or is there something about the language that makes Julia error prone? There is potential in using Julia's type inference engine to check for correctness. For example see JET.jl. "JET.jl employs Julia's type inference to detect potential bugs." https://github.com/aviatesk/JET.jl https://www.youtube.com/watch?v=7eOiGc8wfE0 The video brings up some potential difficulties with Julia's metaprogramming facilities for static or lexical analysis, but also shows that these issues are also addressable. The type inference system could be exploited for further effect. For example, the type system could be extended to check for shape information within the type as demonstrated in this prototype: https://twitter.com/KenoFischer/status/1407810981338796035 Julia has guard rails (e.g. default bounds checkin

JET.jl does a surprisingly good job of statically checking julia type errors as well as other classes of errors using only type-level code analysis. https://github.com/aviatesk/JET.jl It does catch method ambiguities like those shown in this blog post: julia> using JET julia> f(x, y::Int) = x + y f (generic function with 2 methods) julia> f(x::Int, y) = x - y f (generic function with 2 methods) julia> g(x, y) = f(x, y) g (generic function with 1 method) julia> @test_call g(1, 2) JET-test failed at REPL[13]:1 Expression: #= REPL[13]:1 =# JET.@test_call g(1, 2) ═════ 1 possible error found ═════ ┌ @ REPL[12]:1 Main.f(x, y) │ no matching method found for call signature (Tuple{typeof(f), Int64, Int64}): Main.f(x::Int64, y::Int64) └────────────── ERROR: There was an error during testing

To your point about static analysis, https://github.com/aviatesk/JET.jl appears far more capable than comparable systems for other dynamic languages.

New compiler improvements have vastly increased the space of linting -- please see JET.jl, for example: https://github.com/aviatesk/JET.jl

Have you seen Shuhei Kadowaki's work on JET.jl (?) If you're curious: https://github.com/aviatesk/JET.jl This may seem more about performance (than IDE development) but Shuhei is one of the driving contributors behind developing the capabilities to use compiler capabilities for IDE integration -- and indeed JET.jl contains the kernel of a number of these capabilities.

This is sort of being done right now, as dynamic languages have begun to adopt gradual typing... at least Python and Julia, that I know of. If something like [JET.jl](https://github.com/aviatesk/JET.jl) become ubiquitous in Julia, one could add a function that pointed out all the places in the code where types are not fully inferred by the compiler. It'll never be quite the same level of safety as a static language, however.

Yes, this is exactly what I was getting at. Speed is one of the reasons to choose Rust/C/C++ over Python, but there's other compelling ones: static types, more control over execution, tight coupling to the OS, etc. To truly solve the two language problem, Julia should have APIs and coding styles which allow greater control, even if they're not used by everyone. Because it's so closely integrated with C, Python actually does a decent job at this, which IMO is one of the reasons it's been so successful as a general purpose language in addition to a scientific one. I really hope Julia can do the same. Off the top of my head, here are a few features I think would really improve Julia for general purpose programming: - Static type checking (JET.jl[1] looks promising) - Faster startup (again, great strides have been made) - Tagged, closed union

This is a common point of confusion for people. Julia has a useful and expressive type system, so people just assume it must be static but it's not, julia is dynamically typed. It's intermediate representation is statically typed, but the language itself has dynamic semantics. That said, we have almost every trick and tool up our sleeves that static languages have (in various stages of development). Check out https://github.com/aviatesk/JET.jl if you want static typechecking of julia code.

On the package ecosystem side, 1.6 is required for JET.jl [0]. Despite being a dynamic language, the Julia compiler does a lot of static analysis (or "abstract interpretation" in Julia lingo). JET.jl exposes some of this to the user, opening a path for additional static analysis tools (or maybe even custom compilers). [0]: https://github.com/aviatesk/JET.jl

Technically it is catching the type error at compile time (but compile time is Just Ahead Of Time). If you want something that feels more like type checking in a statically compiled language, you should definitely check out https://github.com/aviatesk/JET.jl

This depends a lot on what one means by richness I suppose. I'd say that Python, Javascript, mosts lisps that don't have CLOS, etc. are all dynamic languages with very non-rich type systems. Julia's type system (and to a lesser extent Common Lisp's) are very different. They can do a lot of extremely powerful things with their type systems, just not (usually) static type checking (though even that's changing in julia land with JET.jl: https://github.com/aviatesk/JET.jl)