Julia¹

• Third member of Ju-Pyt-R
  • Can run within Jupyter if you install a Julia kernel
• Dynamically typed, just-in-time compiled
• Becoming more popular recently, especially for Economists
• Still a little rough around the edges

Why Should I Use Julia?

• It’s fast

Installation

• Install Julia
• If you want to add a julia kernel to your jupyter installation:

using Pkg
Pkg.add('IJulia')

Scalars

an_int = 1
a_string = "Julia"
a_string

"Julia"

typeof(a_string)

String

Functions

function add_numbers(x, y)
    return x + y
end

add_numbers(3,2)

5

add_numbers("3", 2)

MethodError: no method matching +(::String, ::Int64)
Closest candidates are:
  +(::Any, ::Any, ::Any, ::Any...) at operators.jl:591
  +(::T, ::T) where T<:Union{Int128, Int16, Int32, Int64, Int8, UInt128, UInt16, UInt32, UInt64, UInt8} at int.jl:87
  +(::Base.TwicePrecision, ::Number) at twiceprecision.jl:290
  ...

add_numbers('3', 2)

'5': ASCII/Unicode U+0035 (category Nd: Number, decimal digit)

Loops

for i in 1:10
    println(i)
end

1
2
3
4
5
6
7
8
9
10

sum = 0
i = 0
while sum + i + 1 <= 2024
    i += 1
    sum += i
end
sum, i

(2016, 63)

Reading in CSVs

using CSV
using DataFrames

senate_polls = CSV.read(
    "/Users/hlukas/git/personal_website/static/econ-481/data/senate_polls_historical.csv", 
    DataFrame
)

Access a Column

senate_polls.pollster

6658-element PooledArrays.PooledVector{String, UInt32, Vector{UInt32}}:
 "Trafalgar Group"
 "Trafalgar Group"
 "Data for Progress"
 "Data for Progress"
 "InsiderAdvantage"
 "InsiderAdvantage"
 "Mitchell"
 "Mitchell"
 "Landmark Communications"
 "Landmark Communications"
 "Patriot Polling"
 "Patriot Polling"
 "Emerson"
 ⋮
 "Fabrizio"
 "Fabrizio"
 "Remington"
 "Remington"
 "PPP"
 "PPP"
 "MassINC Polling Group"
 "MassINC Polling Group"
 "Texas Lyceum"
 "Texas Lyceum"
 "Harper Polling"
 "Harper Polling"

Access a Row

senate_polls[1, :]

senate_polls[1, :pollster]

"Trafalgar Group"

Filtering Data

Filtering in DataFrames.jl is a little annoying – you do everything with functions:

is_az_poll(state) = state == "Arizona"
is_az_poll("Arizona")

true

filter(:state => is_az_poll, senate_polls)

Filtering Missing Data

Let’s use filter inline to filter the endorsed_candidate_party field to “DEM”:

filter(:endorsed_candidate_party => ==("DEM"), senate_polls)

LoadError: TypeError: non-boolean (Missing) used in boolean context

subset(
    senate_polls, 
    :endorsed_candidate_party => ByRow(==("DEM")); 
    skipmissing=true
)

Selecting Columns

A better way to select columns when your data has irregular names:

select(senate_polls, "pollster", "state", "cycle", "candidate_name", "pct")

Selecting Columns with Regex

Easy in Julia:

select(senate_polls, r"^candidate*")

Aggregating by Group

using Statistics

grouped_senate_cycle = groupby(senate_polls, :cycle)
combine(grouped_senate_cycle, :sample_size => (x -> mean(x)))

Missing Data Basic Fix

grouped_senate_cycle = groupby(senate_polls, :cycle)
combine(grouped_senate_cycle, :sample_size => (x -> mean(skipmissing(x))))

Alternative for Missing Data

combine(
    groupby(
        dropmissing(senate_polls, :sample_size), 
        :cycle
    ), 
    :sample_size => mean
)

Function Composition Operator

• We can “compose” two functions by typing \circ<TAB> and using the function composition operator.
• In math, \(f \circ g(x) = f(g(x))\)
• So in Julia, (mean ∘ skipmissing)(x) is mean(skipmissing(x))

combine(
    groupby(
        senate_polls, 
        :cycle
    ), 
    :sample_size => mean ∘ skipmissing
)

Macros

DataFramesMeta.jl admits use of “macros”, which are easy ways to access a function. For example, whereas before we used

select(senate_polls, :candidate_name)

using DataFramesMeta

@select senate_polls :candidate_name

Macro Types

For most of the DataFramesMeta.jl macros we have four variants:

• @macro: non-vectorized
• @rmacro: vectorized
• @macro!: non-vectorized in-place
• @rmacro!: vectorized in-place

What is Vectorized?

This works

exp(3.)

20.085536923187668

exp([3.,2.])

MethodError: no method matching exp(::Vector{Float64})
Closest candidates are:
  exp(::Union{Float16, Float32, Float64}) at special/exp.jl:326
  exp(::StridedMatrix{var"#s886"} where var"#s886"<:Union{Float32, Float64, ComplexF32, ComplexF64}) at /Applications/Julia-1.8.app/Contents/Resources/julia/share/julia/stdlib/v1.8/LinearAlgebra/src/dense.jl:569
  exp(::StridedMatrix{var"#s886"} where var"#s886"<:Union{Integer, Complex{<:Integer}}) at /Applications/Julia-1.8.app/Contents/Resources/julia/share/julia/stdlib/v1.8/LinearAlgebra/src/dense.jl:570
  ...

exp.([3.,2.])

2-element Vector{Float64}:
 20.085536923187668
  7.38905609893065

Compute Columns with @select

We can use the select macro to create new coumns:

@rselect senate_polls :poll_id :candidate_name :pct :pct_unit = :pct / 100

Compute Columns with @transform

This computation does no selection and just adds the column to the data – we can append ! to the end to do the computation inplace

@rtransform! senate_polls :pct_unit = :pct / 100
@select senate_polls :poll_id :candidate_name :pct :pct_unit

Multiple Column Creation

@rtransform! senate_polls begin
:is_dem = :party == "DEM"
:is_rep = :party == "REP"
end
@select senate_polls :party :is_dem :is_rep

Chaining

Remember that we had %>% in dplyr – DataFramesMeta.jl has a similar macro called @chain:

@chain senate_polls begin
    groupby(:cycle)
    @combine :mean_ss = (mean ∘ skipmissing)(:sample_size)
    @rsubset :mean_ss > 850
    @rtransform :mean_ss_sq = :mean_ss ^ 2
end

Other Macros

• The other functions we’ve worked with also have macros in DataFramesMeta.jl
  • E.g. @filter
• Using these macros is a little more intuitive and makes code more readable

Conclusion

• Julia is powerfully fast
  • We haven’t tested anything for speed here, so you’ll have to trust me
• It’s also far less developed than its counterparts, so you have to be a little more self-sufficient
• Don’t focus on it as much as your R and python, but it’s here and it’s valuable!