TwoBasedIndexing.jl
FromFile.jl
TwoBasedIndexing.jl | FromFile.jl | |
---|---|---|
11 | 6 | |
57 | 131 | |
- | - | |
0.0 | 1.5 | |
almost 7 years ago | about 1 year 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.
TwoBasedIndexing.jl
- PyCharm is the worst IDE I have used. /s
-
Obviously European elevators are designed by C programmers!
We need to evolve 2 based indexing is the superior choice
- I promise it won’t hurt you
-
The counter-intuitive rise of Python in scientific computing
There are other choices like https://github.com/simonster/TwoBasedIndexing.jl and https://github.com/giordano/StarWarsArrays.jl if you do not like 1-based indexing.
-
what a wonderful world
Not a problem, there are packages that let you have two-based indexing.
- Kill it bevor it lays eggs
- How to start a war
- Why does Julia adopt 1-based index?
-
some may hate it, some may love it
The one and only indexing is https://github.com/simonster/TwoBasedIndexing.jl
- Why not Julia?
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.
What are some alternatives?
DataFramesMeta.jl - Metaprogramming tools for DataFrames
julia - The Julia Programming Language
OffsetArrays.jl - Fortran-like arrays with arbitrary, zero or negative starting indices.
DaemonMode.jl - Client-Daemon workflow to run faster scripts in Julia
JET.jl - An experimental code analyzer for Julia. No need for additional type annotations.
StarWarsArrays.jl - Arrays indexed as the order of Star Wars movies
HTTP.jl - HTTP for Julia
SymbolicRegression.jl - Distributed High-Performance Symbolic Regression in Julia
Bigsimr.jl - Simulate multivariate distributions with arbitrary marginals.