Julia 1.0 Programming - Second Edition

By Ivo Balbaert
    What do you get with a Packt Subscription?

  • Instant access to this title and 7,500+ eBooks & Videos
  • Constantly updated with 100+ new titles each month
  • Breadth and depth in over 1,000+ technologies
  1. Free Chapter
    Installing the Julia Platform
About this book
The release of Julia 1.0 is now ready to change the technical world by combining the high productivity and ease of use of Python and R with the lightning-fast speed of C++. Julia 1.0 programming gives you a head start in tackling your numerical and data problems. You will begin by learning how to set up a running Julia platform, before exploring its various built-in types. With the help of practical examples, this book walks you through two important collection types: arrays and matrices. In addition to this, you will be taken through how type conversions and promotions work. In the course of the book, you will be introduced to the homo-iconicity and metaprogramming concepts in Julia. You will understand how Julia provides different ways to interact with an operating system, as well as other languages, and then you'll discover what macros are. Once you have grasped the basics, you’ll study what makes Julia suitable for numerical and scientific computing, and learn about the features provided by Julia. By the end of this book, you will also have learned how to run external programs. This book covers all you need to know about Julia in order to leverage its high speed and efficiency for your applications.
Publication date:
September 2018


Chapter 1. Installing the Julia Platform

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.


Installing Julia

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.

Windows OS

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, forC:\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:

The Julia folder structure in Windows

  1. 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:

The Julia REPL

  1. 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.
  2. 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.

Linux OS

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.gzcommand. 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.

Building from source

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.


Working with Julia's REPL

We started with Julia's REPL in the previous section to verify the correctness of the installation by issuing the juliacommand 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:

Working with the REPL (1)

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:

Working with the REPL (2)

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_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 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:



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:

Working with the REPL (3)

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, typeso, 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, whoamion 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.


Startup options and Julia scripts

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;

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. Typejulia -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 

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.


You can download the example code files from your account at http://www.packtpub.com for all the Packt Publishing books you have purchased. If you purchased this book elsewhere, you can visit https://github.com/PacktPublishing/Julia-1.0-Programming-Second-Edition.



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.

Pkghas 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.

Adding a new package

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 Plotsplot(rand(100))

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

A plot of white noise with Plots

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


Installing and working with IJulia

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 IJulianotebook()


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

jupyter notebook

The IJulia dashboard should look as follows:

The IJulia dashboard

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:

An IJulia session example

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

a = 5b = 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.



Installing Juno

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.


Installing julia-vscode

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.


Installing Sublime-IJulia

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.



Other editors and IDEs

For Terminal users, the available editors are as follows:

On Linux, gedit is very good. The Julia plugin works well and provides autocompletion. Notepad++ also has Julia support from thecontrib 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/).


How Julia works

(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 + 5function 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 ofx 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 { 
; 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,)) 
; Function f { 
; Location: REPL[7]:1 
        pushq   %rbp 
        movq    %rsp, %rbp 
; Function +; { 
; Location: int.jl:53 
        leaq    5(%rcx,%rcx), %rax 
        popq    %rbp 
        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 
        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.

About the Author
  • Ivo Balbaert

    Ivo Balbaert is a lecturer in web programming and databases at CVO Antwerpen, a community college in Belgium. He received a PhD in applied physics from the University of Antwerp in 1986. He worked for 20 years in the software industry as a developer and consultant in several companies, and for 10 years as project manager at the University Hospital of Antwerp. From 2000 onwards, he switched to partly teaching and partly developing software (at KHM Mechelen, CVO Antwerpen). He also wrote an introductory book in Dutch about developing in Ruby and Rails, Programmeren met Ruby en Rails, published by Van Duuren Media. In 2012, he authored a book on the Go programming language, The Way to Go, published by iUniverse. He has written a number of introductory books for new programming languages, notably Dart, Julia, Rust, and Red, all published by Packt.

    Browse publications by this author
Latest Reviews (3 reviews total)
it is very convenient. thanks very much!
The book is good, but needs proofreading. Several grammatical errors, some of which confuse the content.
Learning Julia has been one of my goals for sometime. This book has arrived at just the right time for me. Enjoying both at the moment.
Recommended For You
Julia 1.0 Programming - Second Edition
Unlock this book and the full library FREE for 7 days
Start now