Julia

Introduction to Julia

Matthew DeHaven

February 9, 2026

Course Home Page

Overview

Similar to R and Python in syntax
Very fast
Builtin package and environment manager
Unicode support
Broadcasting and multiple dispatch
Strings, dictionaries, and control flow

Julia

Julia Background

Extremely new language.

Development began in 2009. Version 1.0 was launched in 2018.

Developed by a group at MIT: “Why We Created Julia”

Designed to be:

As readable as R and Python
As fast as C

(C is very fast, but hard to read and write)

Julia Microbenchmarks

Running Julia in VS Code

You can run a whole file of Julia code by clicking the play arrow.

Or you can run a single line or selection…

hitting Shift+Enter

Both of these will execute the Julia code in a terminal, called a REPL

REPL = read–eval–print–loop.

Hello World Example

x = "Hello Class!"
print(x)

Hello Class!

Same rounding issues for storing numerical values:

a = 0.1
b = 0.1
c = 0.1

print(a + b + c == 0.3)

false

Julia Basics

Variable Assignment

Julia uses a single = for assignment

x = 42

Just like R, functions can be assigned to variables:

a = sqrt
a(10)

3.1622776601683795

Basic Math

Math is not that different:

3 + 3

3 - 3

3 * 3

3 / 3

1.0

3 ^ 3 # Power

3 % 3  # remainder

Logic

Logic operators are written with double && or ||

1 > 2

false

1 < 2

true

1 > 2 && 1 < 2

false

1 > 2 || 1 < 2

true

!false

true

Julia uses lowercase true and false for booleans, unlike R’s TRUE and FALSE.

Julia Data Types

Booleans
Numbers: Integer, Floating
Strings
Collections:
- Arrays, Tuples, Dicts

Making Arrays

A basic array is constructed as comma-separated elements in square brackets

my_array = [1, 5, 2, 8]

4-element Vector{Int64}:
 1
 5
 2
 8

Single dimension arrays are referred to as Vectors.

Array Types

Arrays will default to the most general type at construction.

int_array = [1, 5, 2, 8]

4-element Vector{Int64}:
 1
 5
 2
 8

If even one of the elements is a float at construction:

float_array = [1, 5.2, 2, 8]

4-element Vector{Float64}:
 1.0
 5.2
 2.0
 8.0

Array Types are Immutable

We cannot add a float to an already made Int Array:

int_array[2] = 9.1

InexactError: Int64(9.1)
Stacktrace:
 [1] Int64
   @ ./float.jl:923 [inlined]
 [2] convert
   @ ./number.jl:7 [inlined]
 [3] setindex!(A::Vector{Int64}, x::Float64, i::Int64)
   @ Base ./array.jl:985
 [4] top-level scope
   @ ~/GitHub/Teaching/BrownEcon2020/course-applied-economics-analysis-2026-Spring/lecture-slides/julia.qmd:216

Arrays of Any Type

But at construction, arrays can include any types:

a = [1, 3.14, "hi", false]

4-element Vector{Any}:
     1
     3.14
      "hi"
 false

Julia will default to a general type “Any” to allow an integer, float, string, and boolean to exist in the same array.

Enforcing an Array Type

You can be explicit about the type for an array by listing it before the square brackets.

int_array = Int[1, 2, 3]

3-element Vector{Int64}:
 1
 2
 3

If we wanted this to be a Float array:

fl_array = Float64[1, 2, 3]

3-element Vector{Float64}:
 1.0
 2.0
 3.0

Empty Arrays

This is most useful when creating an empty array—which defaults to type Any.

empty_array = []

Any[]

Empty array with a type:

string_array = String[]

String[]

Array Dimensions

You can make…

arrays of multiple dimensions (2d: matrices, Nd).

m = [[1, 2, 3] [4, 5, 6]]

3×2 Matrix{Int64}:
 1  4
 2  5
 3  6

Arrays of arrays:

aa = [[1, 2, 3], [4, 5, 6]]

