5 Julia Projects for Beginners — Easy Ideas to Get Started Coding in Julia

Image by Author

Julia is used for a lot of really impactful and interesting challenges like Machine Learning and Data Science. But before you can get to the complex stuff, it is worth exploring the basics to develop a solid foundation. In this tutorial, we will go over some of the basics of Julia by building 5 small Julia projects:

• Mad Libs ✍️
• Guess the Number Game 💯
• Computer Number Guesser 🤖
• Rock 🗿, Paper 📃, Scissors ✂️
• Password Generator 🎫

If you have not downloaded Julia yet, head to: https://julialang.org/downloads/ or watch this video:

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)

Mad Libs ✍️

In Mad Libs, the user is prompted to enter different types of words. The random words the user enters are then inserted into a sentence. This leads to some pretty wacky and funny outcomes. Let us try to program a simple version of this using Julia.

At the core of this problem, we want to concatenate (or add together) multiple strings so that we go from a sentence with some placeholders, to a sentence with the user input. The simplest way to achieve this in Julia is with String Interpolation:

julia> name = "Logan"
"Logan"
julia> new_string = "Hello, my name is $name"
"Hello, my name is Logan"

Here we can see that the name variable we defined can be inserted into the string by using the $name syntax.

There are a bunch of other ways to do this, like using the string function:

julia> new_string = string("Hello, my name is ", name)
"Hello, my name is Logan"

but string interpolation seems the most straightforward and readable in this case.

Now that we know how we are going to set up the strings, we now need to prompt the user for their input. To do this, we can use the readline function as follows:

julia> my_name = readline()
Logan
"Logan"

The readline function takes a single line of input from the user, this is exactly what we will want to use. Let’s put it all together into a simple example:

In this example, we got exposure to working with strings, defining a function, print statements, and more! As noted before, there are lots of other ways to do the same things we did above, if you want to find out more about working with strings, check out the Julia docs: https://docs.julialang.org/en/v1/manual/strings/

Guess the Number Game 💯

In this game, we will have to generate a random number and then try to guess what it is. To begin, we will need to generate a random number. As always, there are many ways to do something like this but the most straightforward approach is to do:

julia> rand(1:10)
4

The rand function takes as input the range of numbers you want to use as the bounds for the number you will generate. In this case, we set the range as 1-10 inclusive of both numbers.

The other new topic we need to cover for this example to work is while loops. The basic structure of a while loop is:

while some_condition is true
   do something
end

This loop will continue to iterate until the condition for the while loop is no longer met. You will see how we use this soon to keep prompting the user to enter a number until they guess it right.

Lastly, to make it a little easier for us, we are going to add an if statement which tells us if we guess a number that is close to the target number. The structure of an if statement in Julia is:

if some_condition is true
   do something
end

The big difference is that the if statement is checked once and then it is done. The initial condition is not re-checked unless the if statement is in a loop.

Now that we have the basic ideas down, let us see the actual code to build the number guesser. I implore you to try this on your own before checking the solution below. Happy coding! 🎉

Computer Number Guesser 🤖

Now that we have seen what it looks like for us to try and guess what the computer randomly generated, let us see if the computer can do any better than us. In this game, we will select a number and then see how long it takes the computer to guess that number. To do this, we will introduce some new concepts like the Random module and for loops.

Let us begin by thinking about how we can have the computer guess random numbers without repeating any. One simple solution is to use the rand function but the issue is that there’s no built-in way to make sure the computer doesn’t guess the same number more than once, since after all, it is random!

We can solve this issue by combining the collect function and the shuffle function. We begin by defining a random seed:

julia> rng = MersenneTwister(1234);

Random seeds make it so that random number generators make reproducible results. Next, we need to define all possible guesses:

julia> a = collect(1:50)
50-element Vector{Int64}:
1
2
3
⋮

We now need to use the shuffle function to make the guesses random:

julia> using Random
julia> shuffle(rng, a)
50-element Vector{Int64}:
41
23
13
49
⋮

Now that we have the random guesses setup, it is time to loop through them one at a time and see if the number is equal to the target the user inputted. Again, give this a try before you check out the solution below:

Rock 🗿, Paper 📃, Scissors ✂️

If you have never played rock, paper, scissors, you are missing out! The basic gist is you try to beat your opponent with either rock, paper, or scissors. In this game, rock beats scissors, scissors beat paper, and paper beats rock. If two people do the same one, you go again.

In this example, we will be playing rock, paper, scissors against the computer. We will also use the sleep function to introduce a short delay as if someone was saying the words out loud (which you would do if you played in person).

The sleep function takes in a number that represents how long you want (in seconds) to sleep. We can use this with a function or a loop to slow things down as you will see in this game.

sleep(1) # Sleep for 1 second

Let us also explore a function I found while writing this tutorial, Base.prompt , which helps us do what we were previously using readline for. In this case , however, prompt auto appends a : to the end of the line and allows us to avoid having two separate lines for the print and user input:

human_move = Base.prompt("Please enter 🗿, 📃, or ✂️")

We will also need to use an elseif to make this example game work. We can chain if , elseif , and else together for completeness. Try putting together the if conditionals, prompts, and sleeps to get the desired behavior, and then check out the code below:

Video captured by Author

Password Generator 🎫

WARNING: Do not use this code to generate real passwords!

In the age of endless data breaches and people using the same password for every website, having a secure password is important. In this example, we will generate an arbitrary number of passwords with a variable length. Given that this could take a long time, we will also add an external package, ProgressBars.jl: https://github.com/cloud-oak/ProgressBars.jl to visually show the progress of our for loop. If you have never added an external package before, consider checking out this robust tutorial:

The most underrated feature of the Julia Programming Language 👀, the package manager 📦

To add a Julia package, open the REPL and type ] followed by add ProgressBars . After that, as we did with the Random module (note we did not need to add it since it is part of base Julia), we can say using ProgressBars to load it in.

The main new idea we will introduce here is vectors / arrays. In Julia, we can put any type into an array. To create an empty array, we do:

password_holder = []

and then to add something, we use the push! function as you will see in the below example. As mentioned before, we will use the ProgressBars package to show progress on the screen. Note that Julia is so quick that it likely won’t show you the loading screen unless you manually slow things down with a sleep function call or a high number of passwords. Check out the README for an example of using this in practice. As with the other example, try to put some code together before you dissect the example below:

Wrapping up 🎁

I hope you had as much fun working with and reading about these projects as I did. If you want to make your own version of this post and make some small Julia projects and share them with the world, please do so and open a PR here: https://github.com/logankilpatrick/10-Julia-Projects-for-Beginners I can easily change the repo name to accommodate an influx of small projects.

I will also note that an exercise like this is also a great way to potentially contribute to Julia. While I was working on this post, I was able to open 2 PR’s to base Julia which I think will help improve the developer experience: https://github.com/JuliaLang/julia/pull/43635 and https://github.com/JuliaLang/julia/pull/43640.

If you enjoyed this tutorial, let’s connect on Twitter: https://twitter.com/OfficialLoganK