Tricky concepts in Julia for beginners (and how to overcome them)

Avoid common pitfalls new Julia users make

Image by Author

Learning any new programming language is not easy. But it also doesn’t need to be unnecessarily hard. This article will point out a few common pitfalls new Julia users should avoid when getting started.

If you aren’t quite sure of the benefits Julia provides for new developers, I suggest you check out this article to learn more:

Why you should learn Julia, as a beginner / first-time programmer

Edit: My Co-author and I are thrilled to share that pre-orders our new book, Julia Crash Course, are now live:

Julia Crash Course (eBook Pre-order)

1-based indexing 🥇

From birth, humans are taught to count starting with 1. Then, sometime later in life when studying computer science, someone shows up and says we are going to start counting from zero. If that does not make you scratch your head for a second then I envy you. Regardless, Julia is a 1-based indexing language which means to index the first item, we start with 1 instead of 0.

julia> a = "Hello world"
"Hello world"
julia> a[1]
'H': ASCII/Unicode U+0048 (category Lu: Letter, uppercase)
julia> a[0]
ERROR: BoundsError: attempt to access 11-codeunit String at index [0]
Stacktrace:
[1] checkbounds
@ ./strings/basic.jl:216 [inlined]
[2] codeunit
@ ./strings/string.jl:104 [inlined]
[3] getindex(s::String, i::Int64)
@ Base ./strings/string.jl:225
[4] top-level scope
@ REPL[32]:1

There isn’t much more to say on this other than to remind yourself that indexing starts with 1. It’s worth noting that if this is a deal breaker for you, there is a package called OffsetArrays.jl which allows you to write Julia code with 0-based indexing (or any arbitrary indexing actually): https://github.com/JuliaArrays/OffsetArrays.jl

String concatenation with 🌟

If you are coming from Python, you are probably used to doing "Hello" + "World" to concatenate a string. In Julia, we use the * instead of a + which looks like "Hello" * "World". I still regularly do this by accident since despite how much I enjoy using Julia, I am a regular Python user.

julia> "Hello" + "World"
ERROR: MethodError: no method matching +(::String, ::String)
Closest candidates are:
+(::Any, ::Any, ::Any, ::Any...) at operators.jl:591
Stacktrace:
[1] top-level scope
@ REPL[33]:1

Again, if you try to do this, you will get an error like the following. While it is not advised to do this, you can define a + function manually if this is too much of an annoyance to deal with (again, this could lead to issues so it’s best to avoid this approach).

Julia Co-creator Stefan Karpinski said back in 2013 that this operation was one of things he was least comfortable with. Though a lot has likely changes in his perspective over the last close to 10 years. Do check out the initial discussion for yourself:

More string concatenation operations? · Issue #1771 · JuliaLang/julia

It’s worth noting that this might have unintended consequences and I am simply showing this for example’s sake:

julia> import Base.+ #Import base.+ so that we can add a new implementation
julia> function +(a::String, b::String)
          return a*b
        end
+ (generic function with 207 methods)
julia> "Hello" + "World"
"HelloWorld"

Defining a string with a single quote 🗯

Another common misstep if you are coming from Python is to try and define a string using a single quotation mark.

julia> 'hello'
ERROR: syntax: character literal contains multiple characters
Stacktrace:
[1] top-level scope
@ none:1

In Julia, this behavior will not work, you need to use double quotes as a single quote is used exclusively for an individual character.

"This is a valid Julia string"
#vs
'This is NOT a valid string'

I also wanted to make sure that anyone who does this has an answer handy if they decide to search this online so I went ahead and documented it on Stack Overflow: https://stackoverflow.com/questions/73712773/syntax-character-literal-contains-multiple-characters-in-julia/73712775#73712775

Looping Through Dictionaries 🔁📖

If you have programmed in Python before, you will be familiar with the dictionary looping syntax:

for key,value in dictionary
    print(key, value)

In Julia, you are required to add parenthesis around the key and value pair as follows:

julia> for key,value in my_dictionary
ERROR: syntax: invalid iteration specification
Stacktrace:
[1] top-level scope
@ none:1

If you leave out the parenthesis, the Julia REPL will not even let you go to the next line, it will automatically error out when you press enter. Here is the correct way to do it:

julia> my_dictionary = Dict("test"=>1, "test2"=>2)
Dict{String, Int64} with 2 entries:
"test2" => 2
"test"  => 1
julia> for (key,value) in my_dictionary
            print(key, value)
       end
test22test1

Note that the syntax to define a dictionary is itself a bit weird but once you get used to using the Dict function, it becomes second nature.

Intermission 🍿

If you have gotten this far and are thinking to yourself, “well maybe Julia isn’t worth trying after all”, this section is for you! If you are finding these tips really valuable and don’t need any extra motivation, feel free to skip this for now but feel free to come back to it later.

Instead of re-stating here what I have already hashed out in other articles, read this one to learn about why Climate Science is a very compelling use case for Julia:

Julia, the little known programming language that might be the key to understanding Climate Change…

