Julia Tools and Editors¶
Florian Oswald¶
This is lecture is a slightly modified version of https://lectures.quantecon.org/jl/tools_editors.html Thank you to the amazing Quantecon.org team!
Co-authored with Arnav Sood.
While Jupyter notebooks are a great way to get started with the language, eventually you will want to use more powerful tools
We’ll discuss a few of them here, such as
- Text editors like Atom, which come with rich Julia support for debugging, documentation, git integration, plotting and inspecting data, and code execution
- The Julia REPL, which has specialized modes for package management, shell commands, and help
- The Docker setup we mentioned in getting started, which provides a painless pre-configured environment on your machine
Note that we assume you’ve already completed the getting started lecture
Preliminary Setup¶
- Follow the instructions for setting up Julia on your local computer
- We have done this in the last session.
Creating a Startup File (Recommended)¶
Whenever the Julia compiler or REPL starts, it will look for a file called startup.jl (see Julia Manual)
We provide a file here which does two things
- Makes the REPL shell mode “sticky,” so you don’t need to keep running
;for new commands - Loads the
Revise.jlpackage on startup, which lets you see changes you make to a package in real-time (i.e., no need to quit the REPL, open again, and load again)
The location for the file is relative to your default Julia environment (e.g. ~/.julia/config/startup.jl or C:\Users\USERNAME\.julia\config\startup.jl on Windows)
Recall that you can find the location of the ~/.julia directory by running
DEPOT_PATH[1]
Note: On Mac, this won’t be visible in the Finder unless you specifically enable that option, but you can get to it by running cd .julia; open . from a new terminal. Alternatively, with your Finder window open at HOME, just press Shift + CMD + . to see all hidden files.
To add Revise.jl:
- In the
juliaterminal, type the following
] add Revise REPL; precompile
- Create the
~/.julia/config/directory if necessary in the terminal or file explorer - Download the file startup.jl into that directory
- For convenience, you may find it useful on your operating system to change the directory where the REPL starts
On Windows, if you have a shortcut on your desktop or on the taskbar, you could: (1) right-click on the icon; (2) right click on the “julia” text; (3) choose “Properties”, and (4) change the “Start In” to be something such as C:\Users\YOURUSERNAME\Documents
The REPL¶
Previously, we discussed basic use of the Julia REPL (“Read-Evaluate-Print Loop”)
Here, we’ll consider some more advanced features
Shell Mode¶
- Hitting
;brings you into shell mode, which lets you run bash commands (PowerShell on Windows) - Notice that by default the REPL goes back to standard mode after your shell command exists - not so with our modification from above in
startup.jl! - To go back to standard mode, type
CTRL + c
#; pwd
pwd()
You can also use Julia variables from shell mode: the shell can "read" the julia variable x!
x = 2
# ; echo $x
Package Mode¶
Hitting ] brings you into package mode
] add Expectationswill add a package (here,Expectations.jl)- Likewise,
] rm Expectationswill remove that package ] stwill show you a snapshot of what you have installed] upwill (intelligently) upgrade versions of your packages] precompilewill precompile everytihng possible
You can get a full list of package mode commands by running
] ?
On some operating systems (such as OSX) REPL pasting may not work for package mode, and you will need to access it in the standard way (i.e., hit ] first and then run your commands)
Help Mode¶
Hitting ? will bring you into help mode
The key use case is to find docstrings for functions and macros, e.g.
? print
Note that objects must be loaded for Julia to return their documentation, e.g.
? @test
will fail, but
using Test
? @test
will succeed.
Atom¶
- As discussed previously, eventually you will want to use a fully fledged text editor.
- The most feature-rich one for Julia development is Atom, with the Juno package
There are several reasons to use a text editor like Atom, including
- Git integration (more on this in the next lecture)
- Painless inspection of variables and data
- Easily run code blocks, and drop in custom snippets of code
Integration with Julia documentation and plots
sublime is another good alternative (much fewer features than Juno, but very stable. Just send lines of code into the console with sendText)
Installation and Configuration¶
- Download and Install Atom from the Atom website
(Optional, but recommended): Change default Atom settings
- Use
Ctrl-,(CMD ,on Mac) to get theSettingspane - Choose the
Packagestab Type
line-ending-selectorinto the Filter and then click “Settings” for that package- Change the default line ending to
LF(only necessary on Windows)
- Change the default line ending to
Choose the Editor tab
- Turn on
Soft Wrap - Set the
Tab Lengthdefault to4
- Turn on
- Use
Installing Juno¶
- Use
Ctrl-,to get the Settings pane - Go to the
Installtab - Type
uber-junointo the search box and then click Install on the package that appears - Wait while Juno installs dependencies
- When it asks you whether or not to use the standard layout, click
yes
At that point, you should see a built-in REPL at the bottom of the screen and be able to start using Julia and Atom
Troubleshooting¶
Sometimes, Juno will fail to find the Julia executable (say, if it’s installed somewhere nonstandard, or you have multiple)
To do this
Ctrl-,to get Settings pane, and select the Packages tab- Type in
julia-clientand choose Settings - Find the Julia Path, and fill it in with the location of the Julia binary
- To find the binary, you could run
Sys.BINDIRin the REPL, then add in an additional/juliato the end of the screen output- e.g.
C:\Users\YOURUSERNAME\AppData\Local\Julia-1.0.1\bin\julia.exeon Windows as/Applications/Julia-1.0.app/Contents/Resources/julia/bin/juliaon OSX
See the setup instructions for Juno if you have further issues
Standard Layout¶
If you follow the instructions, you should see something like this when you open a new file
If you don’t, simply go to the command palette and type “Julia standard layout”
The bottom pane is a standard REPL, which supports the different modes above
The “workspace” pane is a snapshot of currently-defined objects
For example, if we define an object in the REPL
x = 2
Our workspace should read
The ans variable simply captures the result of the last computation
The Documentation pane simply lets us query Julia documentation
The Plots pane captures Julia plots output (the code is as follows)
using Plots
gr(fmt = :png);
data = rand(10, 10)
h = heatmap(data)
Note: The plots feature is not perfectly reliable across all plotting backends, see the Basic Usage page
Other Features¶
Shift + Enterwill evaluate a highlighted selection or line (as above)- The run symbol in the left sidebar (or
Ctrl+Shift+Enter) will run the whole file
See basic usage for an exploration of features, and the FAQ for more advanced steps (e.g. using with Docker)
Package Environments¶
- Julia’s package manager lets you set up Python-style “virtualenvs,” or subsets of packages that draw from an underlying pool of assets on the machine.
- This way, you can work with (and specify) the dependencies (i.e., required packages) for one project without worrying about impacts on other projects.
- Your project
Amay depend on packagexzy - Your project
B, however, may depend on an old version of packagexzy!
- Your project
This is fundamental to ensure reproducibility of results!
An
environmentis a set of packages specified by aProject.toml(and optionally, aManifest.toml)- A
registryis a git repository corresponding to a list of (typically) registered packages, from which Julia can pull (for more on git repositories, see version control) - A
depotis a directory, like~/.julia, which contains assets (compile caches, registries, package source directories, etc.)
Essentially, an environment is a dependency tree for a project, or a “frame of mind” for Julia’s package manager
- We can see the default (
v1.0) environment as such:
] st
- We can also create and activate a new environment
] generate ExampleEnvironment
- And go to it
; cd ExampleEnvironment
- To activate the directory, simply
] activate .
where “.” stands in for the “present working directory”
- Let’s make some changes to this Environment now
- after
activate-ing and environment, all package manager actions are applied to that environment:
] add Expectations Parameters
Note the lack of commas!
- To see the changes, simply open the
ExampleEnvironmentdirectory in an editor like Atom
The Project TOML should look something like this
name = "ExampleEnvironment"
uuid = "f92c96ca-1a46-11e9-1b82-d538e194f99a"
authors = ["Florian Oswald <florian.oswald@gmail.com>"]
version = "0.1.0"
[deps]
Expectations = "2fe49d83-0758-5602-8f54-1f90ad0d522b"
Parameters = "d96e819e-fc66-5662-9728-84c9c7592b0a"
We can also
] precompile
Note The TOML files are independent of the actual assets (which live in ~/.julia/packages, ~/.julia/dev, and ~/.julia/compiled)
You can think of the TOML as specifying demands for resources, which are supplied by the ~/.julia user depot
- To return to the default Julia environment, simply without any arguments!
] activate
- Finally, to clean up:
; cd .. ; rm -rf ExampleEnvironment
InstantiateFromURL¶
With this knowledge, we can explain the operation of the setup block
using InstantiateFromURL
# activate the QuantEcon environment
activate_github("QuantEcon/QuantEconLecturePackages", tag = "v0.9.5");