2-element Vector{Vector{Int64}}:
 [1, 2, 3]
 [4, 5, 6]

Tuples

Tuples are constructed as comma-separated elements in parentheses.

my_tuple = (1, "hi", 2.2, false)

(1, "hi", 2.2, false)

Tuples are immutable; arrays are mutable.

i.e. you cannot change values of tuples once created, or add additional elements

my_tuple[1] = 4

MethodError: no method matching setindex!(::Tuple{Int64, String, Float64, Bool}, ::Int64, ::Int64)
The function `setindex!` exists, but no method is defined for this combination of argument types.
Stacktrace:
 [1] top-level scope
   @ ~/GitHub/Teaching/BrownEcon2020/course-applied-economics-analysis-2026-Spring/lecture-slides/julia.qmd:293

Strings

Strings in Julia use double quotes (single quotes are for characters):

greeting = "Hello"
name = "World"

"World"

String concatenation uses * (not + like Python):

greeting * ", " * name * "!"

"Hello, World!"

String Interpolation

Julia can insert variables directly into strings with $:

x = 42
println("The answer is $x")

The answer is 42

You can also put expressions inside $():

println("2 + 2 = $(2 + 2)")

2 + 2 = 4

Compare to R’s paste() or paste0().

Julia’s $ interpolation is much more concise: "Hello $name" vs paste0("Hello ", name).

Dictionaries

Dictionaries store key-value pairs (similar to named lists in R):

d = Dict("a" => 1, "b" => 2, "c" => 3)

Dict{String, Int64} with 3 entries:
  "c" => 3
  "b" => 2
  "a" => 1

Access values by key:

d["a"]

Add or update entries:

d["d"] = 4
d

Dict{String, Int64} with 4 entries:
  "c" => 3
  "b" => 2
  "a" => 1
  "d" => 4

Julia Indexing and Subsetting

Julia starts indexing from 1.

We can subset arrays with square brackets:

x = ["a", "b", "c"]
x[1]

"a"

We can also subset with ranges:

x[2:3]

2-element Vector{String}:
 "b"
 "c"

For Loops

Julia is not space sensitive.

A for loop instead ends with an end keyword

for i in 1:10
  print(i)
end

12345678910

Leaving out the space is fine (though ugly).

for i in 1:10
print(i)
end

12345678910

for i in 1:10 print(i) end

12345678910

While Loops

Julia also has while loops:

i = 1
while i <= 5
  print(i, " ")
  i += 1
end

1 2 3 4 5

Just like for loops, while loops are closed with end.

If Statements

Julia uses if, elseif, and else — all closed with end:

x = 15

if x > 10
  print("Big")
elseif x > 5
  print("Medium")
else
  print("Small")
end

Big

Compare to R which uses if (...) { } else if (...) { } else { }.

Julia uses elseif (one word, no space) and end instead of braces.

Ternary Operator

For simple if/else, Julia has a one-line shortcut:

x = 7
result = x > 5 ? "big" : "small"
print(result)

big

This is equivalent to:

if x > 5
  result = "big"
else
  result = "small"
end

Julia Functions

Julia functions are defined with the keyword function and end:

function hi()
  print("Hello!")
end

hi()

Hello!

You can define arguments and return values.

function my_pythagorean(a, b)
  c = a ^ 2 + b ^ 2
  return c
end

my_pythagorean(3, 4)

Short Function Declaration

For one line functions, you can define them with:

f(x, y) = x + y * x

f(2, 3)

Multiple Dispatch

Julia’s key design feature: you can define the same function for different input types.

describe(x::Int) = println("$x is an integer")
describe(x::Float64) = println("$x is a float")
describe(x::String) = println("\"$x\" is a string")

describe (generic function with 3 methods)

describe(42)

42 is an integer

describe(3.14)

3.14 is a float

describe("hello")

"hello" is a string

Why Multiple Dispatch Matters

Julia picks the right version of a function based on all argument types.

This is how Julia stays fast: the compiler generates optimized code for each type combination.

You can see all versions (“methods”) of a function:

