FromFile.jl
JET.jl
FromFile.jl | JET.jl | |
---|---|---|
6 | 13 | |
131 | 690 | |
- | - | |
1.5 | 9.0 | |
about 1 year ago | 14 days ago | |
Julia | Julia | |
MIT License | 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.
FromFile.jl
-
A Programming language ideal for Scientific Sustainability and Reproducibility?
On include-- you might like FromFile.jl as an alternative.
- Modules in Julia
-
How to import an own module from the current directory?
For this and other oddities with Julia's include/import system (and especially as you're coming from Python), I'd recommend FromFile as a readable way to approach things.
-
Why not Julia?
You might like FromFile.jl.
-
Problems with nested `include`s and solutions?
However, if you prefer a Python-like experience, checkout FromFile.jl
-
Julia 1.6: what has changed since Julia 1.0?
I'm not using modules. I usually start with one file with a demo or similarly named function that is called if the file is called as an entry point (like if __name__ == '__main__', except Julia makes it even worse).
I tend to refactor code out of there to separate files, and then somehow import it. An ugly way is include, and I've tried Revise.jl with includet.
But I think the least ugly approach is the @from macro from here: https://github.com/Roger-luo/FromFile.jl Judging from some opinion in bug trackers, this is probably gonna get totally shunned by core devs and they'll keep on bikeshedding about the import stuff forever.
With this setup I have about 400 lines of code in three files. It compiles for 15 seconds. After every single change, and actually without any changes too.
I think performance wise this should be equivalent to using modules, but saving some pointless ceremony.
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?
julia - The Julia Programming Language
DaemonMode.jl - Client-Daemon workflow to run faster scripts in Julia
Enzyme.jl - Julia bindings for the Enzyme automatic differentiator
DataFramesMeta.jl - Metaprogramming tools for DataFrames
Metatheory.jl - General purpose algebraic metaprogramming and symbolic computation library for the Julia programming language: E-Graphs & equality saturation, term rewriting and more.
SymbolicRegression.jl - Distributed High-Performance Symbolic Regression in Julia
StaticArrays.jl - Statically sized arrays for Julia
TwoBasedIndexing.jl - Two-based indexing
HTTP.jl - HTTP for Julia
IRTools.jl - Mike's Little Intermediate Representation