The Julia platform, in binary (that is, executable) form, can be downloaded from http://julialang.org/downloads/. It exists for three major platforms (Windows, Linux, and OS X) in 32- and 64-bit format, and it is delivered as a package or in an archive version. FreeBSD 64-bit is also supported.

You should use the current official stable release when doing serious professional work with Julia. At the time of writing, Julia has reached its version 1.0 production release. The previous link contains detailed and platform-specific instructions for the installation. We will not repeat these instructions here completely, but we will summarize some important points.

Keep in mind that your Windows OS must be version 7 or higher. Now, follow the steps shown here:

1. Download the julia-n.m.p-win64.exe file into a temporary folder (n.m.p is the version number, such as 0.7.0 or 0.1.0; win32/win64 are the 32- and 64-bit versions, respectively; a release candidate file looks like julia-1.0.0-rc1-nnnnnnn-win64 (where nnnnnnn is a checksum number such as 0480f1b)).
2. Double-click on the file (or right-click and select Run as Administrator if you want Julia installed for all users on the machine). Click OK on the security dialog message. Then, choose the installation directory (for example, for C:\julia, the default installation folder is: C:\Users\UserName\AppData\Local\Julia-n.m.p (where n.m.p is the version number)) and the setup program will extract the archive into the chosen folder, producing the following directory structure, and taking some 800 MB of disk space:

3. A menu shortcut will be created which, when clicked, starts the Julia command-line version or Read Evaluate Print Loop (REPL), as shown in the following screenshot:

4. On Windows, if you have chosen C:\Julia as your installation directory, this is the C:\Julia\bin\julia.exe file. Add C:\Julia\bin to your PATH variable if you want the REPL to be available on any command window.
5. More information on Julia's installation for the Windows OS can be found at https://github.com/JuliaLang/julia/blob/master/README.windows.md.

Installation for OS X is straightforward, and can be done using the standard software installation tools for the platform. Add /Applications/Julia-n.m.app/Contents/Resources/julia/bin/Julia to make Julia available everywhere on your computer.

Generic Linux binaries for x86 can be downloaded. This will get you a compressed tar.gz archive that will have a name similar to julia-1.0-linux-x86_64.tar.gz, for example, in your ~/Downloads directory in Ubuntu. Open up a Terminal window and navigate to the Downloads directory using cd Downloads. Move the tar.gz file to a directory of your choice, and then extract the tar.gz file using the tar -zxvf julia-1.0-linux-x86_64.tar.gz command. A directory with the extracted contents will be generated in the same parent directory as the compressed archive with a name similar to julia-n.m.p, where n.m.p is Julia's version number.

This is the directory from which Julia will be run; no further installation is needed. To run it, simply navigate to the julia-n.m.p\bin directory in your Terminal and type: ./julia.

If you want to be at the bleeding edge of development, you can download the nightly builds instead of the stable releases from https://julialang.org/downloads/nightlies.html. The nightly builds are generally less stable, but will contain the most recent features. They are available for Windows, Linux, and OS X.

The path to the Julia executable is contained in the environment variable, JULIA_BINDIR (for example, in our installation procedure, this was C:\Julia\bin on Windows).

If you want code to be run whenever you start a Julia session, put it in /home/.juliarc.jl on Ubuntu, ~/.juliarc.jl on OS X, or C:\Users\username\.juliarc.jl on Windows.

Download the source code, rather than the binaries, if you intend to contribute to the development of Julia itself, or if no Julia binaries are provided for your operating system or particular computer architecture. The Julia source code can be found on GitHub at https://github.com/JuliaLang/julia.git. Compiling the source code will get you the latest Julia version, not the stable version (if you want the latter, download the binaries, and refer to the previous section).

Because of the diversity of platforms and the possible issues involved, we refer you to https://github.com/JuliaLang/julia, and in that, the Source Download and Compilation section.

Another alternative is JuliaPro, which is available from https://juliacomputing.com/products/juliapro.html. This is an Anaconda-style Julia repository, which, at present, is only up to version 0.6.4. It does come with about 200+ verified ready-to-go packages, and is a very good way for beginners to start. JuliaPro version 1.0 will probably become available after some time.

There are two ways of using Julia. As described in the previous section, we can use the Julia shell for interactive work. Alternatively, we can write programs in a text file, save them with a .jl extension, and let Julia execute the program by starting it by running julia program.jl.