methods(describe)

Fun Feature: Unicode Support

Julia has built in unicode support.

Unicode is a text encoding standard that supports characters from all major writing systems and emojis!

print("Hi! 😃")

Hi! 😃

But what’s really fun, is that you can use emojis as variables too…

😃 = 4
💛 = 2


f(😃, 💛)

Practical Unicode

Actual use: greek letters for equations

β = 0.99
γ = 1.2

U(C) = β * (1 / (1 - γ)) * C ^ (1 - γ)

U(10)

-3.123238855176958

Tidier than writing out “beta” and “gamma”,

Writing out Unicode

In VS Code, to get one of these unicode symbols, you type:

\:smiley: for 😃

Once you start typing \:smi… you can use tab to autocomplete.

Similarily,

\beta for β

For a full list, see the Unicode Julia documentation.

Vectorization in Julia

Julia can vectorize (broadcast) any function, which is incredibly useful.

By default, Julia functions aren’t vectorized:

abs([-7, 2, -5])

MethodError: no method matching abs(::Vector{Int64})
The function `abs` exists, but no method is defined for this combination of argument types.

Closest candidates are:
  abs(::Bool)
   @ Base bool.jl:155
  abs(::Pkg.Resolve.VersionWeight)
   @ Pkg ~/.julia/juliaup/julia-1.12.4+0.aarch64.apple.darwin14/share/julia/stdlib/v1.12/Pkg/src/Resolve/versionweights.jl:32
  abs(::Missing)
   @ Base missing.jl:101
  ...

Stacktrace:
 [1] top-level scope
   @ ~/GitHub/Teaching/BrownEcon2020/course-applied-economics-analysis-2026-Spring/lecture-slides/julia.qmd:609

Vectorization in Julia

Julia can vectorize (broadcast) any function, which is incredibly useful.

By default, Julia functions aren’t vectorized:

abs([-7, 2, -5])

To apply the abs function to each element, add the . operator:

abs.([-7, 2, -5])

3-element Vector{Int64}:
 7
 2
 5

Broadcasting Your Own Functions

Broadcasting with the . operator works for any functions:

f(x) = x ^ 2 + 7 - x

f.(1:6)

6-element Vector{Int64}:
  7
  9
 13
 19
 27
 37

Broadcasting with Math Operators

By default, Julia won’t multiply two vectors element by element:

vec1 = [1, 4, 3]
vec2 = [1, 2, 7]

vec1 * vec2

MethodError: no method matching *(::Vector{Int64}, ::Vector{Int64})
The function `*` exists, but no method is defined for this combination of argument types.

Closest candidates are:
  *(::Any, ::Any, ::Any, ::Any...)
   @ Base operators.jl:642
  *(::LinearAlgebra.AbstractQ, ::AbstractVector)
   @ LinearAlgebra ~/.julia/juliaup/julia-1.12.4+0.aarch64.apple.darwin14/share/julia/stdlib/v1.12/LinearAlgebra/src/abstractq.jl:180
  *(::Dates.Period, ::AbstractArray)
   @ Dates ~/.julia/juliaup/julia-1.12.4+0.aarch64.apple.darwin14/share/julia/stdlib/v1.12/Dates/src/periods.jl:93
  ...

Stacktrace:
 [1] top-level scope
   @ ~/GitHub/Teaching/BrownEcon2020/course-applied-economics-analysis-2026-Spring/lecture-slides/julia.qmd:650

Broadcasting with Math Operators

By default, Julia won’t multiply two vectors element by element:

vec1 = [1, 4, 3]
vec2 = [1, 2, 7]

vec1 * vec2

Instead, use broadcasting to get this behavior

vec1 .* vec2

3-element Vector{Int64}:
  1
  8
 21

Or, for matrix multiplication, use ' to transpose and line up the dimensions:

vec1' * vec2

The Pipe Operator

Julia has a pipe operator |>, just like R’s |> or %>%:

-5 |> abs

You can chain multiple operations:

-16.0 |> abs |> sqrt

4.0

