Here are some tips for working with Julia efficiently.
As already elaborated in Interacting With Julia, Julia's REPL provides rich functionality that facilitates an efficient interactive workflow. Here are some tips that might further enhance your experience at the command line.
A basic editor/REPL workflow
The most basic Julia workflows involve using a text editor in conjunction with the
line. A common pattern includes the following elements:
Put code under development in a temporary module. Create a file, say
Tmp.jl, and include within it
``` module Tmp
`` * **Put your test code in another file.** Create another file, saytst.jl`, which begins with
julia import Tmp
and includes tests for the contents of
Tmp. The value of using
usingis that you can call
reload("Tmp")instead of having to restart the REPL when your definitions change. Of course, the cost is the need to prepend
Tmp.to uses of names defined in your module. (You can lower that cost by keeping your module name short.)
Alternatively, you can wrap the contents of your test file in a module, as
``` module Tst using Tmp
The advantage is that you can now do
using Tmpin your test code and can therefore avoid prepending
Tmp.everywhere. The disadvantage is that code can no longer be selectively copied to the REPL without some tweaking. * Lather. Rinse. Repeat. Explore ideas at the
juliacommand prompt. Save good ideas in
tst.jl. Occasionally restart the REPL, issuing
julia reload("Tmp") include("tst.jl")
To simplify restarting the REPL, put project-specific initialization code in a file, say
which you can run on startup by issuing the command:
julia -L _init.jl
If you further add the following to your
isfile("_init.jl") && include(joinpath(pwd(), "_init.jl"))
julia from that directory will run the initialization code without the additional
command line argument.
It is also possible to interact with a Julia REPL in the browser via IJulia. See the package home for details.