The Julia package ecosystem is under continuous development and new package versions are released on a daily basis. Most of the times this is great news, as new releases bring new features and bug fixes. However, since many of the packages are still in beta (version 0.x), any new release can introduce breaking changes. As a result, the code presented in the book can stop working. In order to ensure that your code will produce the same results as described in the book, it is recommended to use the same package versions. Here are the external packages used in this chapter and their specific versions:

CSV@v0.4.3
DataFrames@v0.15.2
Feather@v0.5.1
Gadfly@v1.0.1
IJulia@v1.14.1
JSON@v0.20.0
RDatasets@v0.6.1

In order to install a specific version of a package you need to run:

pkg> add PackageName@vX.Y.Z 

For example:

pkg> add IJulia@v1.14.1

Alternatively you can...

We have seen in the previous chapter how to use the REPL in order to execute computations and have the result displayed back to us. Julia even lends a helping hand by setting up the ans variable, which automatically holds the last computed value.

But, if we want to write anything but the most trivial programs, we need to learn how to define variables ourselves. In Julia, a variable is simply a name associated to a value. There are very few restrictions for naming variables, and the names themselves have no semantic meaning (the language will not treat variables differently based on their names, unlike say Ruby, where a name that is all caps is treated as a constant).

Let's see some examples:

julia> book = "Julia v1.0 By Example" 
julia> pi = 3.14 
julia> ANSWER = 42 
julia> my_first_name = "Adrian" 

Common programming wisdom says the following:

Code comments are a powerful tool that make the programs easier to understand later on. In Julia, comments are marked with the # sign. Single-line comments are denoted by a # and everything that follows this, until the end of the line, is ignored by the compiler. Multiline comments are enclosed between #= ... =#. Everything within the opening and the closing comment tags is also ignored by the compiler. Here is an example:

julia> #= 
           Our company charges a fixed  
           $10 fee per transaction. 
       =# 
const flatfee = 10 # flat fee, per transaction  
 

In the previous snippet, we can see both multiline and single-line comments in action. A single-line comment can also be placed at the beginning of the line.

A string represents a sequence of characters. We can create a string by enclosing the corresponding sequence of characters between double quotes, as shown in the following:

julia> "Measuring programming progress by lines of code is like measuring aircraft building progress by weight." 
 

If the string also includes quotes, we can escape these by prefixing them with a backslash \:

julia> "Beta is Latin for \"still doesn't work\"." 

However, escaping can get messy, so there's a much better way of dealing with this—by using triple quotes """...""".

julia> """Beta is Latin for "still doesn&apos...

Regular expressions are used for powerful pattern-matching of substrings within strings. They can be used to search for a substring in a string, based on patterns—and then to extract or replace the matches. Julia provides support for Perl-compatible regular expressions.

The most common way to input regular expressions is by using the so-called nonstandard string literals. These look like regular double-quoted strings, but carry a special prefix. In the case of regular expressions, this prefix is "r". The prefix provides for a different behavior, compared to a normal string literal.

For example, in order to define a regular string that matches all the letters, we can use r"[a-zA-Z]*".

Julia provides quite a few nonstandard string literals—and we can even define our own if we want to. The most widely used are for regular expressions...

If you need to define a string that does not perform interpolation or escaping, for example to represent code from another language that might contain $ and \ which can interfere with the Julia parser, you can use raw strings. They are constructed with raw"..." and create ordinary String objects that contain the enclosed characters exactly as entered, with no interpolation or escaping:

julia> "This $will error out" 
ERROR: UndefVarError: will not defined 

Putting a $ inside the string will cause Julia to perform interpolation and look for a variable called will:

julia> raw"This $will work" 
"This \$will work" 

But by using a raw string, the $ symbol will be ignored (or rather, automatically escaped, as you can see in the output).

Julia provides a broad range of primitive numeric types, together with the full range of arithmetic and bitwise operators and standard mathematical functions. We have at our disposal a rich hierarchy of numeric types, with the most generic being Number—which defines two subtypes, Complex and Real. Conversely, Real has four subtypes—AbstractFloat, Integer, Irrational, and Rational. Finally, Integer branches into four other subtypes—BigInt, Bool, Signed, and Unsigned.

Let's take a look at the most important categories of numbers.

Literal integers are represented simply as follows:

julia> 42 

The default Integer type, called Int, depends on the architecture of the system upon which...