We started with Julia's REPL in the previous section to verify the correctness of the installation by issuing the julia command in a Terminal session. The REPL is Julia's working environment, where you can interact with the just in time (JIT) compiler to test out pieces of code. When satisfied, you can copy and paste this code into a file with a .jl extension, such as program.jl. Alternatively, you can continue to work on this code from within a text editor or an IDE, such as the ones we will point out later in this chapter. After the banner with Julia's logo has appeared, you will get a julia> prompt for the input. To end this session and get to the OS Command Prompt, type Ctrl + D, and hit Enter. To evaluate an expression, type it and press Enter to show the result, as shown in the following screenshot:

If, for some reason, you don't need to see the result, end the expression with a ; (semicolon) such as 8 * 5; In both the cases, the resulting value is stored, for convenience, in a variable named ans that can be used in expressions, but only inside the REPL. You can bind a value to a variable by entering an assignment as a = 3. Julia is dynamic, and we don't need to enter a type for a, but we do need to enter a value for the variable so that Julia can infer its type. Using a variable b that is not bound to the a value results in the ERROR: UndefVarError: b not defined message. Strings are delineated by double quotes (" "), as in b = "Julia". The following screenshot illustrates this in the REPL:

Previous expressions can be retrieved in the same session by working with the up and down arrow keys. The following key bindings are also handy:

• To clear or interrupt a current command, press Ctrl + C
• To clear the screen, press Ctrl + L (variables are kept in memory)

Commands from the previous sessions can still be retrieved, because they are stored (with a timestamp) in a repl_history.jl file (in /home/$USER/.julia/logs on Ubuntu, C:\Users\username\.julia\logs on Windows, or ~/.julia/logs/repl_history on OS X). Ctrl + R (produces a reverse-i-search prompt) searches through these commands. 

Typing ? starts up the help mode (help?>) to give you quick access to Julia's documentation. Information on function names, types, macros, and so on, is given when typing in their names. Alternatively, to get more information on a variable, for example, a, type ?a, and to get more information on a function such as sort, type ?sort. To find all the places where a function such as println is defined or used, type apropos("println"), which gives the following output:

Base.Pair
Base.any
Base.@isdefined
Base.eachindex
Base.all
Base.Generator
Base.Timer
…
Printf.@sprintf
REPL.TerminalMenus.request

Thus, we can see that it is defined in the Base module, and that it is used in several other functions.

Different complete expressions on the same line have to be separated by a ; (semicolon), and only the last result is shown. You can enter multiline expressions, as shown in the following screenshot. If the shell detects that the statement is syntactically incomplete, it will not attempt to evaluate it. Rather, it will wait for the user to enter additional lines until the multiline statement can be evaluated:

A handy autocomplete feature also exists. Type one or more letters, press the Tab key twice, and then a list of functions starting with these letters appears. For example, type so, press the Tab key twice, and then you will get the list as sort sort! sortcols sortperm sortperm! sortrows.

If you start a line with ;, the rest of the line is interpreted as a system shell command (try, for example, ls, cd, mkdir, whoami on Linux). The Backspace key returns to the Julia prompt.

A Julia script can be executed in the REPL by calling it with include. For example, for hello.jl, which contains the println("Hello, Julia World!") statement, the command is as follows:

julia> include("hello.jl") 

The preceding command prints the output as follows:

Hello, Julia World! 

Experiment a bit with different expressions to get a feeling for this environment.

Without any options, the julia command starts up the REPL environment. A useful option to check your environment is julia -v. This shows Julia's version, for example, julia version 1.0.0. (The versioninfo()function in REPL is more detailed, and the VERSION constant only gives you the version number: v"1.0.0"). An option that lets you evaluate expressions on the command line itself is -e, for example:

julia -e 'a = 6 * 7;
println(a)' 

The preceding commands print out 42 (this also works in a PowerShell window on Windows, but in an ordinary Windows Command Prompt, use " instead of the ' character).

Some other options that are useful for parallel processing will be discussed in Chapter 9, Running External Programs. Type julia -h for a list of all options.

A script.jl file with Julia source code can be started from the command line with the following command:

julia script.jl arg1 arg2 arg3

Here, arg1, arg2, and arg3 are optional arguments to be used in the script's code. They are available from the global constant ARGS. Take a look at the args.jl file, which contains the following:

for arg in ARGS 
    println(arg) 
end 

The julia args.jl 1 Red C command prints out 1, Red, and C on consecutive lines.

A script file can also execute other source files by including them in the REPL; for example, main.jl contains include("hello.jl"), which will execute the code from hello.jl when called with julia main.jl.

Sometimes, it can be useful to know when code is executed interactively in the REPL, or when started up with the Julia VM with the julia command. This can be tested with the isinteractive() function. The isinteractive.jl script contains the following code:

println("Is this interactive? $(isinteractive())")

If you start this up in the REPL with include("isinteractive.jl"), the output will be Is this interactive? true.

When started up in a Terminal window as julia isinteractive.jl, the output is Is this interactive? false.

Most of the standard library in Julia (which can be found in /share/julia/base and /share/julia/stdlib, relative to where Julia was installed) is written in Julia itself. The rest of Julia's code ecosystem is contained in packages that are simply GitHub repositories. They are most often authored by external contributors, and already provide functionality for such diverse disciplines such as bioinformatics, chemistry, cosmology, finance, linguistics, machine learning, mathematics, statistics, and high-performance computing. A package listing can be found at http://pkg.julialang.org.

Julia's installation contains a built-in package manager, Pkg, for installing additional packages that are written in Julia. Version and dependency management is handled automatically by Pkg.

Pkg has a REPL mode, which can be started from within the Julia REPL by entering the ] key, which is often called the REPL's package mode. The Pkg mode is shown as a blue prompt, like this: (v1.0) pkg>.

