This chapter guides you through the download and installation process of all the necessary components of Julia. The topics covered in this chapter are as follows:

• Installing Julia
• Working with Julia's REPL
• Startup options and Julia scripts
• Packages
• Installing and working with IJulia
• Installing Juno
• Installing julia-vscode
• Installing Sublime-IJulia
• Other editors and IDEs
• How Julia works

By the end of this chapter, you will have a running Julia platform. Moreover, you will be able to work with Julia's shell as well as with editors or integrated development environments with a lot of built-in features to make development more comfortable.

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

1. Download thejulia-n.m.p-win64.exe file into a temporary folder (n.m.p is the version number, such as0.7.0 or0.1.0;win32/win64 are the 32- and 64-bit versions, respectively; a release candidate file looks likejulia-1.0.0-rc1-nnnnnnn-win64 (where nnnnnnn is a checksum number such as0480f1b)).
2. Double-click on the file (or right-click and selectRun as Administrator if you want Julia installed for all users on the machine). ClickOK on the security dialog message. Then, choose the installation directory (for example, forC:\julia, the default installation folder is:C:\Users\UserName\AppData\Local\Julia-n.m.p (wheren.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 orRead Evaluate Print Loop (REPL), as shown in the following screenshot:

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 compressedtar.gz archive that will have a name similar tojulia-1.0-linux-x86_64.tar.gz, for example, in your~/Downloads directory in Ubuntu. Open up a Terminal window and navigate to theDownloads directory usingcd Downloads. Move thetar.gz file to a directory of your choice, and then extract thetar.gz file using thetar -zxvf julia-1.0-linux-x86_64.tar.gzcommand. A directory with the extracted contents will be generated in the same parent directory as the compressed archive with a name similar tojulia-n.m.p, wheren.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 thejulia-n.m.p\bin directory in your Terminal and type:./julia.

We started with Julia's REPL in the previous section to verify the correctness of the installation by issuing thejuliacommand in a Terminal session. The REPL is Julia's working environment, where you can interact with thejust 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 asprogram.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 ajulia>prompt for the input. To end this session and get to the OS Command Prompt, typeCtrl +D, and hitEnter. To evaluate an expression, type it and pressEnter 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 as8 * 5; In both the cases, the resulting value is stored, for convenience, in a variable namedans that can be used in expressions, but only inside the REPL. You can bind a value to a variable by entering an assignment asa = 3. Julia is dynamic, and we don't need to enter a type fora, but we do need to enter a value for the variable so that Julia can infer its type. Using a variableb that is not bound to thea value results in theERROR: UndefVarError: b not defined message. Strings are delineated by double quotes (" "), as inb = "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, pressCtrl +C
• To clear the screen, pressCtrl +L (variables are kept in memory)

Commands from the previous sessions can still be retrieved, because they are stored (with a timestamp) in arepl_history.jl file (in/home/$USER/.julia/logs on Ubuntu,C:\Users\username\.julia\logs on Windows, or~/.julia/logs/repl_historyon OS X).Ctrl +R (produces areverse-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 assort, type?sort. To find all the places where a function such asprintln is defined or used, typeapropos("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 theBase 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 theTab key twice, and then a list of functions starting with these letters appears. For example, typeso, press theTab 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,whoamion Linux). TheBackspace key returns to the Julia prompt.

A Julia script can be executed in the REPL by calling it withinclude. For example, forhello.jl, which contains theprintln("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, thejulia command starts up the REPL environment. A useful option to check your environment isjulia -v. This shows Julia's version, for example,julia version 1.0.0. (Theversioninfo()function in REPL is more detailed, and theVERSION 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 out42 (this also works in a PowerShell window on Windows, but in an ordinary Windows Command Prompt, use" instead of the' character).

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

For example, to add 2D plotting capabilities, install thePlots package withadd Plots in thePackage mode by first typing]. This installs thePlots 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 Plotsplot(rand(100))

Therand(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 runningup in thePkg REPL-mode.

For Terminal users, the available editors are as follows:

(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 theJIT 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 af(x) = 2x + 5function in a REPL session. Julia responds with the message f (generic function with one method); the code isdynamic because we didn't have to specify the type ofx orf. Functions are, by default, generic in Julia because they are ready to work with different data types for their variables.

Thecode_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 thex argument is of typeInt64, 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 }

Thecode_native function can be used to see the assembly code that was generated for the same type ofx:

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 whenx is of typeFloat64:

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 agarbage 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 callingGC.gc(), or if you don't need it, you can disable it by callingGC.enable(false).

The standard library is implemented in Julia itself. The I/O functions rely on thelibuv library for an efficient, platform-independent I/O. The standard library is contained in a package calledBase, 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.