Auto-evaluation

We have included in this page a series of quizzes to help reinforce your learning. These quizzes are designed not only to test your understanding but also to provide you with an opportunity for self-reflection. After each quiz, take a moment to review your answers, reflect on what you’ve learned, and identify areas where you may need further clarification. Do not hesitate to reach out to your lecturer if any questions come up.

Core Syntax

Question 1. Which of the following defines a variable x with value 10 in Julia?

Select an item

let x = 10

x = 10

int x = 10

x := 10

Question 2. Which keyword is used to define a function in Julia?

Select an item

def

function

func

lambda

Question 3. Which symbol is used for element-wise operations in Julia (e.g., squaring each element of a vector)?

Select an item

:

->

*

.

Question 4. What is the output of this code?

a = [1, 2, 3]
b = a
b[1] = 10
println(a)

Select an item

Error.

[1, 2, 3]

[10, 2, 3]

[1, 10, 3]

Question 5. What does the end keyword do in Julia?

Select an item

Closes a block of code like if, for, or function.

Ends a program.

Marks a breakpoint.

Skips to the next iteration.

Question 6. Which expression returns the number of elements in a vector v?

Select an item

count(v)

size(v)

length(v)

dim(v)

Question 7. What does === do in Julia?

Select an item

Checks if two expressions are numerically equal.

Performs type conversion.

Compares string equality.

Checks if two expressions refer to the exact same object in memory.

Question 8. What is the output of the following code?

result = 0
for i in 1:10
    if i == 5
        break
    end
    result += i
end
println(result)

Select an item

45

10

15

55

Question 9. What is the output of the following code?

result = Int[]
for i in 1:6
    if i % 2 == 0
        continue
    end
    push!(result, i)
end
println(result)

Select an item

[1, 3, 5]

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

[]

[2, 4, 6]

Question 10. Which of the following is a valid for loop in Julia?

Select an item

for i in 1:10

foreach i in 1:10

for i = 1 to 10

for (i = 1; i <= 10; i++)

Question 11. What is the output of the following code?

a = [1, 2, 3]
b = [1, 2, 3]
println(a == b)
println(a === b)

Select an item

true, true — identical contents imply identical memory.

true, false — == compares values, === checks same object in memory.

false, false — arrays are never considered equal.

true, true — both operators check value equality.

Question 12. What is the output of the following code?

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

Select an item

"small"

true

"big"

7

Question 13. What is the output of the following code?

v = [1, 2, 3]
println(v .^ 2)

Select an item

[1, 2, 3]

9 — the last element squared.

[2, 4, 6]

[1, 4, 9]

Type Hierarchies

Question 1. What is the purpose of an abstract type in Julia?

Select an item

It is used for type annotations in functions.

It defines a concrete implementation for other types.

It provides a blueprint for organizing related types but cannot be instantiated.

It can be instantiated and used directly.

Question 2. Which of the following types is a concrete type?

Select an item

Real

Int64

AbstractFloat

Number

Question 3. What does the isconcretetype function return for AbstractFloat?

Select an item

true

null

false

Error: Undefined type

Question 4. What will the following code return?

typeof(42)

Select an item

Int64

Number

Real

Integer

Question 5. What is the purpose of the isa operator in Julia?

Select an item

To check if a variable is a subtype of Any.

To check if a variable's value matches a specific type.

To check if a type is concrete.

To check if a variable is an instance of a specific type or any of its subtypes.

Question 6. What will be the result of the following code?

Int64 <: Real

Select an item

Error: Type mismatch

false

true for Float64 but not for Int64

true

Question 7. What will the following code return?

isconcretetype(Int64)
isconcretetype(AbstractFloat)

Select an item

false for both types if using a different syntax

true for AbstractFloat and false for Int64

false for both types

true for Int64 and false for AbstractFloat

Question 8. What does the <: operator check in Julia?

Select an item

If a type is abstract.

If two types are exactly the same.

If one type is a subtype of another.

If a type can be instantiated.

