Julia can be downloaded from the main website (https://julialang.org) via the Download menu option. It is available for Windows, macOS, Linux, and FreeBSD, and the appropriate download bundles are provided for a current stable version, a long-term support (LTS) version, and the next release. At the time of writing, the stable release is 1.8.5, the LTS is 1.6.7, and the new beta release is 1.9.0. I will briefly cover installing and uninstalling later, although the Julia website is the best source of information.

It can be run using the Julia REPL, the VS Code editor, and a couple of web-based IDEs, Jupyter and Pluto, which we will discuss later in this chapter.

The previous edition used Julia v0.4, which was the stable version at the time, so a large amount has changed since then. When we hosted JuliaCon 2018, v1.0 was announced, promising fewer breaking changes, although these are not insignificant, and so far, a number of breaking changes have been introduced on each...

Julia was first released to the world in February 2012 after a couple of years of development at the Massachusetts Institute of Technology (MIT). This was followed by a couple of years of development at MIT. Later, in 2015, a commercial arm called Julia Computing was set up to acquire funding and provide consultancy and (some) enterprise packages; this was later renamed to JuliaHub to reflect the inclusion of a cloud computing platform facility, at present, hosted on Amazon Web Services (AWS). The use of the JuliaHub cloud is discussed in the last chapter of this book.

Most of Julia remains freely available and we will be concentrating on that here. As mentioned previously, version 1.0 was released in 2018 and, at present, is approaching v1.9.0, although there seem to be no plans for a main release to mark crossing the v2 barrier.

All the original developers – Jeff Bezanson, Stefan Karpinski, and Viral Shah – still maintain roles in the evolution...

Julia was designed with scientific computing in mind. The developers tell us that they came with a wide array of programming skills – Lisp, Python, Ruby, R, and MATLAB.

All needed a “fast” compiled language in the armory such, as C or Fortran as the current languages listed previously are pitifully slow. Here is a quote from the development team:

We want a language that’s open source, with a liberal license. We want the speed of C with the dynamism of Ruby. We want a language that’s homoiconic, with true macros like Lisp, but with obvious, familiar mathematical notation like MATLAB. We want something as usable for general programming as Python, as easy for statistics as R, as natural for string processing as Perl, as powerful for linear algebra as MATLAB, as good at gluing programs together as the shell. Something that is dirt simple to learn yet keeps the most serious hackers happy. We want it to be interactive and we want it compiled...

Julia was initially designed with scientific computing in mind and has made considerable strides in recent years in the fields of machine learning, optimization, solution of differential systems, and so on, all of which will be dealt with topics in the latter portion of this book.

However, Julia was originally seen as a vehicle for the emerging discipline of data science, possibly as an alternative or adjunct to more popular approaches, and it is worth remarking that practitioners in data science would be advised to see what Julia has to offer here as well.

Although the term data science was coined as early as the 1970s, it was only given prominence in 2001 by William S. Cleveland in his article, Data Science: An Action Plan for Expanding the Technical Areas of the Field of Statistics.

Almost in parallel with the development of Julia has been the growth in data science and the demand for data science practitioners.

What is data science?

People...

Julia’s “big” idea was to compile the program right down to the machine code level.

This was by incorporating the LLVM technology developed at Urbana-Champaign in the early 2000s. LLVM was originally termed as the low-level virtual machine but is now seen as a mnemonic. Conceptually, Julia Core is parsed via an internal Lisp (Femtolisp) translator and then compiled into an intermediate representation (IR), and then a machine-dependent LLVM compiler is invoked to produce the actual executable.

Although this represents an overhead, the code is cached (i.e., only compiled once), and much effort has gone into creating system images of the basic Julia system and caching individual packages. This makes execution times of the same “order” as C code, perhaps about (x2). C compilers are often better optimized, but LLVM is getting there quickly. So, Julia provides the holy grail of compact code as well as fast execution times. The downside...

Programming in Julia sometimes seems too good to be true. As it has been implemented in the last few years, many of the recent ideas in computer science design have been incorporated into the language and the developers have not been afraid to modify Julia’s structure and syntax on the run-up to version 1.0, even though this has led to deprecations and breaking changes.

We have pointed out previously that Julia creates executable code from scripts without a separate compilation step and this results in runtimes in the same order as those of C, Fortran, Java, and so on; however, in my opinion, that is not the main reason to use Julia. In this section, we will look at the other factors that make it a must-see for any programmer, analyst, and data scientist.

Julia is easy to learn

Writing simple code in Julia will be almost immediate for anyone with a grounding in Python, R, C, and so on, as this book will show.

As mentioned previously, the syntax is...

Starting to program in Julia is very easy. Naturally, the first task you will need to do is to install Julia on your computer. Thankfully, this has been made very simple. In the early versions of Julia, it was necessary to build from source but was largely made redundant with binaries for the major operating systems.

We differentiate between several different sets of sources:

• Windows
• Apple macOS
• Generic Linux (x86)
• Generic Linux (ARM)
• Free BSD
• Source (necessary for other OSs)

As noted previously, the best place to look is the main Julia website (http://julialang.org), and navigate to the Downloads tab on the menu.

Windows and macOS are serviced by exe and dmg binaries, respectively. In these cases, installation is as simple as downloading the binary and clicking on it, and everything else is handled by the installer. As of v1.9, a source on Apple macOS is now available for the new M-series processors, in addition to...

We have noted that Julia uses GitHub as a repository for the language source and a large number of Julia packages are hosted there.

Note

Other sources for Julia packages may be found on Bitbucket, GitLab, and so on; see stackshare.io for a full discussion: https://stackshare.io/stackups/bitbucket-vs-github-vs-gitlab.

As a full discussion of the package system is given on the Julia website, here, we will cover some of the main commands to use.

In v1.0, a new package manager has been introduced. Given the increase in registered packages, now approaching 2,000, the previous version (which relied on separate invocations of Git) became very slow, especially when using Windows.

Earlier, a method using the Pkg interface for package management was discussed. An alternate approach is to use one of the subset systems from the REPL. This is one of three such subsystems:

Online Help: Triggered by typing ?

• Command Shell: Triggered by typing ;

All the material covered in this chapter will be looked at in more detail in the rest of the book. The aim was to indicate what a simple, straightforward, yet powerful language Julia is.

Julia has been maturing for nearly 12 years, and with the advent of the v1.0+ releases, the formation of the commercial company, JuliaHub (previously named Julia Computing), and the growth of modules (approaching 10,000 in number at the time of writing), it has never been a better time to study and perhaps adopt Julia as a programming language of choice.

The fact that all three of the original developers are still actively involved with the evolution of the language as well as playing major roles within JuliaHub is a testament to the faith that they and many others are putting in it

This chapter introduced you to Julia, and how to download it, install it, and build it from the source. We saw that the language is elegant, concise, and powerful, and introduced some simple Julia coding examples.

The next four chapters will discuss the features of Julia in more depth.

We looked at interacting with Julia via the command line (REPL) in order to use a random walk method to evaluate the price of an Asian option. Also, we discussed the use of the VS Code editor and two IDEs, IJulia and Pluto, as an alternative to the REPL.

Additionally, we reviewed the built-in package manager, how to add, update and remove modules, and then demonstrated the use of two graphics packages to display typical trajectories of the Asian option calculation. In later chapters, we will look at various other approaches in order to create display graphics and quality visualizations.

In the next chapter, we will begin our detailed look at coding in Julia by discussing its primitive...