Revise.jl

WRT boot times, yep it can take a little bit. There are packages like revise [0] or daemon mode [1] that ameliorate this issue while developing the code- and if it is a long running script like DL training, a long startup time will not matter. https://github.com/timholy/Revise.jl https://github.com/dmolina/DaemonMode.jl

Revise.jl[1] is very helpful for development, as it allows for seamless recompilation without restarts. Cold start can also take a long time, so sometimes it helps to add options[2] such as -O0 when developing. Two paths forward for AOT compilation are PackageCompiler.jl[3] mentioned already in this thread (things like RelocatableFolders.jl[4] come in handy) and the possibility of GPUCompiler.jl[5] some day. [1]: https://github.com/timholy/Revise.jl [2]: https://docs.julialang.org/en/v1/manual/command-line-options... [3]: https://github.com/JuliaLang/PackageCompiler.jl [4]: https://github.com/JuliaPackaging/RelocatableFolders.jl [5]: https://github.com/JuliaGPU/GPUCompiler.jl/issues/3

I don't think there is anyone developing packages on pluto/jupyter, so I wouldn't worry about that. The most common method for that should be using an editor like VSCode (which will have some linting capabilities) with an open REPL and Revise [1]. What it does is every time you save any of your files (with some known restrictions), it will automatically and incrementally update the state of your application in the REPL, allowing you to probe your code whenever you want (with tons of introspection methods, up to interactively inspecting the native code being generated), and since you never leave the session you don't face the compiling latency more than once. I end up preferring this workflow for experimenting and data science stuff since it retains the structure and tooling of an editor with the ability to interact with my application (an

In Julia, this can be done with even less efforts on the user-side by loading Revise (https://github.com/timholy/Revise.jl) before any other package you load.

Julia has some packages to address this now. https://github.com/timholy/Revise.jl

There is another Julia package called Revise.jl : https://github.com/timholy/Revise.jl When loading Revise.jl in a Julia REPL session, it keeps track of all packages loaded afterwards and if the code is changed in one of the packages it automatically updates the functions provided by that package. As far as I know this does not work (yet) for structures that have been changed though. The cool thing is now, that it seems as if one can also use Revise.jl in a Pluto notebook - when the code of a package loaded in a Pluto notebook is changed, then also the cells in that notebook are run again with the updated code.

>since I'm relying on fast editing/execution cycles While you can't do it from the shell very well right now (rerunning the program at each step like you would with an interpreted language), that kind of fast cycle is something very common in Julia development but with a particular REPL based workflow [1] in which you use a tool like Revise.jl [2] to automatically update the definition whenever you save a file in your project (the only restriction is that it doesn't automatically updates new type definitions) and directly interacting with the program in the REPL. This way it will only recompile what you just altered, and it's very fast to actually run the code. Other interesting tools are Rebugger.jl (debugger for the REPL) [3] and OhMyREPL (coloring for the REPL) [4], which you can add to your startup.jl to always automatically load them

The start up times really bug me too. I think the solution might be sticking to a Jupyter/Juno session or keeping a repl open and reloading. https://github.com/timholy/Revise.jl It is incredible the degree with which small inconveniences can inhibit adoption.

There have been over 25 000 commits since that post was written, clearly, any comments about the specifics of the language are terribly out of date. For example, the base language now has 92% test coverage. CI is being run on Windows 32/64 bit, Linux 32/64bit, macOS, FreeBSD with ARM CI coming up. Every day a large number of benchmarks are run on dedicated hardware and the results are tracked. Benchmarks are also run on most PRs that has potential performance implications bhefore merging. Before new point releases, the tests for all registered packages are run and compared to the old version. Every new failure in a package test is tracked down to make sure there is nothing breaking in the point release. While package load time is still an issue, the introduced precompilation feature has significantly helped with this. Also, new methods of