StaticLint.jl
JET.jl
StaticLint.jl | JET.jl | |
---|---|---|
4 | 13 | |
133 | 690 | |
1.5% | - | |
5.7 | 9.0 | |
30 days ago | 13 days ago | |
Julia | Julia | |
GNU General Public License v3.0 or later | MIT License |
Stars - the number of stars that a project has on GitHub. Growth - month over month growth in stars.
Activity is a relative number indicating how actively a project is being developed. Recent commits have higher weight than older ones.
For example, an activity of 9.0 indicates that a project is amongst the top 10% of the most actively developed projects that we are tracking.
StaticLint.jl
-
Julia v1.9.0 has been released
Yes, tooling around this is being developed in the form of linters (e.g. https://github.com/julia-vscode/StaticLint.jl) and through real compiler integration tools like the very cool https://aviatesk.github.io/JET.jl/dev/ but this is definitely somewhere that the tooling in julia is weaker than in other languages. It seems to be picking up a lot of speed though.
-
The Julia language has a number of correctness flaws
It is correct if `A` is of type `Array` as normal Array in julia has 1-based indexing. It is incorrect if `A` is of some other type which subtypes `AbstractArray` as these may not follow 1-based indexing. But this case errors normally due to bounds checking. The OP talks about the case where even bounds checking is turned off using `@inbounds` for speed and thus silently giving wrong answers without giving an error.
An issue was created sometime ago in StaticLint.jl to fix this: https://github.com/julia-vscode/StaticLint.jl/issues/337
-
I created an Emacs package to statically lint Julia files (using StaticLint.jl)
Statically lint = find errors in the Julia file like using variables that are not defined, and functions with the wrong arguments. For Julia, StaticLint.jl is an actively developed library that does static linting. It basically provides a bunch of functions that spit out errors in your Julia file like those that I mentioned above. If you are an Emacs editor user, this project is like a "convenience" which will run Julia silently in the background, and communicate with it to extract errors in the file that you currently have open. These errors are then highlighted in your editor view using the Flycheck package that is one of the ways to highlight errors in Emacs.
JET.jl
-
Prospects of utilising Rust in scientific computation?
An informative discussion on julia forum. Have you tried using https://github.com/aviatesk/JET.jl to minimize type instabilities?
-
Julia v1.9.0 has been released
For instance, https://github.com/aviatesk/JET.jl is still in its relative infancy, but it's played a big role in detecting quite a few potential bugs that had never been reported to use by users or caught in our testing infrastructure. There's also been a lot developments like interfaces to RR the time travelling debugger https://rr-project.org/ which helps us better understand and catch some very hard to debug non-deterministic bugs.
-
Julia Computing Raises $24M Series A
Have you seen Shuhei Tadowaki'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.
-
I Hate Programming Language Advocacy (2000)
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.
-
From Julia to Rust
- Pattern matching (sometimes you don't want the overhead of a method lookup)
[1]: https://github.com/aviatesk/JET.jl
-
Julia is the best language to extend Python for scientific computing
You can use the `@code_warntype` macro to check for type stability, which is very helpful for detecting such performance pitfalls on single function level. In the future, https://github.com/aviatesk/JET.jl may give a more powerful way to do it.
- Jet.jl: experimental type checker for Julia
- Jet.jl: A WIP compile time type checker for Julia
What are some alternatives?
LanguageServer.jl - An implementation of the Microsoft Language Server Protocol for the Julia language.
julia - The Julia Programming Language
julia-staticlint - Emacs integration for StaticLint.jl
Enzyme.jl - Julia bindings for the Enzyme automatic differentiator
Optimization.jl - Mathematical Optimization in Julia. Local, global, gradient-based and derivative-free. Linear, Quadratic, Convex, Mixed-Integer, and Nonlinear Optimization in one simple, fast, and differentiable interface.
Metatheory.jl - General purpose algebraic metaprogramming and symbolic computation library for the Julia programming language: E-Graphs & equality saturation, term rewriting and more.
StatsBase.jl - Basic statistics for Julia
StaticArrays.jl - Statically sized arrays for Julia
dotfiles - Linux work environment setup
HTTP.jl - HTTP for Julia
Distributions.jl - A Julia package for probability distributions and associated functions.
FromFile.jl - Julia enhancement proposal (Julep) for implicit per file module in Julia