Julia v1.1 Release Notes
github.com
github.com
1. repl in juno is slow. like broken rendering slow. checking fallback renderer didn't help.
2. dependencies move too quickly. I was trying to reproduce the neural odes code
https://julialang.org/blog/2019/01/fluxdiffeq
and it's broken. one of the dependencies symengine uses some kind of is_windows check https://github.com/symengine/SymEngine.jl/pull/150
which is fixed but at .5.0 which is not what symengine was pinned to (.4.3.0) and add symengine#master didn't work (neither the hash).
3. what is precompiling and why does it happen every single time I restart the interpreter? can I just compile once and be done with it? because it takes minutes each time.
4. getting jupyter to recongize my kernel took I don't even know what? first it wasn't there then after trying to run ijulia notebook from repl, which didn't work, it was there.
Pre-compilation shouldn't trigger all the time, and there is an explicit workflow page about how to avoid constantly triggering the need to restart Julia and JIT everything. It reduced my amount of cursing tremendously.
The ecosystem has improved loads since 1.0 came out but is still lacking in some corners.
The pay off for us has been worth it, but with so much outdated information out there, the tooling in a rough-around-the-edges state, and the documentation of core packages sometimes lacking it's also not something you can easily dip your toes into unfortunately.
For a streamlined workflow, I recommend Emacs + Revise.jl. I just edit my code in an Emacs buffer, and the Revise automatically updates the REPL to reflect the source. This makes the code feel tangible, more than any other language I have experienced.
juno is a product of the team
https://juliacomputing.com/products/juliapro.html
i'm assuming it's where they hope to make the bulk of the revenue from
what is the value proposition of julia? productivity of python with the speed of c (or some kind of tagline like this). a large part of the productivity of python is the fantastic set of tools around python. hence it's quite fair to judge julia proper on the polish of the tools that you need in order to be productive in julia.
I agree that tooling has a significant influence on the productivity of a language. One does not only adopt a language, but the ecosystem and community around it. I think we both agree on this. I am simply trying to point out that there is an unavoidable delay between the maturity of the language and the maturity of the ecosystem. I think its fair to take this delay into account.
What do you mean it's broken? Is it because SymEngine couldn't install? SymEngine seems to have a lot of issues because it relies on Conda and builds its dependencies in an odd way. Python package management is notoriously rough, which is why we are excising it from DiffEq v6.0 (https://github.com/JuliaDiffEq/DifferentialEquations.jl/issu...).
https://github.com/symengine/SymEngine.jl/pull/150/files
the obvious fix was to update to the latest version of SymEngine using the #master modifier with Pkg.add() but it didn't work - it kept ignoring #master and adding v0.4.3 nonetheless. i then tried #5dfc78a, the hash of master, and neither did that work.
It's also one of the Google Summer of Code projects https://julialang.org/soc/projects/general.html
I think that currently, the Julia intepreter is compiled to Wasm, so LLVM is not yet involved?
But it also gives all the tools for not having to restart the interpreter very often these days.
- An exception stack is maintained on each task.
- The experimental macro Base.@locals returns a dictionary of current local variable names and values.
- Binary ~ can now be dotted, as in x .~ y .