Skip to content
A walk through the Elixir language in 30 exercises.
Elixir Erlang
Branch: master
Clone or download

Latest commit


Type Name Latest commit message Commit time
Failed to load latest commit information.
support Playing with digests. This was not fun. Jan 8, 2014
.gitignore add *sw[p|o] to gitignore May 24, 2015
01-hello-world.exs Update links in the examples (#9) May 24, 2015
02-unit-testing.exs Update ExUnit documentation link Sep 27, 2018
03-input-output.exs Update links and resolve warnings (#38) Sep 27, 2018
04-list.exs Removing filter_map since it is deprecated Sep 27, 2018
05-map.exs Fix deprecated syntax to remove compilation warnings Sep 27, 2018
06-record.exs Fix deprecated syntax to remove compilation warnings. Add link to Rec… Sep 30, 2018
07-fibonacci.exs Pattern match the whole list Jul 31, 2015
08-process-ring.exs remove unreachable clause Nov 30, 2015
09-ping.exs Fix bugs in 09-ping Nov 28, 2019
10-sudoku-board.exs Use more idiomatic do_foo style for inner funcs. Feb 8, 2014
11-sudoku-solver.exs Fix deprecation in 11-sodoku-solver Nov 28, 2019
12-sudoku-solver-norvig.exs Fix deprecations in 12-sodoku-solver-norvig Nov 28, 2019
14-spades.exs Fix the problem of quiting game Apr 25, 2016
15-quine.exs Catching up elixir v1.0 Jan 1, 2015
16-euler-tree.exs Fix indent Oct 31, 2015
17-dining-philosophers.exs Catching up elixir v1.0 Jan 1, 2015
18-gen_server.exs Catching up elixir v1.0 - for 18-20 Jan 6, 2015
19-supervisor.exs Catching up elixir v1.0 - for 18-20 Jan 6, 2015
20-inets.exs Catching up elixir v1.0 - for 18-20 Jan 6, 2015
21-wiki.exs Catching up elixir v1.0 - for 21, 22, 24, 26 Jan 7, 2015
23-digest.exs Fix instructions. May 3, 2014
24-stream.exs Catching up elixir v1.0 - for 21, 22, 24, 26 Jan 7, 2015
25-set.exs Ugg, not in love with all this Enum.into stuff. May 3, 2014
26-frank.exs Catching up elixir v1.0 - for 21, 22, 24, 26 Jan 7, 2015
29-vector.exs Catching up elixir v1.0 - for 27, 28, 29, 30 Jan 9, 2015
30-vector.exs Catching up elixir v1.0 - for 27, 28, 29, 30 Jan 9, 2015
LICENSE Initial commit Dec 10, 2013 Fix link Oct 21, 2017

30 Days of Elixir

A walk through the Elixir language, one exercise per day for 30 days.

Frequently Asked Question:

How am I supposed to use this?

I'm not sure! I originally wrote these exercises as I was learning the language myself. I don't know if merely reading them will be of much use though. I recommend you open each file in your favorite editor, change it, break it, rewrite the code in your own style, etc. Experiment, and if you find a mistake, then bonus points for you!

You have to start somewhere.

01-hello-world.exs - We start at the very beginning: our first message to the world!

02-unit-testing.exs - We'll need unit testing for the rest of the exercises, so let's do this! The built-in unit testing library ExUnit is capable and easy-to-use.

03-input-output.exs - Here we learn that file input and user input are easy. José has even done us a solid and duplicated some familiar Path and File methods from Ruby.

04-list.exs - What's a functional language without a List? Here we learn some simple list manipulation, and for awhile we can pretend lists are like our familiar Ruby arrays. :-)

05-map.exs - Maps are the go-to key-value structure in Elixir, and the syntax is fairly simple coming from other dynamic languages.

06-record.exs - Where are our beloved objects? In functional programming, data is just data, and Elixir gives you the Record structure to organize it a bit. Records are a little like Struct from other imperative languages, except of course they are immutable!

07-fibonacci.exs - You learn recursion by using recursion! We learn about multiple methods of the same name, pattern matching, and guard clauses, cool! Finally we do it all over again, backwards! (Hey, why not?)

Learning is a Process.

08-process-ring.exs - Sometimes a contrived example is the best way to focus on the technology. For now, let's just send messages around in a ring and see how this Process thing works.

09-ping.exs - Now let's build something useful! Wow, it's easy to launch as many processes as you have increments of work. When the work is finished, send a message back to the parent and he'll assemble the results. Cool!

So, do you Sudoku?

10-sudoku-board.exs - No objects? Pshaaw! Who needs 'em - let's use simple lists to represent our Sudoku board. Easy!

11-sudoku-solver.exs - Epic fail. Our code is pretty, but the algorithm is naive and too slow to use on a full-size board.

12-sudoku-solver-norvig.exs - Time to bring out the big guns! Here we port Peter Norvig's Holy Grail of a Solver over to Elixir. We learn how to change imperative operations on mutable state to functional ones on immutable data. This solver is freakin' fast!

Spades, cuz they look like little shovels!

13-card-deck.exs - Let's see how we might represent a deck of cards. Easy, a list of tuples! We'll also build a higher-order function to deal out the cards to players.

14-spades.exs - They're aliiiiive! Processes connect to one another and send messages, across terminal windows, machines, even teh intarwebs! Let's put this to good use and build a multi-player game of Spades. Ace of Spades FTW!

Tease your brain, but don't be a bully.

15-quine.exs - A quine is a program that prints its own source code. Let's build the smallest one we can using Elixir... sigils help a lot!

16-euler-tree.exs - Project Euler problem 67 is a fun puzzle; let's solve it with a functional language! We'll make extensive use of list comprehensions in this one.

17-dining-philosophers.exs - Pass the fork! The actor model makes certain problems a lot easier to reason about, and feeding some philosophers is one of them.

OTP, hey you know me!

18-gen_server.exs - Here we move up a level and build a Prime Factors server using OTP GenServer behaviour.

19-supervisor.exs - This one is simple: when our Prime Factors server craps out, restart it. Easy!

Let's build a web...

20-inets.exs - Erlang's built-in inets library is nothing to be amazed by, but it gets the job done. We'll simply announce ourselves to the world again, this time via HTTP.

21-wiki.exs - Now let's build something useful, combining our knowledge of inets and some simple File IO to build a wiki web server.

22-socket-server.exs - "I don't always build web apps, but when I do, I use low-level sockets and parse the HTTP headers myself," said no one, ever. Turns out gen_tcp is pretty easy to use if you want to handle socket communication.

What's this doing here?

23-digest.exs - Erlang/OTP has so many things to offer, yet simple hexdigest using sha1 isn't one of 'em. At least we get to learn one way to import external Erlang code and run it in Elixir, so not all is lost.

24-stream.exs - Let's build a better Fibonacci method using lazy streams. You can tell our understanding of the language has improved, as the amount of code to implement this is 1/10th of the size of our first foray into Fibonacci!

25-set.exs - We'll learn about the built-in HashSet library, just for fun.

The Rat Pack didn't have Macros.

26-frank.exs - Here we'll make a brief incursion into the land of macros. In this exercise, we'll build a web DSL with custom syntax. This first try we'll just use a macro to write a method. quote/unquote confounds a bit.

27-frank-2.exs - This version of Frank is only a little better, but lets our path matches contain any character and utilizes pattern matching to grab the right handler method. But here we're still struggling with quote/unquote et al. What does it all mean?

28-frank-3.exs - Macros are starting to make a little more sense now. The final version of Frank can handle patterns in the URL, e.g. /foo/:id and our macro code got simpler!

You'll never learn if you don't Trie.

29-vector.exs - For our last couple of exercises, let's do something completely different! Elixir has a list data structure, but no Vector, so let's create one... our first attempt has us learning about Hash Array Mapped Trie (HAMT), and as it turns out, using this structure for a vector wasn't the best idea.

30-vector.exs - Take 2... Thanks to Jean Niklas L'orange's excellent articles about Clojure's Vectors, we learn how to build a Bit Partitioned Vector Trie. And now, we have a Vector with constant-time access. Cool stuff!

Copyright & License

Copyright (c) Tim Morgan

Licensed under MIT, see LICENSE file.

You can’t perform that action at this time.