From this mode, we can start all functions of Pkg. To return to the normal REPL mode, press Backspace or Ctrl + C.

To initialize your environment, enter the init command, which creates an empty Project.toml file in your Julia installation folder.

Before adding a new package, it is always a good idea to update your package database for the already installed packages with the up command. Then, add a new package by issuing the add PackageName command, and execute it by using PackageName in the code or in the REPL.

For example, to add 2D plotting capabilities, install the Plots package with add Plots in the Package mode by first typing ]. This installs the Plots package and all of its dependencies, building them when needed.

To make a graph of 100 random numbers between 0 and 1, execute the following commands:

using Plots 
plot(rand(100))

The rand(100) function is an array with 100 random numbers. This produces the following output:

After installing a new Julia version, update all the installed packages by running up in the Pkg REPL-mode.

IJulia (https://github.com/JuliaLang/IJulia.jl) is a combination of the Jupyter Notebook interactive environment (http://jupyter.org/) with a Julia language backend. It allows you to work with a powerful graphical notebook (which combines code, formatted text, math, and multimedia in a single document) with a regular REPL. Detailed instructions for installation can be found at the GitHub page for IJulia (https://github.com/JuliaLang/IJulia.jl) and in the Julia at MIT notes (https://github.com/stevengj/julia-mit/blob/master/README.md). Add the IJulia package in the REPL package mode with add IJulia.

Then, whenever you want to use it, start up a Julia REPL and type the following commands:

using IJulia 
notebook()

If you want to run it from the command line, type:

jupyter notebook 

The IJulia dashboard should look as follows:

You should see the Jupyter logo in the upper-left corner of the browser window. Julia code is entered in the input cells (the input can be multiline) and then executed with Shift + Enter. 

Here is a small example (ijulia-example.jl):

The output should be something as follows:

In the first input cell, the value of b is calculated from a:

a = 5 
b = 2a^2 + 30a + 9 

In the second input cell, we use PyPlot. Install this package with add PyPlot in the REPL package mode, and by issuing using PyPlot in the REPL.

The range(0,stop=5,length=101) command defines an array of 100 equally spaced values between 0 and 5; y is defined as a function of x and is then shown graphically with the plot command, as follows:

using PyPlot 
x = range(0,stop=5,length=101) 
y = cos.(2x .+ 5) 
plot(x, y, linewidth=2.0, linestyle="--") 
title("a nice cosinus") 
xlabel("x axis") 
ylabel("y axis") 

Save a notebook in file format (with the .ipynb extension) by downloading it from the menu.

Juno (http://junolab.org/) is a full-fledged IDE for Julia by Mike Innes, which is based on the Atom environment. The setup page at https://github.com/JunoLab/uber-juno/blob/master/setup.md provides detailed instructions for installing and configuring Juno. Here is a summary of the steps:

1. Download and install Atom (https://atom.io/)
2. Start it up, go to Settings, and then click Install Panel
3. Enter uber-juno into the search box

Atom works extensively with a command palette that you can open by typing Ctrl + spacebar, entering a command, and then selecting it. Juno provides an integrated console, and you can evaluate single expressions in the code editor directly by typing Ctrl + Enter at the end of the line. A complete script is evaluated by typing Ctrl + Shift + Enter. More on basic usage can be found here: http://docs.junolab.org/latest/man/basic_usage.html.

Another IDE called julia-vscode is based on the Visual Studio Code editor (https://code.visualstudio.com/). Install it by following the instructions given here: https://github.com/JuliaEditorSupport/julia-vscode. This IDE provides syntax highlighting, code snippets, Julia-specific commands (execute code by pressing F5), an integrated Julia REPL, code completion, hover help, a linter, code navigation, and tasks for running tests, builds, benchmarks, and build documentation.

The Sublime Text editor (http://www.sublimetext.com/3) has a plugin called Julia-sublime: https://github.com/JuliaEditorSupport/Julia-sublime. It gives you syntax highlighting, autocompletion, auto-indentation, and code snippets. To install it, select Julia from the Package Control: Install Package drop-down list in the Command Palette.

For Terminal users, the available editors are as follows:

• Vim, together with julia-vim, works great (https://github.com/JuliaLang/julia-vim)
• Emacs, with julia-mode.el, from the https://github.com/JuliaLang/julia/tree/master/contrib directory

On Linux, gedit is very good. The Julia plugin works well and provides autocompletion. Notepad++ also has Julia support from the contrib directory mentioned earlier.

The CoCalc project (https://cocalc.com/) runs Julia in the cloud within a Terminal and lets you work with Jupyter notebooks. You can also work and teach with Julia in the cloud by using the JuliaBox platform (https://juliabox.org/).

(You can safely skip this section on a first reading.) Julia works with an LLVM JIT compiler framework that is used for JIT generation of machine code. The first time you run a Julia function, it is parsed, and the types are inferred. Then, LLVM code is generated by the JIT compiler, which is then optimized and compiled down to native code. The second time you run a Julia function, the native code that's already generated is called. This is the reason why, the second time you call a function with arguments of a specific type, it takes much less time to run than the first time (keep this in mind when doing benchmarks of Julia code).

This generated code can be inspected. Suppose, for example, that we have defined a f(x) = 2x + 5 function in a REPL session. Julia responds with the message f (generic function with one method); the code is dynamic because we didn't have to specify the type of x or f. Functions are, by default, generic in Julia because they are ready to work with different data types for their variables.

The code_llvm function can be used to see the JIT bytecode. This is the bytecode generated by LLVM, and it will be different for each target platform. For example, for the Intel x64 platform, if the x argument is of type Int64, it will be as follows:

julia> code_llvm(f, (Int64,)) 
 
; Function f 
; Location: REPL[7]:1 
; Function Attrs: uwtable 
define i64 @julia_f_33833(i64) #0 { 
top: 
; Function *; { 
; Location: int.jl:54 
  %1 = shl i64 %0, 1 
;} 
; Function +; { 
; Location: int.jl:53 
  %2 = add i64 %1, 5 
;} 
  ret i64 %2 
} 

The code_native function can be used to see the assembly code that was generated for the same type of x:

julia> code_native(f, (Int64,)) 
 
        .text 
; Function f { 
; Location: REPL[7]:1 
        pushq   %rbp 
        movq    %rsp, %rbp 
; Function +; { 
; Location: int.jl:53 
        leaq    5(%rcx,%rcx), %rax 
;} 
        popq    %rbp 
        retq 
        nopl    (%rax,%rax) 
;} 

Compare this with the code generated when x is of type Float64:

julia> code_native(f, (Float64,)) 
 
        .text 
; Function f { 
; Location: REPL[7]:1 
        pushq   %rbp 
        movq    %rsp, %rbp 
; Function *; { 
; Location: promotion.jl:314 
; Function *; { 
; Location: float.jl:399 
        vaddsd  %xmm0, %xmm0, %xmm0 
        movabsq $424735072, %rax        # imm = 0x1950F160 
;}} 
; Function +; { 
; Location: promotion.jl:313 
; Function +; { 
; Location: float.jl:395 
        vaddsd  (%rax), %xmm0, %xmm0 
;}} 
        popq    %rbp 
        retq 
        nopl    (%rax,%rax) 
;} 

Julia code is fast because it generates specialized versions of functions for each data type. Julia also implements automatic memory management. The user doesn't have to worry about allocating and keeping track of the memory for specific objects. Automatic deletion of objects that are not needed anymore (and hence, reclamation of the memory associated with those objects) is done using a garbage collector (GC).

The GC runs at the same time as your program. Exactly when a specific object is garbage collected is unpredictable. The GC implements an incremental mark-and-sweep algorithm. You can start garbage collection yourself by calling GC.gc(), or if you don't need it, you can disable it by calling GC.enable(false).

The standard library is implemented in Julia itself. The I/O functions rely on the libuv library for an efficient, platform-independent I/O. The standard library is contained in a package called Base, which is automatically imported when starting Julia.

By now, you should have been able to install Julia in the working environment you prefer using. You should also have some experience with working in the REPL. We will put this to good use starting in the next chapter, where we will meet the basic data types in Julia by testing out everything in the REPL.