Combine with broadcasting using .|>:

[-1, -3, -5] .|> abs

3-element Vector{Int64}:
 1
 3
 5

Class Activity

Open a Julia REPL in VS Code and try the following:

Create an array of the integers 1 through 20.
Write a function is_even(x) that returns true if x is even and false otherwise.
- Hint: the remainder operator is %.
Broadcast your function over the array to get a vector of true/false.
Use string interpolation to print: "There are __ even numbers in my array."
- Hint: you can sum() a boolean vector.

Julia Environments and Packages

Pkg.jl

Julia has a built in package and environment manager: Pkg.jl

It has its own REPL, which can be launched from Julia by typing a right square bracket: ]

But all of its commands can also be run from withing Julia.

ex: Pkg.add("DataFrames")

I will show commands should be run in the Pkg REPL with: pkg>

Creating an Environment

In a Julia REPL, activate the Pkg REPL with: ]

Then you can create and activate an environment:

pkg>

activate myenv

This will create an environment in a new folder, “myenv”.

If you want to use your current folder, run

pkg>

activate .

This is what I would use in a VS Code project folder.

Adding a Package

In Julia, you can install packages both system wide

i.e. in the default installation environment (called something like “v1.10”)

or in an environment you have created.

To add the DataFrames.jl package:

pkg>

add DataFrames

This is equivalent to running the following in Julia:

import Pkg
Pkg.add("DataFrames")

Pkg TOMLs

Once you have a package added to your environment, you will see two files:

Project.toml: Lists the packages you have installed for this environment

Manifest.toml: Lists the Julia version, installed package versions, package dependency versions

With these two files, Julia can always recreate your environment.

Connect Environment to VS Code Workspace

In order to have your VS Code workspace automatically use the correct Julia environment, you have to connect it.

Open the Command Palette (Shift+Cmd+P), then search “Julia: Change Current Environment”

Click on “Julia env:” at the bottom left of the VS Code window

After selecting your environment, VS Code will add a “.vscode/settings.json” file to the folder. This file contains a path to the environment.

Using Packages

Once you have a package installed, you can:

Load the entire namespace:

using DataFrames
DataFrame(a = 1:2, b = 3:4)

Import the package and use the . to reference functions

import DataFrames
DataFrames.DataFrame(a = 1:2, b = 3:4)

Import the package and rename it

import DataFrames as DF
DF.DataFrame(a = 1:2, b = 3:4)

DataFrames

Working with Data

DataFrames is a package that implements dataframes in Julia.

First, you need to install DataFrames, then import it.

pkg>

add DataFrames

And then in your Julia code:

using DataFrames

DataFrame Example

Constructing a dataframe by hand:

df = DataFrame(
  a = [1, 5, 6, 8],
  b = ["Y", "Y", "N", "N"],
  c = [true, false, false, true]
)

4×3 DataFrame

Row	a	b	c
	Int64	String	Bool
1	1	Y	true
2	5	Y	false
3	6	N	false
4	8	N	true

Accessing Columns

You can access a column by name with . or [:, :col]:

df.a

4-element Vector{Int64}:
 1
 5
 6
 8

df[:, :b]

4-element Vector{String}:
 "Y"
 "Y"
 "N"
 "N"

df.a is shorthand. df[:, :a] returns a copy; df[!, :a] returns the column without copying.

Filtering Rows

Filter rows using boolean conditions:

df[df.a .> 4, :]

3×3 DataFrame

Row	a	b	c
	Int64	String	Bool
1	5	Y	false
2	6	N	false
3	8	N	true

Filtering on Multiple Rows

Combine conditions with .&& (broadcasted AND):

df[(df.a .> 2) .&& (df.b .== "Y"), :]

1×3 DataFrame

Row	a	b	c
	Int64	String	Bool
1	5	Y	false

Notice the .> and .== — these are broadcasted comparisons, just like we saw earlier.

The “Bang!” Convention

In Julia, functions that modify their inputs always end with a bang: !

For example, if we want to add a row to the DataFrame:

push!(df, [2, "Y", false])

5×3 DataFrame

Row	a	b	c
	Int64	String	Bool
1	1	Y	true
2	5	Y	false
3	6	N	false
4	8	N	true
5	2	Y	false

Mutating vs. Non-Mutating

Compare sort (returns a new array) vs. sort! (modifies in place):

my_vec = [3, 1, 2]
sorted_vec = sort(my_vec)

println("Original: $my_vec")
println("Sorted copy: $sorted_vec")

Original: [3, 1, 2]
Sorted copy: [1, 2, 3]

sort!(my_vec)
println("Original: $my_vec")

Original: [1, 2, 3]

Whenever you see a ! at the end of a function name, it is warning you: “this will change your data in place!”

Data Science with DataFrames

Usual data science operations are possible with Julia and DataFrames.jl

group by
summarize
adding new columns
etc.

For reading and writing CSVs, use the CSV.jl package.

Plotting in Julia

Lots of possible plotting packages in Julia.

Plots.jl the most used
Gadfly.jl is a grammar of graphics package
UnicodePLots.jl makes plots in the terminal
Makie.jl is a high performance plotting package (can use GPUs for big plots)
AlgebraOfGraphics.jl is a grammar of graphics package that wraps Makie.jl
PlotlyJS.jl is a wrapper for Plotly

Plot Example with `PLots.jl`

using Plots
x = 1:10
y = rand(10)
plot(x, y, title="My Plot")

Just-in-time Compilation

Programming languages have to be compiled to machine code before they can be run.

Julia does this “just-in-time” (JIT)—i.e. right before the code is run.

This means that Julia can be very fast, but it also means that the first time you run a function, it will be slow.

The speed advantage comes from compiling code for only the specific types of the inputs.

An example of the disadvantage is the “time to first plot” problem.

the first plot you run in a Julia session takes a while, the second is fast

Summary

Lecture Summary

Similar to R and Python in syntax
Very fast
Builtin package and environment manager
Unicode support
Broadcasting and multiple dispatch
Strings, dictionaries, and control flow
Pipe operator |>
Mutating ! convention
JIT compilation

Live Coding Example

Launch Julia REPL
Create a new environment ] activate .
Install Gadfly and RDatasets

using Gadfly, RDatasets

iris = dataset("datasets", "iris")
plot(iris, x = :SepalLength, y = :SepalWidth, Geom.point)

mtcars = dataset("datasets", "mtcars")
plot(mtcars, x = :MPG, y = :HP, Geom.point)

attach Julia environment to VS Code workspace

Julia

Overview

Julia

Julia Background

Julia Microbenchmarks

Running Julia in VS Code

Hello World Example

Julia Basics

Variable Assignment

Basic Math

Logic

Julia Data Types

Making Arrays

Array Types

Array Types are Immutable

Arrays of Any Type

Enforcing an Array Type

Empty Arrays

Array Dimensions

Tuples

Strings

String Interpolation

Dictionaries

Julia Indexing and Subsetting

For Loops

While Loops

If Statements

Ternary Operator

Julia Functions

Short Function Declaration

Multiple Dispatch

Why Multiple Dispatch Matters

Fun Feature: Unicode Support

Practical Unicode

Writing out Unicode

Vectorization in Julia

Vectorization in Julia

Broadcasting Your Own Functions

Broadcasting with Math Operators

Broadcasting with Math Operators

The Pipe Operator

Class Activity

Class Activity

Julia Environments and Packages

Pkg.jl

Creating an Environment

Adding a Package

Pkg TOMLs

Connect Environment to VS Code Workspace

Using Packages

DataFrames

Working with Data

DataFrame Example

Accessing Columns

Filtering Rows

Filtering on Multiple Rows

The “Bang!” Convention

Mutating vs. Non-Mutating

Data Science with DataFrames

Plotting in Julia

Plot Example with PLots.jl

Just-in-time Compilation

Summary

Lecture Summary

Live Coding Example

Plot Example with `PLots.jl`