Question 9. What is the result of the following code?

subtypes(Real)

Select an item

Returns an error because Real is abstract.

Returns a list of all types that are subtypes of Real.

Shows Real as a parent type with no subtypes.

Returns Any as the only subtype of Real.

Question 10. What does the supertype function return for Float64?

supertype(Float64)

Select an item

Real

AbstractFloat

Number

Int

Question 11. What is the output of the following code?

println(42 isa Int64)
println(42 isa Real)
println(Int64 <: Real)
println(42 <: Real)

Select an item

true, true, true, false (or error) — <: is for types, not values.

true, true, true, true — all four return true.

true, false, true, false — isa Real only matches abstract types.

false, false, true, false — isa only matches concrete types.

Question 12. Starting from Float64, what is the correct chain of supertypes up to Any?

Select an item

Float64 → Number → Real → AbstractFloat → Any

Float64 → AbstractFloat → Real → Number → Any

Float64 → Real → Number → Any

Float64 → AbstractFloat → Number → Any

Type Conversion and Promotion

Question 1. What does the convert function do in Julia?

Select an item

It converts numbers to strings.

It changes a value to a boolean type.

It automatically promotes values to a common type.

It converts a value from one type to another, if possible.

Question 2. What is the output of the following code?

println(round(Int, 3.14))
println(floor(Int, 3.14))
println(convert(Float64, 5))
println(string(123))

Select an item

3, 3, 5.0, 123

5.0, 3, 5, "123"

3, 3.14, 5, "123"

3, 3, 5.0, "123"

Question 3. What happens when an integer is assigned to a Float64 variable in Julia?

y::Float64 = 10
println(y)

Select an item

The conversion needs to be done explicitly using convert.

The variable y will be set to the integer value of 10.

Julia automatically converts the integer to a Float64.

Julia throws a type error because of the type mismatch.

Question 4. What does the promote function do in Julia?

a, b = promote(3, 4.5)
println(a)
println(b)
println(typeof(a))
println(typeof(b))

Select an item

It promotes two values to a common type for an operation.

It converts both values to integers.

It converts values to strings for display.

It checks if two values have the same type.

Question 5. What will happen if we try to add an Int and a String in Julia?

println(3 + "Hello")

Select an item

Julia will automatically convert both to a common type.

It will promote the number to a string.

It will throw a type error.

It will concatenate the string and the number.

Question 6. What are the types of a, b, and c after the following promote call?