If you want to get a sense of the Data Engineering ecosystem being built in Julia, I encourage you to read:

Data Engineering in Julia

Interested in Machine Learning? Want to learn where the ecosystem is heading and why it is going to be dominated by Julia? Read more here:

The Future of Machine Learning and why it looks a lot like Julia 🤖

Are you a data scientist or just someone who has to do data science workflows? This post goes over the ins and outs of the ecosystem:

Why You Should Invest in Julia Now, as a Data Scientist

Now that we have sufficient motivation and context, let’s keep talking about tips to avoid common pitfalls in Julia!

The End keyword 🔚🎬

Every language has its nuance, and one of the more esoteric things about Julia is that you have to end each code block (if statements, loops, functions, etc) with the end keyword. end is essentially like a closing parenthesis in other languages. While it starts out a bit odd to get used to, this behavior is something I have grown to love! When I write Python code now, I tend to actually add comments with the word end so that it becomes more visually clear where each code block begins and ends. Here is the end statement in action:

if a == b
   print("A is equal to B")
end
for item in array
   print(item)
end
function test()
   print("test")
end

In all of these examples, we quite simply end the code block with end. You will likely be nesting the code blocks in one another like this example:

function test(item, item2)
   print("test")
   for new_item in item
     if new_item == item2
        print("We found the item")
     end
     
     print(item)
   end
end

In general, the error messages you get for missing an end statement can be forgiving (though of course, it depends on the context as well):

julia> function test()
          print(test)
ERROR: syntax: incomplete: "function" at REPL[50]:1 requires end
Stacktrace:
[1] top-level scope
@ none:1

Vectors of Booleans 🤨

A rather odd behavior that might not be intuitive is the fact that when you print a vector of booleans, the values show as 0 and 1 instead of true and false.

julia> d = [true, false, true]
3-element Vector{Bool}:
1
0
1

This is something you will just have to deal with as you use vectors (which again are the same as lists or arrays).

For context on why this is the case, check out this issue on GitHub: https://github.com/JuliaLang/julia/issues/30683

Object-Oriented programming (or a lack thereof) 📦

Julia as a language does not employ traditional object-oriented programming methodologies. There are no classes or the like. However, Julia does have structs that operate similarly to classes with a few notable differences. Let’s dive into a basic example of a struct:

julia> mutable struct Dog
           breed::String
           paws::Int
           name::String
           weight::Float64
       end

julia> my_dog = Dog("Australian Shepard", 4, "Indy", 34.0)
dog("Australian Shepard", 4, "Indy", 34.0)

julia> my_dog.name
"Indy"

In this example, we define a struct to represent a dog. In the struct, we define four attributes that make up the dog object. In the lines after that, we show the code to actually create a dog object and then access some of its attributes. Note that you need not specify the types of the attributes, you could leave it more open. For this example, we defined explicit types to highlight that feature.

You will notice that similar to classes in Python (and other languages), we did not define an explicit constructor to create the dog object. We can, however, define one if that would be useful to use:

julia> mutable struct Dog
           breed::String
           paws::Int
           name::String
           weight::Float64
           
           function Dog(breed, name, weight, paws=4)
               new(breed, paws, name, weight)
           end
       end

julia> new_dog = Dog("German Shepard", "Champ", 46)
Dog("German Shepard", 4, "Champ", 46.0)

Here we defined a constructor and used the special keyword new in order to create the object at the end of the function. You can also create getters and setters specifically for the dog object by doing the following:

julia> function get_name(dog_obj::Dog)
           print("The dogs's name is: ", dog_obj.name)
       end
get_name (generic function with 1 method)

julia> get_name(new_dog)
The dogs's name is: Champ

In this example, the get_name function only takes an object of type Dog. If you try to pass in something else, it will error out:

julia> get_name("test")
ERROR: MethodError: no method matching get_name(::String)
Closest candidates are:
  get_name(::Dog) at REPL[61]:1
Stacktrace:
 [1] top-level scope
   @ REPL[63]:1

It is worth noting that we also defined the struct to be mutable initially so that we could change the field values after we created the object. You omit the keyword mutable if you want the objects initial state to persist.

Structs in Julia not only allow us to create object’s, we also are defining a custom type in the process:

julia> typeof(new_dog)
Dog

In general, structs are used heavily across the Julia ecosystem and you can learn more about them in the docs: https://docs.julialang.org/en/v1/base/base/#struct

Closing Out With Additional Resources 👀

Learning the ins and outs of a new language is not always easy, I hope that this article helped bridge the gap for you as you get started using the language. If you run into any technical issues, please post on the Julia Discourse or Stack Overflow:

JuliaLang

I also suggest checking out the learning section of the Julia website for all of our up-to-date resources:

https://julialang.org/learning

Lastly, if you want to see an open discussion by the community around this very topic, check out this post on Discourse:

What are common mistakes in julia that beginners should aware of?

This was the post that inspired me to write about this and share some of these plus my own experience. Happy learning and please do reach out to me if you have any issues!