a, b, c = promote(1, 2.0, 3//1)
println(typeof(a), " ", typeof(b), " ", typeof(c))

Select an item

Int64 Float64 Rational{Int64} — no promotion occurs.

Int64 Int64 Int64 — floats are converted to Int.

Rational Float64 Rational — Rational is the common type.

Float64 Float64 Float64 — all promoted to the common type.

Question 7. What is the output of the following code?

println(floor(Int, -2.3))
println(round(Int, -2.5))

Select an item

-3, -3 — both round toward −∞.

-2, -3 — both round toward zero.

-3, -2 — floor rounds toward −∞; round uses banker's rounding.

-2, -2 — both round toward zero.

Special Types

Question 1. What does the Nothing type represent in Julia?

Select an item

It is used for undefined variables.

It is a special type for numeric values.

It is a placeholder for missing data.

It represents the absence of a meaningful value.

Question 2. What is the result of calling the following function in Julia?

# Example of a function that returns `Nothing`
function print_message(msg::String)
    println(msg)
    return nothing  # Explicitly returns `nothing`
end

result = print_message("Hello!")
println(result === nothing)  # Output: true

Select an item

nothing is returned and the output is true.

nothing is returned but the output is false.

The function returns a string 'nothing'.

The function throws an error because nothing cannot be returned.

Question 3. What happens to Julia’s compiler when a function’s return type is inferred as Any?

Select an item

The function can only accept Any-typed arguments.

The function becomes type-stable by definition.

The function runs faster because it skips all type checks.

The compiler cannot optimize the function, which degrades performance.

Question 4. What does the following code do in Julia?

data = [1, 2, missing, 4, 5]
for item in data
    if item === missing
        println("Missing data detected.")
    else
        println("Value: ", item)
    end
end

Select an item

It throws an error when encountering missing data.

It sums all the values and skips missing ones.

It replaces missing data with a default value.

It checks for missing values and prints a message for each.

Question 5. What is the purpose of the skipmissing function in Julia?

using Statistics

# Example array with missing values
data = [1, 2, missing, 4, 5, missing, 7]

# Summing values while skipping missing entries
sum_no_missing = sum(skipmissing(data))
println("Sum without missing values: ", sum_no_missing)  # Output: 19

# Calculating the mean while skipping missing values
mean_no_missing = mean(skipmissing(data))
println("Mean without missing values: ", mean_no_missing)  # Output: 3.8

Select an item

It creates an iterator that skips missing values during computations.

It prints out the number of missing values.

It raises an error if missing values are encountered.

It replaces missing values with 0.

Question 6. What is the output of the following code?

data = Union{Int, Missing}[1, missing, 3]
println(typeof(data[2]))
println(ismissing(data[2]))

Select an item

Nothing, false

Missing, true

Missing, false

Int64, true

Question 7. What is the output of the following code?

function find_value(d::Dict, key)
    return get(d, key, nothing)
end

result = find_value(Dict("a" => 1), "b")
println(result === nothing)
println(typeof(result))

Select an item

true, Missing — missing and nothing are the same.

true, Nothing — the key does not exist; get returns the default.

false, Int64 — the key is found.

false, Nothing — the function always returns Nothing.

Union Types

Question 1. What is a Union type in Julia?

Select an item

A type that allows a variable to accept multiple types.

A type that can only accept floating-point numbers.

A type that restricts a variable to only one type.

A built-in function for type conversion.

Question 2. What is the output of the following code?

function process_number(x::Union{Int, Float64})
    println("The input is: ", x)
end

process_number(5)       # Works with an Int
process_number(3.14)    # Works with a Float64

Select an item

The input is: 5, The input is: 3

The input is: 5, The input is: 3.14

The input is: 3.14, The input is: 5

The input is: 5, The input is: 3.0

Question 3. Which of the following scenarios would benefit from using a Union type?

# Example using Union to handle multiple types in a function
function add_one(x::Union{Int, Float64})
    return x + 1
end

println(add_one(3))     # Output: 4 (Int)
println(add_one(2.5))   # Output: 3.5 (Float64)

Select an item

When a function is only designed to accept floating-point numbers.

When there is a strict requirement to accept a specific type.

When a function accepts only integers.

When a function needs to accept both integers and floating-point numbers.

Question 4. Two methods exist for process. Which one is called by process(3//1)?

function process(x::Union{Int, Float64})
    return x * 2
end

function process(x::Real)
    return x + 1
end

println(process(3//1))

Select an item

4//1 — the Real method is called because Rational is not Int or Float64.

MethodError — no matching method exists.

6//1 — the Union{Int, Float64} method is called because Rational <: Int.

6.0 — the value is promoted to Float64.

Question 5. What is the output of the following code?

function add_one(x::Union{Int, Float64})
    return x + 1
end

println(add_one(Int8(3)))

Select an item

4 — Int8 is a subtype of Int, so the method matches.

4 as Int8.

MethodError — Int8 is not Int (which is Int64 on 64-bit systems).

4.0 — Int8 is promoted to Float64.

Question 6. What does Int <: Union{Int, Float64} return, and what does it mean?

Select an item

true — every type is a subtype of every Union.

true — Int is one of the types listed in the Union, so it is a subtype.

false — Int is a concrete type, so it cannot be a subtype of a Union.

false — <: only works between two concrete types.

Type Annotations and Declarations

Question 1. What is the primary purpose of type annotations in Julia?

Select an item

To make code run faster by skipping type checks.

To prevent errors from occurring in the code.

To specify the exact memory address of a variable.

To provide clarity in the code and enable optimizations by the compiler.

Question 2. Which of the following correctly applies a type annotation to a variable?

Select an item

Int::a = 10

a::Int = 10

a:Int = 10

a = 10::Int

Question 3. What will happen if the following code is executed?

function add(a::Int, b::Int)
    return a + b
end

add(3, "4")

Select an item

It will throw a type error because "4" is a String, not an Int.

It will ignore the type annotation and return 7.

It will convert "4" to an Int and return 7.

It will throw a syntax error.

Question 4. In Julia, what will the following code output?

function multiply(a::Int, b::Int)::Int
    return a * b
end
multiply(3, 4)

Select an item

12.0

Nothing

12

Error: Incorrect type

Question 5. What happens when the following function is called with f("hello")?

function f(x::T) where T <: Real
    return x * 2
end

f("hello")

Select an item

TypeError — the return type annotation is violated.

The function works because T is inferred as String.

MethodError — String is not a subtype of Real.

"hellohello" — the * operator works on strings too.

Parametric Types

Question 1. What is the output of the following code?

struct MyPair{T, S}
    first::T
    second::S
end

p = MyPair(1, 2.0)
println(typeof(p))

Select an item

MyPair{Int64, Float64}

MyPair{Any, Any}

MyPair{Number, Number}

MyPair{Int64, Int64}

Question 2. What is the role of T and S in the Pair struct example?

struct Pair{T, S}
    first::T
    second::S
end

pair1 = Pair(1, "apple")
pair2 = Pair(3.14, true)

Select an item

T is used for the first element, and S is used for the second element.

T and S define the data types of the first and second elements of the pair.

T defines the data type of both elements in the pair.

T and S are unused in this case, they are placeholders.

Question 3. What happens when you instantiate Pair(1, 'apple') in the provided code?

pair1 = Pair(1, "apple")

Select an item

It will cause a runtime error because the types don't match.

It will create a pair with an Int and a String.

It will throw an error because Int and String can't be combined.

It will create a pair with Int and String.

Question 4. What is the benefit of using parametric types like AbstractContainer{T}?

abstract type AbstractContainer{T} end

struct VectorContainer{T} <: AbstractContainer{T}
    data::Vector{T}
end

struct SetContainer{T} <: AbstractContainer{T}
    data::Set{T}
end

Select an item

It makes the code more complex and harder to maintain.

It allows you to specify concrete types directly in the struct.

It allows you to create types that can handle any type of data, with type safety.

It makes the code less flexible and more specific.

Question 5. What does the print_container_info function do?

function print_container_info(container::AbstractContainer{T}) where T
    println("Container holds values of type: ", T)
end

Select an item

It returns the type of the container.

It prints the type of the values in the container.

It prints the number of elements in the container.

It prints the values inside the container.

Question 6. What is the purpose of AbstractContainer{T} in the code example?

abstract type AbstractContainer{T} end

Select an item

It defines a container for a specific type of data.

It defines an abstract type that can be used to create containers for any data type T.

It defines a concrete container type.

It restricts containers to hold only numeric types.

Question 7. What would be the output of print_container_info(vec) if vec is VectorContainer([1, 2, 3])?

vec = VectorContainer([1, 2, 3])

Select an item

It will print the values inside the container.

It will throw an error because VectorContainer is not defined.

It will print Container holds values of type: Vector{Int64}.

It will print Container holds values of type: Int64.

Question 8. How does using parametric types help with code reusability?

Select an item

It makes the code less reusable.

It forces you to create new types for every use case.

It reduces the need to define separate functions for different data types.

It requires more boilerplate code.

Question 9. What is the output of the following code?

struct RealPair{T <: Real}
    first::T
    second::T
end

println(typeof(RealPair(1, 2)))
println(typeof(RealPair(1.0, 2.0)))

Select an item

RealPair{Real}, RealPair{Real}

RealPair{Any}, RealPair{Any}

RealPair{Number}, RealPair{Number}

RealPair{Int64}, RealPair{Float64}

Question 10. What happens when RealPair("a", "b") is called?

Select an item

RealPair{Any} is created as a fallback.

RealPair{String} is created because String is concrete.

TypeError — String violates the T <: Real constraint.

The constructor silently converts the strings to numbers.

Errors and Exception Handling

Question 1. Which error type is raised when an index is out of bounds in an array?

Select an item

BoundsError

IOError

ArgumentError

DivisionByZeroError

Question 2. What does the following code do in Julia?

function divide(a, b)
    if b == 0
        throw(DivideError())
    end
    return a / b
end

Select an item

It raises an ArgumentError when a or b is invalid.

It raises a DivideError when b equals 0.

It throws a BoundsError if a or b are not numbers.

It performs division and returns the result.

Question 3. What happens when the following try/catch block is executed?

try
    println(divide(10, 0))  # Will raise an error
catch e
    println("Error: ", e)  # Handles the error
end

Select an item

The program throws an error and stops execution.

The error is caught and a custom error message is printed.

The program silently ignores the error.

The program prints the result of the division.

Question 4. What is the purpose of the finally block in Julia’s exception handling?

Select an item

To ensure that cleanup code runs regardless of whether an error occurs.

To rethrow any errors that are caught.

To perform the main logic of the program.

To catch all errors and handle them.

Question 5. What is the output of the following code?

function safe_file_read(filename::String)
    file = nothing
    try
        file = open(filename, "r")
        data = read(file, String)
        return data
    catch e
        println("An error occurred: ", e)
    finally
        if file !== nothing
            close(file)
            println("File closed.")
        end
    end
end

# Test with a valid file
println(safe_file_read("example.txt"))

# Test with an invalid file
println(safe_file_read("nonexistent.txt"))

Select an item

The program prints data from the file and closes it.

The program raises an error and does not close the file.

The program prints the error but skips file closing.

The program tries to read a file, catches errors, and always closes the file.

Question 6. Which of the following is an appropriate use case for the finally block?

Select an item

To catch all exceptions without handling them.

To prevent specific types of errors from being raised.

To handle errors and return a value from the finally block.

Ensuring a file is closed after reading, regardless of errors.

Question 7. What happens when try is used with finally but without catch?

try
    error("oops")
finally
    println("cleanup")
end

Select an item

The finally block is skipped because there is no catch.

cleanup is printed and then the error propagates normally.

The error is silently ignored because finally handled it.

cleanup is printed and then execution continues normally.

Question 8. What type of error is thrown by sqrt(-1.0) in Julia?

Select an item

ArgumentError — the argument type is incorrect.

MethodError — no sqrt method exists for negative numbers.

DomainError — the argument is outside the valid domain.

InexactError — the result cannot be represented exactly.

Performance

Question 1. What does it mean for a function in Julia to be type stable?

Select an item

It always avoids recursion.

It always returns an Int64.

It never allocates memory.

The return type can be predicted at compile time from the input types.

Question 2. Which Julia macro is commonly used to check for type stability?

Select an item

@code_warntype

@inbounds

@time

@show

Question 3. Which of the following best describes a type-unstable function?

Select an item

A function that runs slower than expected.

A function that returns multiple values.

A function where the compiler cannot infer a concrete return type.

A function that allocates memory unnecessarily.

Question 4. Consider the function:

function g(x)
    return x > 10 ? 10 : "small"
end

Select an item

The function is type unstable.

The function is recursive.

The function will always error.

The function is type stable.

Question 5. In Julia, which type causes the biggest problems for type inference when used as a return type?

Select an item

Float64

Int64

Any

Bool

Question 6. Which of the following is volatile (non permanent) memory?

Select an item

Flash drive.

SSD.

Hard disk.

RAM.

Question 7. Which component temporarily stores instructions and data for quick access by the CPU?

Select an item

GPU.

ROM.

Hard disk.

Cache.

Question 8. The basic unit of data in computer hardware is:

Select an item

Bit.

Nibble.

Word.

Byte.

Question 9. Consider two functions below. Which one is type-stable when called with an Int argument?

function f1(x)
    return x > 0 ? x : 0.0
end

function f2(x)
    return x > 0 ? x : zero(x)
end

Select an item

Both are type-stable since they return a number.

f1 — returning 0.0 ensures a consistent Float64 output.

Neither is type-stable because they use a conditional.

f2 — zero(x) preserves the type of x, so the return type is always the same.

Question 10. A function returns Union{Int, Float64} depending on its input value. What is the main performance consequence?

Select an item

The function is automatically rewritten by the compiler to return Float64.

There is no consequence; Julia handles Union types efficiently.

The compiler cannot specialize the caller's code, causing dynamic dispatch overhead.

The function runs twice as fast because it handles two types.

Functions

Question 1. Which of the following is the correct syntax for a keyword argument with a default value?

Select an item

function f(x; n=10)

function f(x, n::default=10)

function f(x; n::required)

function f(x, n=10)

Question 2. What is the output of the following code?

function greet(name; greeting="Hello")
    println("$greeting, $name!")
end

greet("Alice")
greet("Bob", greeting="Hi")

Select an item

Error — keyword arguments cannot have default values.

Hi, Alice! then Hi, Bob!

Hello, Alice! then Hi, Bob!

Hello, Alice! then Hello, Bob!

Question 3. By convention, what does a trailing ! in a Julia function name indicate?

Select an item

The function modifies (mutates) one or more of its arguments.

The function may throw an exception.

The function returns a boolean value.

The function is defined in a module.

Question 4. What is the output of the following code?

function sum_all(args...)
    total = 0
    for x in args
        total += x
    end
    return total
end

println(sum_all(1, 2, 3))
println(sum_all(10))

Select an item

Error — variadic functions cannot have zero extra arguments.

6 then 0

6 then 10

1 then 10

Question 5. What is the output of the following code?

function double(x)
    x * 2
end

println(double(5))
println(double("hi"))

Select an item

10 then error — * is not defined for strings.

10 then "hihi" — the last expression is the implicit return value.

nothing then nothing — no explicit return means nothing is returned.

10 then "hi" — strings ignore the multiplier.

Question 6. What is the output of the following code?

v = [3, 1, 2]
sort(v)
println(v)
sort!(v)
println(v)

Select an item

[3, 1, 2] then [3, 1, 2] — neither modifies the original.

[1, 2, 3] then [1, 2, 3] — both sort in place.

[3, 1, 2] then [1, 2, 3] — sort returns a new array; sort! mutates in place.

Error — sort! requires a different argument type.

Question 7. What is the output of the following code?

f(x) = x^2
v = [1, 2, 3, 4]
println(f.(v))

Select an item

[1, 2, 3, 4] — broadcasting does not change the values.

Error — broadcasting syntax . requires the function to accept arrays.

[1, 4, 9, 16] — broadcasting applies f element-wise.

16 — the function is applied to the entire array.

Question 8. Three methods are defined for describe. Which method is called by describe(3.14)?

describe(x::Int)     = println("integer: ", x)
describe(x::Float64) = println("float: ", x)
describe(x)          = println("other: ", x)

describe(3.14)
describe(42)
describe("hello")

Select an item

Error — multiple methods with the same name are not allowed.

float: 3.14, float: 42, other: hello — all numbers use the float method.

other: 3.14, other: 42, other: hello — the fallback method is always called.

float: 3.14, integer: 42, other: hello — Julia dispatches on the most specific matching method.

Data Structures

Question 1. How do you create a Dict mapping "a" to 1 and "b" to 2 in Julia?

Select an item

Dict["a" = 1, "b" = 2]

{"a": 1, "b": 2}

Dict("a" => 1, "b" => 2)

HashMap("a", 1, "b", 2)

Question 2. What is the output of the following code?

d = Dict("x" => 10, "y" => 20)
d["z"] = 30
println(length(d))
println(get(d, "w", -1))

Select an item

3 then 0 — get returns 0 for missing numeric keys.

2 then -1 — d["z"] = 30 fails because the key doesn't exist.

3 then -1 — the dict has 3 entries; get returns the default for missing keys.

3 then error — accessing a missing key throws a KeyError.

Question 3. What is the difference between v[2:4] and @view v[2:4]?

Select an item

@view is only valid for matrices, not vectors.

Both create a copy; @view is just syntax sugar.

v[2:4] creates a view; @view v[2:4] creates a copy.

v[2:4] creates a copy of the slice; @view v[2:4] creates a view that shares memory with v.

Question 4. What is the output of the following code?

A = [1 2; 3 4]
B = [5 6; 7 8]
println(A * B)
println(A .* B)

Select an item

Error — matrix operations require the LinearAlgebra package.

[5 12; 21 32] then [19 22; 43 50] — the operators are swapped.

[19 22; 43 50] then [5 12; 21 32] — * is matrix multiplication; .* is element-wise.

[19 22; 43 50] then [19 22; 43 50] — both operators perform matrix multiplication.

Question 5. What does the \\ operator do when applied to a matrix A and vector b?

Select an item

It solves the linear system Ax = b for x.

It performs element-wise division of A by b.

It computes the matrix inverse of A.

It returns the dot product of A and b.

Question 6. What is the output of the following code?

A = [2.0 1.0; 1.0 3.0]
b = [5.0, 10.0]
x = A \ b
println(round.(x, digits=4))

Select an item

[1.0, 3.0] — the solution to the 2×2 linear system.

[2.5, 3.33] — the element-wise division result.

[5.0, 10.0] — the right-hand side is returned unchanged.

Error — \ requires an integer matrix.

Question 7. What is the output of the following code?

d = Dict("score" => 0)

function update!(d, key, val)
    d[key] = val
end

update!(d, "score", 42)
println(d["score"])

Select an item

0 — only the ! convention guarantees in-place mutation.

0 — the function receives a copy of the dict.

42 — Dict is passed by reference; the function mutates the original.

Error — you cannot pass a Dict to a function.

Question 8. What is the output of the following code?

v = [10, 20, 30, 40, 50]
w = v[2:4]
w[1] = 999
println(v[2])

Select an item

30 — Julia shifts the index by one.

Error — you cannot assign to a slice.

999 — slicing creates a view; modifying w also modifies v.

20 — v[2:4] creates a copy; modifying w does not affect v.

Composite Types

Question 1. What is the key difference between struct and mutable struct in Julia?

Select an item

Fields of a struct cannot be changed after creation; fields of a mutable struct can.

struct allows inheritance; mutable struct does not.

Both are identical; mutable is just a naming convention.

mutable struct is faster because it avoids type checks.

Question 2. What is the output of the following code?

struct Point
    x::Float64
    y::Float64
end

p = Point(3.0, 4.0)
println(p.x)
println(fieldnames(Point))

Select an item

Error — fieldnames is not defined for user-defined structs.

3.0 then (:x, :y) — field access uses .; fieldnames returns a tuple of symbols.

3.0 then ["x", "y"] — fieldnames returns a vector of strings.

3.0 then (x, y) — fieldnames returns a tuple of variable names.

Question 3. What happens when you try to modify a field of an immutable struct?

struct Circle
    radius::Float64
end

c = Circle(5.0)
c.radius = 10.0

Select an item

The field is updated silently.

A new Circle is created with the updated radius.

An error is thrown — fields of immutable structs cannot be reassigned.

A warning is shown but execution continues.

Question 4. What is the output of the following code?

mutable struct Counter
    count::Int
end

c = Counter(0)
c.count += 1
c.count += 1
println(c.count)

Select an item

0 — the struct is copied on assignment.

Error — += is not defined for struct fields.

1 — only the last assignment is kept.

2 — mutable struct allows field modification.

Question 5. What is the output of the following code?

struct LinearTransform
    slope::Float64
    intercept::Float64
end

(lt::LinearTransform)(x) = lt.slope * x + lt.intercept

lt = LinearTransform(2.0, 3.0)
println(lt(5))

Select an item

Error — structs cannot be used as functions.

13.0 — the struct is called like a function: 2.0 * 5 + 3.0.

13 as Int — integer inputs produce integer outputs.

10.0 — only the slope is applied.

Question 6. An inner constructor is defined below. What happens when SafeValue(-5) is called?

struct SafeValue
    value::Float64
    function SafeValue(v)
        v < 0 && error("Value must be non-negative")
        new(v)
    end
end

SafeValue(-5)

Select an item

A warning is displayed but the struct is created.

An error is thrown: "Value must be non-negative".

SafeValue(-5.0) is created silently.

SafeValue(0.0) is created — negative values are clamped to 0.

Question 7. What does fieldnames(Point) return for struct Point; x::Float64; y::Float64; end?

Select an item

["x", "y"] — a vector of strings.

(Float64, Float64) — a tuple of field types.

(:x, :y) — a tuple of symbols.

2 — the number of fields.

Question 8. What is the output of the following code?

struct Box{T}
    value::T
end

b1 = Box(42)
b2 = Box(3.14)
println(typeof(b1))
println(typeof(b2))
println(Box{Int} <: Box{Real})

Select an item

Box{Any}, Box{Any}, true — all Box types collapse to Box{Any}.

Box{Int64}, Box{Float64}, true — because Int64 <: Real.

Box{Int64}, Box{Float64}, false — parametric structs are invariant; Box{Int} is NOT a subtype of Box{Real}.

Error — parametric structs require explicit type parameters.

Scoping, Closures and Modules

Question 1. What is the output of the following code?

x = 10

function f()
    x = 20
    println(x)
end

f()
println(x)

Select an item

20 then 20 — f modifies the global x.

20 then 10 — x inside f is a local variable; the global x is unchanged.

10 then 10 — f reads the global x and prints it.

Error — you cannot shadow a global variable inside a function.

Question 2. What is the output of the following code?

function make_adder(n)
    return x -> x + n
end

add5 = make_adder(5)
println(add5(3))
println(add5(10))

Select an item

5 then 5 — the closure always returns n.

3 then 10 — n is not captured; the closure returns the input unchanged.

8 then 15 — add5 is a closure that captures n = 5.

Error — closures cannot capture variables from the enclosing scope.

Question 3. What is the output of the following code?

function make_counter()
    count = 0
    increment! = () -> (count += 1; count)
    return increment!
end

counter = make_counter()
println(counter())
println(counter())
println(counter())

Select an item

1 then 2 then 3 — the closure mutates the captured variable count.

1 then 1 then 1 — each call creates a fresh count = 0.

0 then 1 then 2 — the count starts at 0 and increments after printing.

Error — closures cannot modify captured variables.

Question 4. What does the export keyword do inside a module?

Select an item

It copies the module's functions into the global namespace permanently.

It restricts access to the listed names from outside the module.

It makes the listed names available without module-prefix qualification when using using.

It exports the module to a separate .jl file.

Question 5. What is the output of the following code?

module MyMath
    export square
    square(x) = x^2
    cube(x) = x^3
end

using .MyMath
println(square(4))
println(MyMath.cube(3))

Select an item

16 then 27 — all module functions are accessible without a prefix.

Error — using .MyMath only works if MyMath is in a separate file.

16 then 27 — square is exported so it can be used directly; cube requires the module prefix.

16 then error — cube is not accessible because it wasn't exported.

Question 6. What is the output of the following code?

x = 1

for i in 1:3
    x = x + i
end

println(x)

Select an item

7 — for loops in the REPL/global scope can read and modify outer variables.

6 — only the loop body sum 1+2+3 is computed.

Error — x is not defined inside the for loop scope.

1 — the loop variable x is local and does not affect the outer x.