diff --git a/_config.yml b/_config.yml
index 18d7dd5ab..78201b070 100644
--- a/_config.yml
+++ b/_config.yml
@@ -1,3 +1,5 @@
 markdown: redcarpet
 pygments: true
 permalink: /blog/:year/:month/:day/:title
+redcarpet:
+  extensions: ['with_toc_data']
diff --git a/_includes/bottom.html b/_includes/bottom.html
index cf7a187ee..ad4721366 100644
--- a/_includes/bottom.html
+++ b/_includes/bottom.html
@@ -4,7 +4,7 @@
       </div>
 
       <div id="copyright">
-        © 2012-2013 <a href="http://plataformatec.com.br/" target="_blank">Plataformatec</a>. All rights reserved.
+        © 2012-2014 <a href="http://plataformatec.com.br/" target="_blank">Plataformatec</a>. All rights reserved.
       </p>
     </div><!-- .wrap -->
   </div><!-- #container -->
@@ -21,4 +21,4 @@
     })();
   </script>
 </body>
-</html>
\ No newline at end of file
+</html>
diff --git a/_includes/important-links.html b/_includes/important-links.html
index ed9f35a05..5622ba913 100644
--- a/_includes/important-links.html
+++ b/_includes/important-links.html
@@ -1,7 +1,7 @@
 <div class="widget">
   <h3 class="widget-title">Join the Community</h3>
   <ul>
-    <li>#elixir-lang on freenode IRC</li>
+    <li><a class="spec" href="irc://irc.freenode.net/elixir-lang">#elixir-lang on freenode IRC</a></li>
     <li><a class="spec" href="http://groups.google.com/group/elixir-lang-talk" target="_blank">elixir-talk mailing list (questions)</a></li>
     <li><a class="spec" href="http://groups.google.com/group/elixir-lang-core" target="_blank">elixir-core mailing list (development)</a></li>
     <li><a class="spec" href="https://github.com/elixir-lang/elixir/issues" target="_blank">Issues tracker</a></li>
@@ -25,7 +25,8 @@ <h3 class="widget-title">Code editor support</h3>
     <li><a class="spec" href="https://github.com/elixir-lang/emacs-elixir" target="_blank">Emacs Mode</a></li>
     <li><a class="spec" href="https://github.com/elixir-lang/elixir-tmbundle" target="_blank">Textmate Bundle</a></li>
     <li><a class="spec" href="https://github.com/elixir-lang/vim-elixir" target="_blank">Vim Elixir</a></li>
+    <li><a class="spec" href="https://github.com/SteffenBauer/elixir-gtksourceview" target="_blank">GtkSourceView (gedit)</a></li>
   </ul>
 </div>
 
-{% include sponsors.html %}
\ No newline at end of file
+{% include sponsors.html %}
diff --git a/_includes/learning-resources.html b/_includes/learning-resources.html
index 17e8d55f7..a30c82f1f 100644
--- a/_includes/learning-resources.html
+++ b/_includes/learning-resources.html
@@ -2,7 +2,7 @@
   <h3 class="widget-title">Learning resources</h3>
   <ul>
     <li class="image"><a href="http://pragprog.com/titles/elixir" target="_blank" title="Programming Elixir cover"><img src="http://imagery.pragprog.com/products/361/elixir_xlargebeta.jpg?1368724397" /></a></li>
-    <li class="image"><a href="https://peepcode.com/products/elixir" target="_blank" title="PeepCode Meet Elixir cover"><img src="https://peepcode.com/system/uploads/2013/peepcode-elixir-lang-cover.jpg" width="190" height="228" /></a></li>
     <li class="image"><a href="http://elixirsips.com" target="_blank" title="ElixirSips cover"><img src="http://elixirsips.com/images/ElixirLangAd2_190x160.png" width="190" height="160" /></a></li>
+    <li class="image"><a href="http://manning.com/juric/" target="_blank" title="Elixir in Action"><img src="http://manning.com/juric/juric_cover150.jpg" width="190" height="238" /></a></li>
   </ul>
 </div>
diff --git a/_includes/search.html b/_includes/search.html
index 494a341ae..de4b10526 100644
--- a/_includes/search.html
+++ b/_includes/search.html
@@ -1,6 +1,6 @@
 <div class="widget news">
   <h3>
-    News: <a href="/blog/2013/11/05/elixir-v0-11-0-released/">Elixir v0.11.0 released</a>
+    News: <a href="/blog/2014/04/21/elixir-v0-13-0-released/">Elixir v0.13.0 released, hex.pm and ElixirConf announced</a>
   </h3>
 </div>
 
diff --git a/_includes/top.html b/_includes/top.html
index ba54713b1..26d5a7114 100644
--- a/_includes/top.html
+++ b/_includes/top.html
@@ -32,7 +32,7 @@ <h1 id="site-title">
             <li class="menu-item docs"><a class="spec" href="/docs.html">Docs</a></li>
             <li class="menu-item blog"><a class="spec" href="/blog">Blog</a></li>
             <li class="menu-item source"><a class="spec" href="https://github.com/elixir-lang/elixir" target="_blank">Source</a></li>
-            <li class="menu-item packages"><a class="spec" href="http://expm.co/" target="_blank">Packages</a></li>
+            <li class="menu-item packages"><a class="spec" href="http://hex.pm/" target="_blank">Packages</a></li>
 
           </ul>
         </div>
diff --git a/_layouts/getting_started.html b/_layouts/getting_started.html
index 11647d40a..71d3d304e 100644
--- a/_layouts/getting_started.html
+++ b/_layouts/getting_started.html
@@ -10,13 +10,26 @@
   <div class="widget">
     <h3 class="widget-title">Index</h3>
     <ol>
-      <li><a class="spec" href="/getting_started/1.html">Introduction</a></li>
-      <li><a class="spec" href="/getting_started/2.html">Diving in</a></li>
-      <li><a class="spec" href="/getting_started/3.html">Modules</a></li>
-      <li><a class="spec" href="/getting_started/4.html">Records, Protocols &amp; Exceptions</a></li>
-      <li><a class="spec" href="/getting_started/5.html">Macros</a></li>
-      <li><a class="spec" href="/getting_started/6.html">Other topics</a></li>
-      <li><a class="spec" href="/getting_started/7.html">Where to go next</a></li>
+      <li><a class="spec" href="/getting_started/1.html">Interactive Elixir (IEx)</a></li>
+      <li><a class="spec" href="/getting_started/2.html">Basic types</a></li>
+      <li><a class="spec" href="/getting_started/3.html">Basic operators</a></li>
+      <li><a class="spec" href="/getting_started/4.html">Pattern matching</a></li>
+      <li><a class="spec" href="/getting_started/5.html">case, cond and if</a></li>
+      <li><a class="spec" href="/getting_started/6.html">Binaries, strings and char lists</a></li>
+      <li><a class="spec" href="/getting_started/7.html">Keywords, maps and dicts</a></li>
+      <li><a class="spec" href="/getting_started/8.html">Modules</a></li>
+      <li><a class="spec" href="/getting_started/9.html">Recursion</a></li>
+      <li><a class="spec" href="/getting_started/10.html">Enumerables and streams</a></li>
+      <li><a class="spec" href="/getting_started/11.html">Processes</a></li>
+      <li><a class="spec" href="/getting_started/12.html">IO</a></li>
+      <li><a class="spec" href="/getting_started/13.html">alias, require and import</a></li>
+      <li><a class="spec" href="/getting_started/14.html">Module attributes</a></li>
+      <li><a class="spec" href="/getting_started/15.html">Structs</a></li>
+      <li><a class="spec" href="/getting_started/16.html">Protocols</a></li>
+      <li><a class="spec" href="/getting_started/17.html">try, catch and rescue</a></li>
+      <li><a class="spec" href="/getting_started/18.html">Comprehensions</a></li>
+      <li><a class="spec" href="/getting_started/19.html">Sigils</a></li>
+      <li><a class="spec" href="/getting_started/20.html">Where to go next</a></li>
     </ol>
   </div>
   <div class="widget">
@@ -33,6 +46,14 @@ <h3 class="widget-title">ExUnit - a unit test framework</h3>
       <li><a class="spec" href="/getting_started/ex_unit/1.html">Introduction to ExUnit</a></li>
     </ol>
   </div>
+  <div class="widget">
+    <h3 class="widget-title">Meta-programming in Elixir</h3>
+    <ol>
+      <li><a class="spec" href="/getting_started/meta/1.html">Quote and unquote</a></li>
+      <li><a class="spec" href="/getting_started/meta/2.html">Macros</a></li>
+      <li><a class="spec" href="/getting_started/meta/3.html">Domain Specific Languages</a></li>
+    </ol>
+  </div>
 
   {% include learning-resources.html %}
   {% include sponsors.html %}
@@ -49,9 +70,9 @@ <h3 class="widget-title">ExUnit - a unit test framework</h3>
       <a href="{{page.guide | minus:1}}.html" class="previous page-numbers spec">&larr; Previous</a>
     {% endif %}
       <a class="page-numbers spec" href="#container">Top</a>
-    {% if page.guide < page.total_guides %}
+    {% unless page.last %}
       <a href="{{page.guide | plus:1}}.html" class="next page-numbers spec">Next &rarr;</a>
-    {% endif %}
+    {% endunless %}
   </div>
   {% endif %}
 </div><!-- #content -->
diff --git a/_posts/2012-04-06-what-s-new-in-elixir-1.markdown b/_posts/2012-04-06-what-s-new-in-elixir-1.markdown
deleted file mode 100644
index 25ed45f3e..000000000
--- a/_posts/2012-04-06-what-s-new-in-elixir-1.markdown
+++ /dev/null
@@ -1,75 +0,0 @@
----
-layout: post
-title: What's New in Elixir  &#35;1
-author: Alexei Sholik
-category: "What's New in Elixir"
-excerpt: Last week Elixir has seen a lot of new features, improvements, and bug fixes. In this little post I'm going to highlight some of the most prominent ones.
----
-
-Last week Elixir has seen a lot of new features, improvements, and bug fixes. In this little post I'm going to highlight some of the most prominent ones.
-
-* Access protocol has been added for tuples, lists, strings, and whatnot. It allows us to easily access elements of a collection. We can also use a regex to find the first match in a string or a list. Examples follow: 
-
-        dict = [a: 1, b: 2, c: 3]
-        dict[:a]   #=> 1
-        dict[:d]   #=> nil
-
-        tuple = {5, 4, 3, 2, 1}
-        tuple[1]   #=> 5
-        tuple[0]   #=> nil
-        tuple[-1]  #=> 1
-
-        defrecord TestRec, red: 0, green: 0, blue: 0
-        r = TestRec[red: 255, blue: 80]  #=> new record
-        s = "The quick brown fox jumps over the lazy dog."
-        s[%r/[a-z]+o[a-z]+/]  #=> "brown"
-
-* Access protocol also makes it possible to pattern-match records:
-
-
-        defrecord TestRec, red: 0, green: 0, blue: 0
-        r = TestRec[red: 255, blue: 80]  #=> new record
-        case r do
-        match: TestRec[red: 0]
-          :no_match
-        match: TestRec[red: red, blue: 80]
-          :ok
-        end
-        #=> :ok
-        red === 255  #=> true
-
-* The `Orddict` module is no longer with us, it has been renamed to `Keyword`. The new module only allows atoms to be used as keys. A general purpose module for dicts will be added sooner or later. 
-
-* The [`Enum` module](https://github.com/elixir-lang/elixir/blob/6f5611317a3d3102f60dbb319f88f2ca1d561c11/lib/enum.ex) has been cleaned up a bit and got new functions, namely `drop_while`, `take_while`, and `split_with`.
-
-* The [`List` module](https://github.com/elixir-lang/elixir/blob/28eaff894e527643ba58b85fb975b5963679542b/lib/list.ex) has also seen some improvements. It now supports access protocol, the `append` function was renamed to `concat`, and a new `range` function has been implemented. 
-
-* Support for nested modules has been added.
-
-        defmodule Father do
-          defmodule Child do
-            def child_fun(str) do
-              IO.puts str
-            end
-          end
-          def fun do
-            Child.child_fun "some argument"
-          end
-        end
-        Father.Child.child_fun "hello!"
-
-* The `Regex` module has received new functions, namely, `source` and `opts`. It can also be `inspect`ed now.
-
-        reg = %r/[a-z]+o[a-z]+/im
-        Regex.source reg  #=> "[a-z]+o[a-z]+"
-        Regex.opts reg    #=> "im"
-        inspect reg       #=> "%r\"[a-z]+o[a-z]+\"im"
-
-* A new `read_info` function has been added to the [`File` module](https://github.com/elixir-lang/elixir/blob/35b22c598defd8be07d46d2e7e8fc0ddf9ec4e80/lib/file.ex) allowing 
-users to query for file attributes.
-
----
-
-That's it for this week. I think it's been a great one! If anyone of you has something in the works in a separate fork or branch, please let me know so that I can highlight your contributions too.
-
-Thank you all and see you next week.
diff --git a/_posts/2012-04-13-what-s-new-in-elixir-2.markdown b/_posts/2012-04-13-what-s-new-in-elixir-2.markdown
deleted file mode 100644
index 74ad3e504..000000000
--- a/_posts/2012-04-13-what-s-new-in-elixir-2.markdown
+++ /dev/null
@@ -1,57 +0,0 @@
----
-layout: post
-title: What's New in Elixir  &#35;2
-author: Alexei Sholik
-category: "What's New in Elixir"
-excerpt: This week has not seen as many prominent new features as the previous one. Still, more bugs have been fixed and a number of small improvements has been made here and there, so the overall progress is quite noticeable.
----
-This week has not seen as many prominent new features as the previous one. Still, more bugs have been fixed and a number of small improvements has been made here and there, so the overall progress is quite noticeable.
-
-Let's get started with our usual overview. I'm using the latest master (`2851da4186a7e4c8e94c6ddd4e78dc7e883a31e9`) to compile and run the code snippets in this post.
-
-* Literal support for hexadecimal, octal and binary numbers has been added.
-
-        0xFF    #=> 255
-        0o10    #=> 8
-        0b1010  #=> 10
-
-* New functions in the [List module](https://github.com/elixir-lang/elixir/blob/master/lib/list.ex): `sort`, `zip`, `unzip`.
-
-        # Charlists are sorted in lexicographic order
-        List.sort ['10', '2', '4', '1', '21']
-        #=> ['1', '10', '2', '21', '4']
-
-        # Numerical sort for charlists using a custom function
-        List.sort ['10', '2', '4', '1', '21'], fn(a, b) ->
-          {na, _} = :string.to_integer a
-          {nb, _} = :string.to_integer b
-          na <= nb
-        end
-        #=> ['1', '2', '4', '10', '21']
-
-        List.zip [[1, 2], [:a, :b], ["one", "two"]]
-        #=> [{1,:a,"one"},{2,:b,"two"}]
-
-* The [System module](https://github.com/elixir-lang/elixir/blob/master/lib/system.ex) has been merged into master. It provides functions for communicating with OS environment, running external commands, getting the stacktrace, etc.
-
-        System.pwd
-        #=> "/Users/alco/Documents/git/elixir"
-
-        System.get_env "PAGER"
-        #=> "less"
-
-        System.cmd 'date'
-        #=> "Fri Apr 13 19:35:13 EEST 2012\n"
-
-        System.stacktrace
-        #=> (usually long output)
-
-* In other news, we're getting closer to having a dedicated site for documentation, JSON parsing/serialization is currently in the works, and there's also work being done on bringing dicts back into Elixir.
-
-* We're also seeing new faces on the list and on the IRC channel. If you haven't already, come join us at #elixir-lang on irc.freenode.net. More fun stuff is coming in the nearest future, including new language features, projects and demos.
-
----
-
-That's it for this week. Don't forget that if you have something related to Elixir cooking, be it a language feature or a project, or a demo, or whatever, please let me know so that I can highlight your thing too. I will soon start featuring the most active projects in this digest. If you prefer to pitch the thing you're working on yourself, you are welcome to do so.
-
-Thank you all and see you next week!
diff --git a/_posts/2012-04-21-hello-macros.markdown b/_posts/2012-04-21-hello-macros.markdown
deleted file mode 100644
index bc00ce5d5..000000000
--- a/_posts/2012-04-21-hello-macros.markdown
+++ /dev/null
@@ -1,214 +0,0 @@
----
-layout: post
-title: Building a Web Framework. Part I
-author: Alexei Sholik
-category: "Web dev"
-excerpt: Since we haven't seen much new stuff in the Elixir land this week, I've decided to do something a little different. We'll build our own web framework to get a feel of the Elixir power. In this first part we'll take a closer look at macros and we'll see how they can be useful when it comes to building a friendly syntax for our users.
----
-Since we haven't seen much new stuff in the Elixir land this week, I've decided to do something a little different. We'll build our own web framework to get a feel of the Elixir power. In this first part we'll take a closer look at macros and we'll see how they can be useful when it comes to building a friendly syntax for our users.
-
-Here's an example of what we are aiming at:
-
-    defmodule HelloServer do
-      use Feb, root: "assets"
-
-      get "/" do
-        { :ok, "Hello world!" }
-      end
-
-      get "/demo", file: "demo.html"
-
-      post "/" do
-        { :ok, "You're posted!\nYour data: #{inspect _data}" }
-      end
-    end
-
-## The Foundation ##
-
-To keep this post short and simple, we won't cover every single aspect of web framework development right away. Instead, we'll first focus on one specific task — defining a domain specific language (DSL) using Elixir macros. Let's start by stepping through the code above, one piece at a time.
-
-You might remember from the [Getting Started guide][1] that `use` is just a syntactic sugar that expands into a call to the `__using__` macro. In our case, the expansion will look like this
-
-    require Feb
-    Feb.__using__(__MODULE, [root: "assets"])
-
-Let's forget about the `root` option for now, we'll deal with it later. Here's how our `__using__` macro is going to be defined:
-
-    defmodule Feb do
-      defmacro __using__(module, _opts) do
-        quote do
-          import Feb, only: [get: 2, post: 2]
-
-          def start do
-            Feb.start unquote(module)
-          end
-        end
-      end
-    end
-
-One important thing to understand here is that this macro is called inside the module which invokes the `use` directive (**HelloServer** in our case). When the macro is called, its return value is then evaluated inside the calling module. Thus, our **HelloServer** ends up with a definition for the `start` function which will in turn call `Feb.start`. Too see this in action, let's first define the `start` function in **Feb**:
-
-    def start(_) do
-      IO.puts "Executing Feb.start"
-    end
-
-And here's the code for our **HelloServer** so far:
-
-    defmodule HelloServer do
-      use Feb
-    end
-
-Now let's try this out in the shell. I'm using a Makefile to simplify the compilation-related tasks. You can grab a copy from the project's [GitHub repo][2]. Notice also how the project directory is organized.
-
-    $ make
-    $ elixir -e 'HelloServer.start'
-    Executing Feb.start
-
-Everything is working as expected. Now let's move to the fun part.
-
-  [1]: http://elixir-lang.org/getting_started/6.html
-  [2]: https://github.com/alco/web-framework/blob/master/1-macros/Makefile
-
-## Writing Method Macros ##
-
-Let's look at the first `get` definition and think a bit about its meaning.
-
-    get "/" do
-      { :ok, "Hello world!" }
-    end
-
-The important thing to know about Elixir definitions is that they are executable. The Elixir compiler does not compile the code in the strict sense of the word, it is executing the code. So when you put `IO.puts "Hello"` inside a module definition, you'll see `Hello` printed in the shell when the code is compiled.
-
-So, in this case, it's just a call to the `get` macro defined in **Feb**. In fact, we could write it as
-
-    Feb.get("/", do: { :ok, "Hello world!" })
-
-and would be exactly the same thing. The reason we are allowed to omit the `Feb.` part is because we have imported the `get` macro earlier, see the definition of `__using__`.
-
-OK, so now that when we understand what's actually going on, let's look at the definition:
-
-    defmacro get(path, [do: code]) do
-      quote do
-        def handle(:get, unquote(path), _data) do
-          unquote(code)
-        end
-      end
-    end
-
-Our `get` macro accepts two arguments, the second one is pattern-matched to extract the block of code between `do` and `end`. The macro produces a definition of the `handle` function with three arguments. The `_data` argument is not used here, it will be used in the `post` macro later. So, basically, instead of calling `get` we could write the following definition in **HelloServer** to achieve the same effect:
-
-    def handle(:get, "/", _data) do
-      { :ok, "Hello world!" }
-    end
-
-That's all there is to it. We can check this in the shell.
-
-    $ make
-    $ iex
-    iex> HelloServer.handle :get, "/", nil
-    {:ok,"Hello world!"}
-
-The code for the `post` macro is pretty straightforward as well:
-
-    defmacro post(path, [do: code]) do
-      quote hygiene: false do
-        def handle(:post, unquote(path), _data) do
-          unquote(code)
-        end
-      end
-    end
-
-One new thing here is `hygiene: false`. What this does is it allows us to define variables that will be accessible by the caller. We do this here so that we can then reference the `_data` variable in our **HelloServer** implementation:
-
-    post "/" do
-      { :ok, "You're posted!\nYour data: #{inspect _data}" }
-    end
-
-Check that it works as expected:
-
-    $ make
-    $ iex
-    iex> HelloServer.handle :post, "/", "abc"
-    {:ok,"You're posted!\nYour data: \"abc\""}
-
-Good. We're almost done with the basics. I haven't covered the second `get` definition yet. Let's recall what it looked like:
-
-    get "/demo", file: "demo.html"
-
-By using this macro we're letting the framework know that we want to send the contents of the _demo.html_ file back to the client. In order to support this second form we need to define another clause for our `get` macro:
-
-    defmacro get(path, [file: bin]) when is_binary(bin) do
-      quote do
-        def handle(:get, unquote(path), _data) do
-          full_path = File.join([static_root(), unquote(bin)])
-          case File.read(full_path) do
-            { :ok, data } -> { :ok, data }
-            _ -> { :error, "404 Not Found" }
-          end
-        end
-      end
-    end
-
-Having written the code for reading from a file in the framework, we free our users from the need to do so themselves.
-
-## Wrapping Up ##
-
-I haven't yet provided the definition for `static_root`, let me fix this. It has to do with the `root` option mentioned at the beginning of the post. Remember what our first invocation of `use` looked liked
-
-    # In module HelloServer
-    use Feb, root: "assets"
-
-The `[root: "assets"]` Keyword is what ends up in the `_opts` argument of our `__using__` macro. So let's rewrite that macro to include the definition for the `static_root` function.
-
-    # In module Feb
-    defmacro __using__(module, opts) do
-      root_val = Keyword.get(opts, :root, ".")
-
-      quote do
-        import Feb, only: [get: 2, post: 2]
-
-        def start do
-          Feb.start unquote(module)
-        end
-
-        defp static_root, do: unquote(root_val)
-      end
-    end
-
-We read the value of the `root` key from the `opts` Keyword. If it's nil, the current directory becomes the root.
-
-The post is already getting quite long, so let's wrap up and do the final test drive to make sure everything works as expected.
-
-    $ make
-    $ iex
-    iex> import HelloServer
-    []
-    iex> handle :get, "/", nil
-    {:ok,"Hello world!"}
-    iex> handle :post, "/", :data
-    {:ok,"You're posted!\nYour data: :data"}
-    iex> handle :get, "/demo", nil
-    {:error,"404 Not Found"}
-
-Oops, looks like I've forgotten to create the _demo.html_ file. Let's do this real quick. Create the file in the _assets_ directory and paste the following contents into it:
-
-    <html>
-      <head>
-        <title>Demo</title>
-      </head>
-      <body>
-        <h1>Hello world!</h1>
-      </body>
-    </html>
-
-Now let's try that again:
-
-    iex> handle :get, "/demo", nil
-    {:ok,"<html>\n<head>\n  <title>Demo</title>\n</head>\n<body>\n  <h1>Hello world!</h1>\n</body>\n</html>\n\n\n"}
-
-Awesome! This concludes the first part in the series. Don't forget to grab the code [from GitHub][3]. If you have any questions or corrections, send a message to the [mailing list][4] or stop by the **#elixir-lang** channel on **irc.freenode.net**.
-
-See you there.
-
-  [3]: https://github.com/alco/web-framework/tree/master/1-macros
-  [4]: http://groups.google.com/group/elixir-lang-talk
diff --git a/_posts/2012-04-24-a-peek-inside-elixir-s-parallel-compiler.markdown b/_posts/2012-04-24-a-peek-inside-elixir-s-parallel-compiler.markdown
index bc1c64b55..82b076aee 100644
--- a/_posts/2012-04-24-a-peek-inside-elixir-s-parallel-compiler.markdown
+++ b/_posts/2012-04-24-a-peek-inside-elixir-s-parallel-compiler.markdown
@@ -18,7 +18,7 @@ In Elixir, we could write this code as follows:
       parent = Process.self()
       child  = spawn_link(fn ->
         :elixir_compiler.file_to_path(current, output)
-        parent <- { :compiled, Process.self() }
+        send parent, { :compiled, Process.self() }
       end)
       receive do
         { :compiled, ^child } ->
@@ -95,7 +95,7 @@ As discussed in the previous section, we want to extend the error handler to act
             []
           { :error, _ } ->
             parent = Process.get(:elixir_parent_compiler)
-            parent <- { :waiting, Process.self, module }
+            send parent, { :waiting, Process.self, module }
             receive do
               { :release, ^parent } -> ensure_loaded(module)
             end
@@ -114,7 +114,7 @@ With our error handler code in place, the first thing we need to do is to change
       Process.flag(:error_handler, Elixir.ErrorHandler)
 
       :elixir_compiler.file_to_path(current, output)
-      parent <- { :compiled, Process.self() }
+      send parent, { :compiled, Process.self() }
     end)
 
 Notice that we have two small additions. First we store the `:elixir_parent_compiler` PID in the process dictionary so we are able to read it from the error handler and then we proceed to configure a flag in our process so our new error handler is invoked whenever a module or function cannot be found.
@@ -125,7 +125,7 @@ Second, our main process can now receive a new `{ :waiting, child, module }` mes
       parent = Process.self()
       child  = spawn_link(fn ->
         :elixir_compiler.file_to_path(current, output)
-        parent <- { :compiled, Process.self() }
+        send parent, { :compiled, Process.self() }
       end)
       wait_for_messages(files, output, [child|stack])
     end
@@ -147,7 +147,7 @@ Notice we added an extra clause to `spawn_compilers` so we can properly handle t
         { :compiled, child } ->
           new_stack = List.delete(stack, child)
           Enum.each new_stack, fn(pid) ->
-            pid <- { :release, Process.self }
+            send pid, { :release, Process.self }
           end
           spawn_compilers(files, output, new_stack)
         { :waiting, _child, _module } ->
diff --git a/_posts/2012-04-27-what-s-new-in-elixir-3.markdown b/_posts/2012-04-27-what-s-new-in-elixir-3.markdown
deleted file mode 100644
index 2f9185888..000000000
--- a/_posts/2012-04-27-what-s-new-in-elixir-3.markdown
+++ /dev/null
@@ -1,216 +0,0 @@
----
-layout: post
-title: What's New in Elixir  &#35;3
-author: Alexei Sholik
-category: "What's New in Elixir"
-excerpt: It's been two weeks since the last edition of the series, so this one is going to be packed with information.
----
-
-It's been two weeks since the last edition of the series, so this one is going to be packed with information.
-
-As usual, I'm using the latest available master (`b4cc71a8351222721b0e1dce130843d7e683863e`) to compile and run the code snippets in this post.
-
-You might have noticed that the version number has been downgraded to 0.5.0 recently. This doesn't mean that half of the features have been removed from Elixir. It simply indicates that there's still plenty of work to be done, but we're sure we're moving in the right direction.
-
-Without further ado, let's get to it.
-
-
-## Highlights ##
-
-José has written an awesome blog post describing how the new parallel compiler allows Elixir to seamlessly resolve dependencies and improve the speed of ~~light~~ compilation by doing only the work that needs to be done. Read all about it [here][1].
-
-  [1]: http://elixir-lang.org/blog/2012/04/24/a-peek-inside-elixir-s-parallel-compiler/
-
-
-## API Changes ##
-
-
-### Keyword ###
-
-Keywords can have duplicate entries. When you `get` a value for a key from a keyword, the first entry with that key is returned. When you `put` a new value, it replaces all values for the given key:
-
-    kv = [a: 1, a: 2, b: 3]
-    #=> [{:a,1},{:a,2},{:b,3}]
-
-    Keyword.get kv, :a
-    #=> 1
-
-    Keyword.put kv, :a, 10
-    #=> [{:a,10},{:b,3}]
-
-### New syntax for protocol declarations ###
-
-Protocol declarations now look more like module definitions. This allows us to document each function and increases their overall visual appeal (in my view).
-
-    defprotocol ProtoName do
-      @only [Record, List]
-
-      @doc """
-      This is a doc string.
-      """
-      def function(arg)
-
-      @doc """
-      Another function
-      """
-      def another_function(list)
-    end
-
-As before, functions are only declared inside the `defprotocol` body. Their implementation is defined separately (in a `defimpl` block) for each type that wishes to support the protocol. More info can be found in the [Getting Started guide][2] (_Section 4.2_).
-
-  [2]: http://elixir-lang.org/getting_started/4.html
-
-### Declarations for default arguments ###
-
-Default arguments in Elixir are shared between different clauses of the functions with the same name. This recent addition allows this fact to be expressed more clearly in the code.
-
-    defmodule DefaultTest do
-      def function(a, b // "world")
-
-      def function(a, b) when is_binary(a) do
-        a <> b
-      end
-
-      def function(a, b) when is_list(a) do
-        a ++ to_char_list(b)
-      end
-    end
-
-    ###
-
-    iex> DefaultTest.function "Hello "
-    "Hello world"
-
-    iex> DefaultTest.function 'Hello '
-    'Hello world'
-
-Notice how the first declaration does not have a body, its only purpose is to define the default argument that will be used in the remaining two clauses.
-
-### Revamped assert with smart guessing ###
-
-Our good old `assert` macro has become a tad smarter and can be now be used in places where we had to use `assert_equal`, `assert_operator`, and `assert_access` before.
-
-    # Replaces assert_equal
-    assert "abc" == to_binary('abc')
-
-    # Replaces assert_operator
-    assert 11 < 13
-
-    # Replaces assert_access. Checks that the regexp can access/match the string.
-    assert "foo"[%r(o)]
-
-### Enum ###
-
-The `Enum` module has been reworked slightly in order to add support for dicts (described below). It's still working with lists as before, but now you can also use most of its functions with dicts too.
-
-
-## New Modules & Protocols ##
-
-### Meet the new Dict protocol along with it's buddies HashDict and Orddict ###
-
-This change has been cooking for quite a while. Now it's finally merged into master. Let's have a look:
-
-    dict = HashDict.new [a: 1, b: 2, c: 3]
-    Dict.keys dict
-    #=> [:a,:b,:c]
-
-    Dict.values dict
-    #=> [1,2,3]
-
-    dict = Dict.put dict, "hello", "world"
-    Dict.get dict, "hello"
-    #=> "world"
-
-    ord = Orddict.new [{"a", []}, {"b", [1, 2, 3]}, {[nil], "cool"}]
-    Dict.get ord, [nil]
-    #=> "cool"
-
-    ord = Dict.merge ord, Orddict.new([key: 'value'])
-    Dict.get ord, :key
-    #=> 'value'
-
-Notice, that `Dict` is a protocol and it works with both hash dicts and orddicts. Take a look at the [source code][3] for the new modules. The protocol declaration in _common.ex_ has extensive documentation for the functions it defines.
-
-  [3]: https://github.com/elixir-lang/elixir/tree/master/lib/dict
-
-
-Let's look at how we can use `Enum` with the new dict modules.
-
-    # ord is our orddict from the previous snippet
-
-    # Swap keys and values
-    Enum.map ord, fn({k, v}) -> {v, k} end
-    #=> [{'value',:key},{"cool",[nil]},{[],"a"},{[1,2,3],"b"}]
-
-Notice that `Enum` always returns a list even when passed a dictionary.
-
-Some functions in `Enum` expect an ordered collection to be passed in. Since `HashDict` does not define a meaningful order for its contents, you'll get a runtime error if you try to use one of those functions with this dict. `Orddict`, on the other hand, keeps its entries sorted by keys:
-
-    ord = Orddict.new [{'value',:key},{"cool",[nil]},{[],"a"},{[1,2,3],"b"}]
-    #=> {Orddict.Record,[{[],"a"},{[1,2,3],"b"},{'value',:key},{"cool",[nil]}]}
-
-    Enum.drop_while ord, fn({k, v}) -> is_list(k) end
-    #=> [{"cool",[nil]}]
-
-Take a look at the [source code][4] for the detailed descriptions of all the functions defined in `Enum`. Those functions that expect an ordered collection are explicitly marked as such.
-
-  [4]: https://github.com/elixir-lang/elixir/blob/master/lib/enum.ex
-
-
-## Technical Stuff ##
-
-### Macros can now be invoked locally ###
-
-You can also define private macros with `defmacrop`. Example:
-
-    defmodule Obnoxious do
-      defmacro swap({:*, line, args}) do
-        {:+, line, args}
-      end
-
-      defmacrop priv_swap({:+, line, args}) do
-        {:*, line, args}
-      end
-
-      def mul(a, b) do
-        swap(a * b)
-      end
-
-      def add(a, b) do
-        priv_swap(a + b)
-      end
-    end
-
-    ###
-
-    iex> Obnoxious.mul 3, 4
-    7
-
-    iex> Obnoxious.add 6, 6
-    36
-
-
-### Extended module info available at runtime ###
-
-Given the definition of `Obnoxious` above, we can query some of its attributes at run time:
-
-    # Functions exported by the module
-    iex> Obnoxious.__info__(:functions)
-    [{:__info__,1},{:add,2},{:mul,2}]
-
-    # Macros exported by the module
-    iex> Obnoxious.__info__(:macros)
-    [{:swap,1}]
-
-As you can see, the private macro `priv_swap` is not available outside of the module it is defined in, the same goes for private functions. They could even have been inlined by the compiler, who knows.
-
-And don't forget that Erlang compiler provide the `module_info` function for each compiled module:
-
-    iex> Obnoxious.module_info
-    [{:exports,[{:__info__,1},{:MACRO_swap,1},{:mul,2},{:add,2},{:module_info,0},{:module_info,1}]}, ...]
-
----
-
-That's it for this week. It's exciting to see Elixir evolving each day. Join the community if you don't want to end up lagging behind!
-
-Thank you all and see you next week!
diff --git a/_posts/2012-05-06-web-framework-2.markdown b/_posts/2012-05-06-web-framework-2.markdown
deleted file mode 100644
index 524de0991..000000000
--- a/_posts/2012-05-06-web-framework-2.markdown
+++ /dev/null
@@ -1,300 +0,0 @@
----
-layout: post
-title: Building a Web Framework. Part II
-author: Alexei Sholik
-category: "Web dev"
-excerpt: Last time we learned how to write macros that provide a useful abstraction for building a web server on top of the language. The server we built was able to serve static files and handle user's GET and POST requests. This week we're going to further extend our web framework, fix a couple of rough edges, and experiment with networking.
----
-
-[Last time][1] we learned how to write macros that provide a useful abstraction on top of the language which we used for building a web server. The server we built was able to serve static files and handle user's GET and POST requests. Here's what it looked like:
-
-    defmodule HelloServer do
-      use Feb, root: "assets"
-
-      get "/" do
-        { :ok, "Hello world!" }
-      end
-
-      get "/demo", file: "demo.html"
-
-      post "/" do
-        { :ok, "You're posted!\nYour data: #{inspect _data}" }
-      end
-    end
-
-If you missed the previous post, I encourage you to [go back][1] to it and make sure you understand the concepts explained there.
-
-In this post we're going to fix a couple of rough edges and further extend our web framework. Specifically, we're going to implement URL query parsing and add a generic `multi_handle` macro that will complete our syntactic abstraction. From that point on we'll start looking at how to add networking to the framework to eventually be able to build a real website. This is what the code for our `HelloServer` is going to turn into by the end of this post:
-
-    defmodule HelloServer do
-      use Feb, root: "assets"
-
-      get "/" do
-        { :ok, "Hello world!" }
-      end
-
-      get "/demo", file: "demo.html"
-
-      post "/" do
-        { :ok, "You're posted!\nYour data: #{inspect _data}" }
-      end
-
-      ## New stuff below this line ##
-
-      multi_handle "/kvstore" do
-        :post ->
-          IO.puts "Got a POST request with data: #{inspect _data}"
-          :ok
-
-        :get ->
-          IO.puts "Got a GET request with query: #{inspect _query}"
-          :ok
-      end
-
-      get "/search", query do
-        search = Dict.get query, "q"
-        if search do
-          { :ok, "No items found for the query '#{search}'" }
-        else
-          { :ok, "No query" }
-        end
-      end
-    end
-
-The entire source code for this and the past articles is available over at [GitHub][2]. To recap, we have two files in the _src_ directory: _feb.ex_ which contains the code for our `Feb` framework and _server.ex_ which is a simple server implementation (named `HelloServer`) based on the framework. To follow along with the post, I recommend keeping the code from the _1-macros_ directory open in a side window. I will be explaining the new stuff based on the code we have seen so far.
-
-  [1]: http://elixir-lang.org/blog/2012/04/21/hello-macros/
-  [2]: https://github.com/alco/web-framework
-
-
-## Unexpected Requests ##
-
-Our server can currently handle only those requests that are explicitly coded. If we try to send it a different kind of request, it'll crash:
-
-    iex> HelloServer.handle :oops, "/", nil
-    ** (FunctionClauseError) no function clause matching: HelloServer.handle(:oops, "/", nil)
-
-To avoid this, we'll add a catch-all default handler to _feb.ex_:
-
-    defmacro default_handle(_) do
-      quote do
-        def handle(method, path, data // "")
-        def handle(method, path, data) do
-          cond do
-            # Allow only the listed methods
-            not (method in [:get, :post]) -> format_error(400)
-            
-            # Path should always start with a slash (/)
-            not match?("/" <> _, path) -> format_error(400)
-            
-            # Otherwise, the request is assumed to be valid but the requested
-            # resource cannot be found
-            _ -> format_error(404)
-        end
-      end
-    end
-
-I'll explain the ignored argument to this macro shortly. I've also introduced a new function that automates error reporting a bit. Here's how it's implemented in _feb.ex_:
-
-    # Return a { :error, <binary> } tuple with error description
-    def format_error(code) do
-      { :error, case code do
-        400 -> "400 Bad Request"
-        404 -> "404 Not Found"
-        _   -> "503 Internal Server Error"
-      end }
-    end
-
-Lastly, I've changed the `import` statement in the `__using__` macro (again in _feb.ex_) to the following one:
-
-    import Feb
-    # was
-    # import Feb, only: [get: 2, post: 2]
-
-This will allow us to add new functions and macros and make them available to the client code automatically.
-
-To include the `default_handle` function in `HelloServer` we can add a call to it at the end of the module definition. But there is a better way, an automatic one. Elixir provides the function `Module.add_compile_callback/1` which is exactly what we need to set up our default handler and ensure that it is going to be invoked only after every other clause was tried and failed to match the arguments.
-
-We'll add the following line at the beginning the `__using__` macro definition in _feb.ex_:
-
-    defmacro __using__(module, opts) do
-      Module.add_compile_callback module, __MODULE__, :default_handle
-
-Elixir will call the `default_handle` macro as if it were placed right at the end of `HelloServer` definition and it will pass the module name as an argument (which we're not using here, so we're simply ignoring it).
-
-Now let's test the new handler.
-
-    $ make
-    $ iex
-    iex> HelloServer.handle :oops, "/"
-    {:error,"400 Bad Request"}
-
-    iex> HelloServer.handle :get, "wrong_path"
-    {:error,"400 Bad Request"}
-
-    iex> HelloServer.handle :get, "/404"
-    {:error,"404 Not Found"}
-
-That's better.
-
-
-## Generic Handle ##
-
-Let's add one more piece of sugar to our framework by allowing the users to write one function that will handle several HTTP methods, useful for defining various interactions with a single path spec. For instance:
-
-    multi_handle "/kvstore" do
-      :post ->
-        IO.puts "Got a POST request with data: #{_data}"
-        :ok
-      :get ->
-        IO.puts "Got a GET request with query: #{_query}"
-        :ok
-    end
-
-You can see how this approach allows us to express the fact that "/kvstore" provides some kind of service with support for multiple methods. This skeleton could be used to build a REST API, for example. This time around we'll be using implicit variables for POST data and GET query.
-
-Let's think for a moment what the `multi_handle` macro should expand to. So far we've been expanding our `post` and `get` macros into one `handle` function that uses pattern-matching to dispatch to the appropriate handler based on the incoming request. There's no reason not to use the same approach for `multi_handle`. So here's what its implementation looks like:
-
-    defmacro multi_handle(path, [do: { :"->", _line, blocks }]) do
-      # Iterate over each block in `blocks` and
-      # produce a separate `handle` clause for it
-      Enum.map blocks, fn ->
-        { [:get], code } ->
-          quote hygiene: false do
-            def handle(:get, unquote(path), _query) do
-              unquote(code)
-            end
-          end
-        { [:post], code } ->
-          quote hygiene: false do
-            def handle(:post, unquote(path), _data) do
-              unquote(code)
-            end
-          end
-      end
-    end
-
-When the macro is called, we receive all clauses under the `do` key with each HTTP verb and its implementation inside the syntax node `->`, in the order they are specified. Each clause is a tuple with two elements, the first one is a list of parameters given on the left side and the second one is the implementation, for example:
-
-    { :"->", line, [{[:get], <user code>}, {[:post], <user code>}] }
-
-In our `multi_handle` macro signature, we pattern match against the expression above and get a list with the blocks of code. Then we loop through this list emitting a function definition with the corresponding arguments. The code for each of the code blocks is similar to the GET and POST handlers we have defined earlier.
-
-Finally, let's test it in `iex`:
-
-    $ make
-    $ iex
-    iex> import HelloServer
-    []
-
-    iex> handle :get, "/kvstore"
-    Got a GET request with query: ""
-    :ok
-
-    iex> handle :post, "/kvstore"
-    Got a POST request with data: ""
-    :ok
-
-    iex> handle :post, "/kvstore", "secret"
-    Got a POST request with data: "secret"
-    :ok
-
-So far so good. Now let's add the ability to get the query from a URL.
-
-
-## URL Queries ##
-
-We'd like our server to be able to handle queries of the form `/search?q=donut`. The `URI` module which ships with Elixir has the right tools for the task: `parse` and `decode_query`. The first one parses a URI and stores it in a `URI.Info` record. The second one accepts a query string and returns a dict.
-
-We'll implement a `split_path` function in `Feb` that will return a tuple of the form `{ path, query }` where `query` is going to be an orddict. If the path does not contain a query, an empty orddict will be returned.
-
-    # Return { path, query } where `query` is an orddict.
-    def split_path(path_with_query) do
-      uri_info = URI.parse path_with_query
-      { uri_info.path, URI.decode_query(uri_info.query || "") }
-    end
-
-The code is pretty straightforward. Let's make sure that it works:
-
-    $ make
-    $ iex
-    iex> Feb.split_path "/search"
-    {"/search",{Orddict.Record,[]}}
-
-    iex> Feb.split_path "/search?q=hello&find=chuck%20norris"
-    {"/search",{Orddict.Record,[{"find","chuck norris"},{"q","hello"}]}}
-
-OK, so that's done. But we have no way of passing the query to the server. This is solved by adding another clause to the `get` macro as follows:
-
-    # feb.ex
-
-    # A 2-argument handler that also receives a query along with the path
-    defmacro get(path, query, [do: code]) do
-      quote do
-        def handle(:get, unquote(path), unquote(query)) do
-          unquote(code)
-        end
-      end
-    end
-
-The only difference between this handler and the basic query-less GET handler is that we include the `query` argument provided by the user in the generated function definition. Remember that in our [POST handler](https://github.com/alco/web-framework/blob/master/1-macros/src/feb.ex#L49) we used a `quote` form with hygiene turned off in order to define an implicit `_data` variable. Our GET handlers could also receive such implicit argument if we turned the hygiene off for them. The reason I've chosen to handle the query explicitly in this case is to show you that there are multiple options available. You may choose whichever you like most.
-
-With this new clause in place we can add another `get` request definition in the `HelloServer` module:
-
-    # server.ex
-
-    get "/search", query do
-      search = Dict.get query, "q"
-      if search do
-        { :ok, "No items found for the query '#{search}'" }
-      else
-        { :ok, "No query" }
-      end
-    end
-
-Let's take a step back and look again at the definition for this `get` macro in _feb.ex_. It takes its second argument (the `query`) and puts it in place of the third argument in the definition of `handle`. The reason we're unquoting it (instead of simply writing `query`) is to allow the user to choose an arbitrary name for this argument. So, for instance, the following definition in `HelloServer` will work the same way:
-
-    get "/search", my_query do
-      # the query dict is now stored in `my_query`
-      IO.inspect my_query
-    end
-
-All that's left is to test the code:
-
-    $ make
-    $ iex
-    iex> { path, query } = Feb.split_path "/search?q=donut"
-    {"/search",{Orddict.Record,[{"q","donut"}]}}
-
-    iex> import HelloServer
-    []
-
-    iex> handle :get, path, query
-    {:ok,"No items found for the query 'donut'"}
-
-    iex> handle :get, "/search", Orddict.new
-    {:ok,"No query"}
-
-    # Let's also test our generic handler with a query
-    iex> handle :get, "/kvstore", URI.decode_query("key=value")
-    Got a GET request with query: {Orddict.Record,[{"key","value"}]}
-    :ok
-
-Great! With this we have completed the implementation of our simplistic DSL. Let's wrap up for this week and do a quick review of what we have learned.
-
-
-## Conclusion ##
-
-By this time you know how to use macros to your advantage by defining appropriate abstractions that allow writing code that's easy to grasp. Another benefit of this approach is that it hides implementation details so that they can be changed without touching the application-level code. We'll see an example of this in a future post.
-
-Next time, we'll implement a basic networking layer for our framework. It will serve as a basis for testing and adding support for the real HTTP protocol later on.
-
----
-
-This concludes the second part in the series. Don't forget to grab the code [from GitHub][2]. I'd like to thank [@rafaelfranca][4] and [@josevalim][5] for their valuable suggestions. If you have any questions or corrections, send a message to the [mailing list][3] or join the the **#elixir-lang** channel on **irc.freenode.net**.
-
-See you there.
-
-  [3]: http://groups.google.com/group/elixir-lang-talk
-  [4]: https://github.com/rafaelfranca
-  [5]: https://github.com/josevalim
diff --git a/_posts/2012-05-13-what-s-new-in-elixir-4.markdown b/_posts/2012-05-13-what-s-new-in-elixir-4.markdown
deleted file mode 100644
index 1f6be3b91..000000000
--- a/_posts/2012-05-13-what-s-new-in-elixir-4.markdown
+++ /dev/null
@@ -1,149 +0,0 @@
----
-layout: post
-title: What's New in Elixir  &#35;4
-author: Alexei Sholik
-category: "What's New in Elixir"
-excerpt: Welcome to the new edition of our biweekly series. Elixir development has been progressing at a steady pace and there are quite a few new things we're going to have a look at today.
----
-Welcome to the new edition of our biweekly series. Elixir development has been progressing at a steady pace and there are quite a few new things we're going to have a look at today.
-
-As always, I'm using the latest master (`d28d716de0f2892e31b4bcc9f87549b125075fa5`) to compile and run the code snippets in this post.
-
-## Highlights ##
-
-The [online docs][1] are finally up! This means easier navigation and integrated search. The docs are generated directly from the source, so it's very easy for you to contribute. Simply hit the _Source_ link, author your patch and send a pull request to the main Elixir repo. With GitHub you can do this all without leaving the browser. Any changes improving the documentation are welcome.
-
-The docs are generated with the help of the [ExDoc][0] utility which is itself written in Elixir.
-
-  [0]: https://github.com/elixir-lang/ex_doc
-  [1]: http://elixir-lang.org/docs.html
-
-
-## API Changes ##
-
-### Overridable ###
-
-Overridable is no longer a data attribute, but a macro. This makes it more straightforward to define an overridable function that has multiple clauses of the same arity.
-
-    defmodule DefaultMod do
-      defmacro __using__(_module, _opts) do
-        quote do
-          def test(:x) do
-            IO.puts "This is X"
-          end
-
-          def test(:y) do
-            IO.puts "This is Y"
-          end
-
-          defoverridable [test: 1]
-        end
-      end
-    end
-
-    defmodule InheritMod do
-      use DefaultMod
-
-      def test(:z) do
-        IO.puts "This is Z"
-      end
-    end
-
-    ###
-
-    InheritMod.test :x
-    #=> ** (FunctionClauseError) no function clause matching: InheritMod.test(:x)
-
-    InheritMod.test :y
-    #=> ** (FunctionClauseError) no function clause matching: InheritMod.test(:y)
-
-    InheritMod.test :z
-    #=> This is Z
-
-As you can see, all clauses are being overriden with one new clause. If you want to keep the default clauses, you can use the `super` keyword that is available inside an overriden function definition. So, if we add the following definition
-
-    def test(_) do
-      super
-    end
-
-at the end of `InheritMod`, it would result in the following:
-
-    InheritMod.test :x
-    #=> This is X
-
-    InheritMod.test :y
-    #=> This is Y
-
-    InheritMod.test :z
-    #=> This is Z
-
-Alternatively, if you wanted to keep your function extensible but not overridable, you would do away with the `defoverridable` line altogether. In this case, any new clause defined in `InheritMod` would be just that -- a new clause for the function that already has some number of clauses defined.
-
-## Misc. Stuff ##
-
-* The new `in` keyword has been added to simplify some common patterns. For instance, if you wanted to check for a falsey value, you had to write
-
-      case val do
-        nil ->   # code
-        false -> # code
-        other -> # other_code
-      end
-
-      # or
-
-      case val do
-        x when x == nil or x == false -> # code
-        other -> # other_code
-      end
-
-  Now you can write
-
-      case val do
-        x in [nil, false] -> # code
-        other -> # other_code
-      end
-
-  This new syntax can be used in guards, ordinary conditions, and pattern matching.
-
-* The new [File.exists?][2] function allows you to check if a file object exists in the file system. It can be a regular file, a directory, a socket, etc. If want to check for existence of a regular file, use [File.regular?][3] instead.
-
-  [2]: http://elixir-lang.org/docs/stable/File.html#exists?/1
-  [3]: http://elixir-lang.org/docs/stable/File.html#regular?/1
-
-* The [URI][4] module has got a new function for URL query parsing: [decode_query][5].
-
-      URI.decode_query "key=value&login=password"
-      #=> {Orddict.Record,[{"key","value"},{"login","password"}]}
-
-    Orddict is used by default. You can also pass your own dict
-
-      d = URI.decode_query "key=value&login=password", HashDict.new
-      Dict.get d, "login"
-      #=> "password"
-
-    This function also does percent-decoding for you
-
-      d = URI.decode_query "find=a%20place%20to%20live"
-      Dict.get d, "find"
-      #=> "a place to live"
-
-  [4]: http://elixir-lang.org/docs/stable/URI.html
-  [5]: http://elixir-lang.org/docs/stable/URI.html#decode_query/2
-
-* [OptionParser][6] now supports argument aliases:
-
-      OptionParser.Simple.parse(["-d"], [d: :debug])
-      #=> { [debug: true], [] }
-
-  [6]: http://elixir-lang.org/docs/stable/OptionParser.Simple.html
-
-* Node names are now valid atoms:
-
-      iex> :foo@bar
-      :"foo@bar"
-
----
-
-That's it for this edition. Don't forget to go [read the docs][1] and help us improve them :)
-
-Thank you all and see you next time!
diff --git a/_posts/2012-07-05-what-s-new-in-elixir-5.markdown b/_posts/2012-07-05-what-s-new-in-elixir-5.markdown
deleted file mode 100644
index e4ef398ae..000000000
--- a/_posts/2012-07-05-what-s-new-in-elixir-5.markdown
+++ /dev/null
@@ -1,93 +0,0 @@
----
-layout: post
-title: What's New in Elixir  &#35;5
-author: José Valim
-category: "What's New in Elixir"
-excerpt: The series is back after the first, official 0.5.0 release and we are packed with information!
----
-
-This is our first post from the What's New in Elixir series after [Elixir v0.5.0 was released](http://elixir-lang.org/blog/2012/05/25/elixir-v0-5-0-released/) and we have great improvements to share with you.
-
-Many of these improvements are related to how Elixir handles macros, but we also have the addition of ranges, some performance improvements and other minor changes.
-
-## API Changes ##
-
-### List and bit comprehensions ###
-
-The syntax for list and bit comprehensions was changed slightly to be more explicit and allow a developer to mix generators and filters:
-
-    lc x inlist [1,2,3], rem(x, 2) == 0, y inlist [4,5,6], do: x * y
-    #=> [8,10,12]
-
-### The `__ENV__` pseudo-variable ###
-
-Elixir provides many pseudo-variables that allow you to get information from the source code. For example, with `__MODULE__` you can get the current module name.
-
-In Elixir master, two pseudo-variables were deprecated (`__LINE__` and `__FUNCTION__`) in favor of the `__ENV__` variable. The `__ENV__` variable returns a [`Macro.Env` record](http://elixir-lang.org/docs/master/Macro.Env.html) that contains not only the current line and function but extra information such as the aliases set, macros imported and modules required:
-
-    iex> __ENV__.aliases
-    []
-    iex> alias List, as: L
-    []
-    iex> L.flatten([1,[2],3])
-    [1,2,3]
-    iex> __ENV__.aliases
-    [{L,List}]
-
-Besides the `__ENV__` variable, all macros can also access a `__CALLER__` pseudo-variable that contains the environment information about the caller. With such information, Elixir programmers can create more robust macros, as showed [in this commit which rewrites the `access` macro from Erlang to Elixir](https://github.com/elixir-lang/elixir/commit/088eff4c19614101cea55dfef9966d4de89181e3).
-
-## Performance improvements ##
-
-Regular expressions defined with the macros `%r` and `%R` are now compiled at compilation time instead of runtime, [as seen in this commit](https://github.com/elixir-lang/elixir/commit/646ee5f125601760bcd263105470545e0b7aa7f2). Our benchmarks showed that matching against [the regular expression defined in the URI module](https://github.com/elixir-lang/elixir/blob/ab61e6f95c37a8c0538f349a59be63ca00341b98/lib/uri.ex#L123) got twice faster:
-
-    Regex.match? %r/^(([^:\/?#]+):)?(\/\/([^\/?#]*))?([^?#]*)(\?([^#]*))?(#(.*))?/, "http://foo.com/"
-    #=> true
-
-The `Enum` module was also optimized when handling lists. Micro benchmarks show improvements from 1.5 to 4x. Such work was done over many commits throughout the month, but here is [an example of how `Enum.all?` and `Enum.any?` were optimized](https://github.com/elixir-lang/elixir/commit/058f0f66965323ca9e792b5143929ffd7819ed9d).
-
-## New features ##
-
-### Type specifications ###
-
-Elixir master also has shiny new features. Thanks to [Yurii Rashkovskii](https://github.com/yrashk), we now support [Erlang's type specification](http://www.erlang.org/doc/reference_manual/typespec.html):
-
-    @spec add(integer, integer), do: integer
-    def add(a, b), do: a + b
-
-Many tools in the Erlang community, as [dialyzer](http://www.erlang.org/doc/man/dialyzer.html) and [PropEr](https://github.com/manopapad/proper/), use type specifications to give feedback and point out inconsistencies, tests and improvements to your codebase. Supporting type specification is an important milestone which allows Elixir to integrate better with the existing Erlang community.
-
-### Ranges ###
-
-Elixir master has initial support for ranges. Ranges can be created with the operator `..` and integrate nicely with guard clauses. For example, a function that converts a student score to a message could be written as:
-
-    def score_to_message(x) when x in 0..40,   do: "Fail"
-    def score_to_message(x) when x in 41..60,  do: "Pass"
-    def score_to_message(x) when x in 61..70,  do: "Pass with Merit"
-    def score_to_message(x) when x in 71..100, do: "Pass with Distinction"
-
-Ranges can be extended via the range protocol, so developers can use their custom types in ranges and guard clauses too!
-
-### Other improvements ###
-
-There are many other improvements for the upcoming v0.6.0 release, including more robust and complete `IO` and `File` modules, more compilation callbacks with the `@before_compilation` and `@after_compilation` attributes and convenient helpers to work with macros, like `Macro.expand` that expands macros and `Macro.to_binary`, that receives a tree and converts it to its original source code:
-
-    iex> tree = Macro.expand(quote(do: !foo), __ENV__)
-    iex> IO.puts Macro.to_binary(tree)
-    case(foo) do
-      false ->
-        true
-      nil ->
-        true
-      _ ->
-        false
-    end
-
-In the example above, we use `Macro.expand` to expand the expression `!foo` and then print it using `Macro.to_binary`. We can see that the operator `!` is simply a macro that translates the expression to a `case` expression.
-
-## Community ##
-
-Besides improvements to Elixir itself, Elixir's community is also working on tools to make their day-to-day life easier. One of such examples is [genx](https://github.com/yrashk/genx), which provides helpers to work with Erlang OTP behaviors such as `application`, `gen_event` and others.
-
-More importantly, [rebar_elixir_plugin](https://github.com/yrashk/rebar_elixir_plugin) was also released to allow existing Erlang developers to compile Elixir source code using [Rebar](https://github.com/basho/rebar). For those not familar with Rebar, it is a build tool for Erlang projects created by [the good folks at Basho, from Riak fame](http://basho.com/).
-
-Finally, our documentation generation tool [ExDoc](https://github.com/elixir-lang/ex_doc) was improved to include the function signatures and arguments, making it more friendly to developers. [The documentation for Elixir master with those improvements is available here](http://elixir-lang.org/docs/master/). Enjoy!
diff --git a/_posts/2012-11-18-elixir-v0-7-1-released-and-the-end-of-a-journey.markdown b/_posts/2012-11-18-elixir-v0-7-1-released.markdown
similarity index 96%
rename from _posts/2012-11-18-elixir-v0-7-1-released-and-the-end-of-a-journey.markdown
rename to _posts/2012-11-18-elixir-v0-7-1-released.markdown
index 6a5b60ce7..bfe465b6d 100644
--- a/_posts/2012-11-18-elixir-v0-7-1-released-and-the-end-of-a-journey.markdown
+++ b/_posts/2012-11-18-elixir-v0-7-1-released.markdown
@@ -1,6 +1,6 @@
 ---
 layout: post
-title: Elixir v0.7.1 released and the end of a journey
+title: Elixir v0.7.1 released
 author: José Valim
 category: Releases
 excerpt: Elixir v0.7.1 was released to celebrate the end of a two months journey traveling around Europe, United States and Brazil talking about Elixir.
diff --git a/_posts/2013-08-08-elixir-design-goals.markdown b/_posts/2013-08-08-elixir-design-goals.markdown
index d69e5a38b..f62442ac8 100644
--- a/_posts/2013-08-08-elixir-design-goals.markdown
+++ b/_posts/2013-08-08-elixir-design-goals.markdown
@@ -88,7 +88,7 @@ This simple example illustrates how a developer can leverage macros to provide a
 
 Those examples are just scratching the surface of what can be achieved with macros in Elixir. For example, we are currently using macros to compile routes from a web application into a bunch of patterns that are highly optimizable by the VM, providing an expressive but heavily optimized routing algorithm.
 
-The macro system also caused a huge imapct on the syntax, which we will discuss briefly before moving to the last goal.
+The macro system also caused a huge impact on the syntax, which we will discuss briefly before moving to the last goal.
 
 ### Syntax
 
diff --git a/_posts/2013-12-11-elixir-s-new-continuable-enumerators.markdown b/_posts/2013-12-11-elixir-s-new-continuable-enumerators.markdown
new file mode 100644
index 000000000..717e04aeb
--- /dev/null
+++ b/_posts/2013-12-11-elixir-s-new-continuable-enumerators.markdown
@@ -0,0 +1,213 @@
+---
+layout: post
+title: Elixir's new continuable enumerators
+author: Peter Minten
+category: Internals
+excerpt: In 0.12.0 Elixir's enumerators have gained the ability to suspend value
+         production and to terminate early.
+---
+
+As you may have heard in the upcoming 0.12.0 release Elixir's enumerators gained
+some new features. In this blog post I'll explain what's new, what it enables
+and how it works.
+
+For those of you who use the development version of Elixir these changes are
+already available. For the exact differences in code you can look at the
+[relevant pull request](https://github.com/elixir-lang/elixir/pull/1922).
+
+## A recap of enumerators, and some terminology
+
+The basic idea of enumerators is that you traverse some data structure or
+resource (lines from a file) by putting the thing that is traversed in control.
+That is if you're reading from a file you have a loop that reads lines from a
+file and for each line calls a function. Just calling a function isn't all that
+useful for most tasks as there'd be no way to remember previous lines (ugly
+hacks aside), so some accumulator value is passed to the function and a new
+accumulator is returned by it.
+
+For example here's how you can count the total length of strings in a list.
+
+```elixir
+Enumerable.reduce(l, 0, fn x, acc -> String.length(x) + acc end)
+```
+
+Often the actual call to `Enumerable.reduce/3` is hidden inside another
+function.  Say that we want to define a `sum` function. The usual way is to
+write it like this:
+
+```elixir
+def sum(coll) do
+  Enumerable.reduce(coll, 0, fn x, acc -> x + acc end)
+end
+```
+
+This could get called as `Enum.map(1..10, &(&1 * &1)) |> sum()` to get the sum of
+squares. Desugaring this means `sum(Enum.map(1..10, &(&1 * &1)))`.
+
+The general pattern is this:
+
+```elixir
+def outer_function(coll, ...) do
+  ...
+  Enumerable.reduce(coll, initial_consumer_acc, consumer)
+  ...
+end
+
+something_that_returns_an_enumerable(...) |> outer_function(...)
+```
+
+You'll notice the slightly uncommon terminology of "outer function" and
+"consumer" (normally called an "iteratee"). That's intentional, naming an
+iteratee a consumer better reflects that it consumes values.
+
+Along the same lines I call the reduce function for a specific enumerable a
+producer, it produces values which are given to a consumer.
+
+The outer function is the function to which the enumerable is passed.
+Syntactically it looks like this is the consumer, but it's really a function
+that combines the producer and the consumer. For simple consumers (say `fn x,
+acc -> length(x) + acc end`) the consumer will often be written directly in the
+source text of the outer function, but let's try to keep those concepts
+distinguished.
+
+## Two issues with classic Elixir enumerators
+
+Enumerators are great, but they have their limitations. One issue is that it's
+not possible to define a function that only returns at most 3 elements without
+traversing all elements or using ugly tricks such as `throw` (with a
+`try...catch` construct in the outer function). The `throw` trick is used in
+`Enum` and `Stream` to implement functions such as `Enum.take/2` and
+`Stream.take_while/2`. It works, but it's not what I'd call stylish.
+
+A bigger problem, that doesn't have a workaround, is that there's no way to
+interleave two enumerables. That is, it's not possible to define a function that
+for two enumerables `A` and `B` returns a list `[A1, B1, A2, B2, A3, ...]`
+(where `A1` is the first element of A) without first traversing both lists and
+then interleaving the collected values. Interleaving is important because it's
+the basis of a zip function. Without interleaving you cannot implement
+`Stream.zip/2`.
+
+The underlying problem, in both cases, is that the producer is fully in control.
+The producer simply pushes out as many elements to the consumer as it wants and
+then says "I'm done". There's no way aside from `throw`/`raise` for a consumer
+to tell a producer "stop producing". There is definitely no way to tell a
+producer "stop for now but be prepared to continue where you left off later".
+
+## Power to the consumer!
+
+At CodeMeshIO José Valim and Jessica Kerr sat down and discussed this problem.
+They came up with a solution inspired by a [Monad.Reader
+article](http://themonadreader.files.wordpress.com/2010/05/issue16.pdf) (third
+article). It's an elegant extension of the old system, based on a simple idea.
+Instead of returning only an accumulator at every step (for every produced
+value) the consumer returns a combination of an accumulator and an instruction
+to the producer. Three instructions are available:
+
+* `:cont` - Keep producing.
+* `:halt` - Stop producing.
+* `:suspend` - Temporarily stop producing.
+
+A consumer that always returns `:cont` makes the producer behave exactly the
+same as in the old system. A consumer may return `:halt` to have the producer
+terminate earlier than it normally would.
+
+The real magic is in `:suspend` though. It tells a producer to return the
+accumulator and a continuation function. 
+
+```elixir
+{ :suspended, n_, cont } = Enumerable.reduce(1..5, { :cont, 0 }, fn x, n ->
+  if x == 3 do
+    { :suspend, n }
+  else
+    { :cont, n + x }
+  end
+end)
+```
+
+After running this code `n_` will be `3` (1 + 2) and `cont` will be a
+function. We'll get back to `cont` in a minute but first take a look at some of
+the new elements here. The initial accumulator has an instruction as well, so
+you could suspend or halt a producer immediately, if you really want to. The
+value passed to the consumer (`n`) does not contain the instruction. The return
+value of the producer also has a symbol in it. Like with the instructions of
+consumers there are three possible values:
+
+* `:done` - Completed normally.
+* `:halted` - Consumer returned a `:halt` instruction.
+* `:suspended` - Consumer return a `:suspend` instruction.
+
+Together with the other values returned the possible return values from a
+producer are `{ :done, acc } | { :halted, acc } | { :suspended, acc,
+continuation }`.
+
+Back to the continuation. A continuation is a function that given an accumulator
+returns a new producer result. In other words it's a way to swap out the
+accumulator but keep the same producer in the same state.
+
+## Implementing `interleave`
+
+Using the power of suspension it is now possible to create an interleave
+function.
+
+```elixir
+defmodule Interleave do
+  def interleave(a, b) do
+    step = fn x, acc -> { :suspend, [x|acc] } end
+    af = &Enumerable.reduce(a, &1, step)
+    bf = &Enumerable.reduce(b, &1, step)
+    do_interleave(af, bf, []) |> :lists.reverse()
+  end
+
+  defp do_interleave(a, b, acc) do
+    case a.({ :cont, acc }) do
+      { :suspended, acc, a } ->
+        case b.({ :cont, acc }) do
+          { :suspended, acc, b } ->
+            do_interleave(a, b, acc)
+          { :halted, acc } ->
+            acc
+          { :done, acc } ->
+            finish_interleave(a, acc)
+        end
+      { :halted, acc } ->
+        acc
+      { :done, acc } ->
+        finish_interleave(b, acc)
+    end
+  end
+
+  defp finish_interleave(a_or_b, acc) do
+    case a_or_b.({ :cont, acc }) do
+      { :suspended, acc, a_or_b } ->
+        finish_interleave(a_or_b, acc)
+      { _, acc } ->
+        acc
+    end
+  end
+end
+
+Interleave.interleave([1,2], [:a, :b, :c, :d])
+#=> [1, :a, 2, :b, :c, :d]
+```
+
+Lets go through this step by step. The main `interleave` function first
+partially applies `Enumerable.reduce/3` to get function values that work just
+like the continuations. This makes things easier for `do_interleave`.
+
+The `do_interleave` function first calls `a` (`af` from `interleave`) with the
+`step` function so that the available element of `a` gets added to the
+accumulator and `a` immediately suspends afterwards. Then the same is done for
+`b`. If either producer is done all the remaining elements of the other get
+added to the accumulator list.
+
+Note that `acc` is sometimes used to mean a tuple like `{ :cont, x }` and
+sometimes the accumulator value proper. It's a bit confusing, yes.
+
+This example shows that through clever combination of an outer function
+(`do_interleave`) and an inner function `step` two producers can be interleaved.
+
+## Conclusion
+
+The new system of enumerators certainly makes things a bit more complicated but
+also adds power. I suspect many interesting and "interesting" functions can be
+built on top of it.
diff --git a/_posts/2013-12-15-elixir-v0-12-0-released.markdown b/_posts/2013-12-15-elixir-v0-12-0-released.markdown
new file mode 100644
index 000000000..200a4a5cf
--- /dev/null
+++ b/_posts/2013-12-15-elixir-v0-12-0-released.markdown
@@ -0,0 +1,52 @@
+---
+layout: post
+title: Elixir v0.12.0 released
+author: José Valim
+category: Releases
+excerpt: Elixir v0.12.0 is out with improved enumerables, build patterns and welcoming a new member to our team
+---
+
+Elixir v0.12.0 has been released with improved enumerables, build patterns and welcoming a new member to our team.
+
+## Enumerables
+
+In previous versions, the Enumerable protocol was based on reduce/fold, and while it is very efficient for operations like `map`, `reduce` and `filter`, it was sub-optimal for operations that need to halt, like `take` and `take_while`, and it made it impossible for operations like `zip` to be implemented. 
+
+In v0.12.0, Elixir's Enumerable protocol has been extended to allow suspension and halting mechanisms, making operations like `take` simpler and operations that require interleaving, like `zip`, possible.
+
+Although most users don't need to concern with the implementation of the Enumerable protocol, the side-effect is that both `Enum` and `Stream` modules have been considerably extended and improved in this release, with more than 15 new functions added to the `Stream` module.
+
+## Mix
+
+The tool that received most improvements in this release was Mix. The biggest change is that Mix no longer compiles projects in place but to the `_build` directory. For example, take the [Ecto project](https://github.com/elixir-lang/ecto) that [depends on `postgrex` and `poolboy`](https://github.com/elixir-lang/ecto/blob/master/mix.exs#L24-L25). When compiled, all the artifacts will be placed in the `_build` directory like this:
+
+```
+_build
+└── shared
+    └── lib
+        ├── ecto
+        │   └── ebin
+        |   └── priv
+        ├── poolboy
+        │   └── ebin
+        └── postgrex
+            └── ebin
+```
+
+For those familiar with Erlang's OTP, this is similar to the structure used by OTP when releasing your software. So this new structure makes our software one step close to production and guarantee it is designed correctly since day 1.
+
+This approach comes with the `:build_per_environment` option which, when set to true, creates a different build per environment (`dev`, `test`, `production` or more). Extremely useful when a project compile different artifacts depending on the compilation environment.
+
+Mix has also added support to optional dependencies and improved common patterns, like the usage of umbrella apps.
+
+## Welcome, Eric!
+
+With this release, we also want to welcome [Eric MJ](https://github.com/ericmj) to the Elixir Team. He has done fantastic work on Elixir, helping us maintain the codebase and working on many of the important features from previous releases and now many more to come.
+
+Eric is also maintainer of both [Ecto](https://github.com/elixir-lang/ecto) and [Postgrex](https://github.com/ericmj/postgrex) projects. Which are proving to be very useful to the Elixir community too!
+
+## Tidying up
+
+There were other small changes, like additions to the `Float` module and improvements the to the typespec syntax. To see the full list, please [see the CHANGELOG](https://github.com/elixir-lang/elixir/blob/v0.12.0/CHANGELOG.md).
+
+Give Elixir a try! You can start with our [getting started guide](http://elixir-lang.org/getting_started/1.html), or check out our sidebar for other learning resources.
diff --git a/_posts/2014-04-21-elixir-v0-13-0-released.markdown b/_posts/2014-04-21-elixir-v0-13-0-released.markdown
new file mode 100644
index 000000000..bf6e179a2
--- /dev/null
+++ b/_posts/2014-04-21-elixir-v0-13-0-released.markdown
@@ -0,0 +1,282 @@
+---
+layout: post
+title: Elixir v0.13.0 released, hex.pm and ElixirConf announced
+author: José Valim
+category: Releases
+excerpt: "Elixir v0.13.0 comes with substantial improvements to the language: maps, structs, comprehensiona and more. It also marks the announcement of the hex.pm package manager and the announcment of ElixirConf!"
+---
+
+Hello folks!
+
+Elixir v0.13.0 has been released. It contains changes that will effectively shape how developers will write Elixir code from now on, making it an important milestone towards v1.0! On this post we are going to cover some of those changes, the road to Elixir v1.0, as well as the announcement of [hex.pm](http://hex.pm).
+
+Before we go into the changes, let's briefly talk about ElixirConf!
+
+## ElixirConf
+
+We are excited to announce [ElixirConf](http://elixirconf.com), the first ever Elixir conference, happening July 25-26, 2014 in Austin, TX. The Call For Proposals is open and we are waiting for your talks!
+
+The registration is also open and we hope you will join us on this exciting event. We welcome Elixir developers and enthusiasts that are looking forward to be part of our thrilling community!
+
+## Summary
+
+In a nutshell, here is what new:
+
+* Elixir now runs on and requires Erlang R17;
+
+* With Erlang R17, Elixir also adds support for maps, which are key-value data structures that supports pattern matching. We'll explore maps, their features and limitations in this post;
+
+* Elixir v0.13 also provides structs, an alternative to Elixir records. Structs are more flexible than records, provide faster polymorphic operations, and still provide the same compile-time guarantees many came to love in records;
+
+* The [Getting Started guide](http://elixir-lang.org/getting_started/1.html) was rewritten from scratch. The previous guide was comprised of 7 chapters and was about to become 2 years old. The new guide features 20 chapters, it explores the new maps and structs (which are part of this release), and it goes deeper into topics like IO and File handling. It also includes an extra guide, still in development, about [Meta-Programming in Elixir](http://elixir-lang.org/getting_started/meta/1.html);
+
+* Elixir v0.13 provides a new comprehension syntax that not only works with lists, but with any [`Enumerable`](/docs/stable/Enumerable.html). The output of a comprehension is also extensible via the [`Collectable`](/docs/stable/Collectable.html) protocol;
+
+* Mix, Elixir's build tool, has been improved in order to provide better workflows when compiling projects and working with dependencies;
+
+* There are many other changes, like the addition of [StringIO](/docs/stable/StringIO.html), support for [tags and filters in ExUnit](/docs/stable/ExUnit.Case.html) and more. Please check the [CHANGELOG](https://github.com/elixir-lang/elixir/blob/v0.13.0/CHANGELOG.md) for the complete list.
+
+Even with all those improvements, Elixir v0.13.0 is backwards compatible with Elixir v0.12.5 and upgrading should be a clean process. 
+
+## Maps
+
+Maps are key-value data structures:
+
+```iex
+iex> map = %{"hello" => :world}
+%{"hello" => :world}
+iex> map["hello"]
+:world
+iex> map[:other]
+nil
+```
+
+Maps do not have a explicit ordering and keys and values can be any term.
+
+Maps can be pattern matched on:
+
+```iex
+iex> %{"hello" => world} = map
+%{"hello" => :world}
+iex> world
+:world
+iex> %{} = map
+%{"hello" => :world}
+iex> %{"other" => value} = map
+** (MatchError) no match of right hand side value
+```
+
+A map pattern will match any map that has all the keys specified in the pattern. The values for the matching keys must also match. For example, `%{"hello" => world}` will match any map that has the key `"hello"` and assign the value to `world`, while `%{"hello" => "world"}` will match any map that has the key `"hello"` with value equals to `"world"`. An empty map pattern (`%{}`) will match all maps.
+
+Developers can use the functions in the [`Map` module](/docs/stable/Map.html) to work with maps. For more information on maps and how they compare to other associative data structures in the language, please check the [Maps chapter in our new Getting Started guide](/getting_started/7.html). Elixir Sips has also released two episodes that cover maps ([part 1](http://elixirsips.com/episodes/054_maps_part_1.html) and [part 2](http://elixirsips.com/episodes/055_maps_part_2.html)).
+
+Maps also provide special syntax for creating, accessing and updating maps with atom keys:
+
+```iex
+iex> user = %{name: "josé", age: 27}
+%{name: "josé", age: 27}
+iex> user.name
+"josé"
+iex> user = %{user | name: "eric"}
+%{name: "eric", age: 27}
+iex> user.name
+"eric"
+```
+
+Both access and update syntax above expect the given keys to exist. Trying to access or update a key that does not exist raises an error:
+
+```iex
+iex> %{ user | address: [] }
+** (ArgumentError) argument error
+     :maps.update(:address, [], %{})
+```
+
+As we will see, this functionality becomes very useful when working with structs.
+
+## Structs
+
+Structs are meant to replace Elixir records. Records in Elixir are simply tuples supported by modules which store record metadata:
+
+```elixir
+defrecord User, name: nil, age: 0
+```
+
+Internally, this record is represented as the following tuple:
+
+```elixir
+# {tag, name, age}
+{User, nil, 0}
+```
+
+Records can also be created and pattern matched on:
+
+```iex
+iex> user = User[name: "josé"]
+User[name: "josé", age: 0]
+iex> user.name
+"josé"
+iex> User[name: name] = user
+User[name: "josé", age: 0]
+iex> name
+"josé"
+```
+
+Pattern matching works because the record meta-data is stored in the User module which can be accessed when building patterns.
+
+However, records came with their own issues. First of all, since records were made of data (the underlying tuple) and a module (functions/behaviour), they were frequently misused as an attempt to bundle data and behaviour together in Elixir, for example:
+
+```elixir
+defrecord User, name: nil, age: 0 do
+  def first_name(self) do
+    self.name |> String.split |> Enum.at(0)
+  end
+end
+
+User["josé valim"].first_name #=> "josé"
+```
+
+Not only that, records were often slow in protocol dispatches because every tuple can potentially be a record, sometimes leading to expensive checks at runtime.
+
+Since maps are meant to replace many cases of records in Erlang, we saw with the introduction of maps the perfect opportunity to revisit Elixir records as well. In order to understand the reasoning behind structs, let's list the features we got from Elixir records:
+
+1. A way to organize data by fields
+2. Efficient in-memory representation and operations
+3. Compile-time structures with compile-time errors
+4. The basic foundation for polymorphism in Elixir
+
+Maps naturally solve issues `1.` and `2.` above. In particular, maps that have same keys share the same key-space in memory. That's why the update operation `%{map | ...}` we have seen above is relevant: if we know we are updating an existing key, the new map created as result of the update operation can share the same key space as the old map without extra checks. For more details on why Maps are efficient, I would recommend [reading Joe's blog post on the matter](http://joearms.github.io/2014/02/01/big-changes-to-erlang.html).
+
+Structs were added to address features `3.` and `4.`. A struct needs to be explicitly defined via `defstruct`:
+
+```elixir
+defmodule User do
+  defstruct name: nil, age: 0
+end
+```
+
+Now a `User` struct can be created without a need to explicitly list all necessary fields:
+
+```iex
+iex> user = %User{name: "josé"}
+%User{name: "josé", age: 0}
+```
+
+Trying to create a struct with an unknown key raises an error during compilation:
+
+```iex
+iex> user = %User{address: []}
+** (CompileError) unknown key :unknown for struct User
+```
+
+Furthermore, every struct has a `__struct__` field which contains the struct name:
+
+```iex
+iex> user.__struct__
+User
+```
+
+The `__struct__` field is also used for polymorphic dispatch in protocols, addressing issue `4.`.
+
+It is interesting to note that structs solve both drawbacks we have earlier mentioned regarding records. Structs are purely data and polymorphic dispatch is now faster and more robust as it happens only for explicitly tagged structs.
+
+For more information on structs, check out the [Structs chapter in the getting started guide](/getting_started/15.html) (you may also want to read the new Protocols chapter after it).
+
+## Maps, structs and the future
+
+With the introduction of maps and structs, some deprecations will arrive on upcoming releases. First of all, the `ListDict` data structure is being deprecated and phased out. Records are also being deprecated from the language, although it is going to be a longer process, as many projects and Elixir itself still use records in diverse occasions.
+
+Note though only Elixir records are being deprecated. Erlang records, which are basically syntax sugar around tuples, will remain in the language for the rare cases Elixir developers need to interact with Erlang libraries that provide records. In particular, the [Record](/docs/stable/Record.html) has been updated to provide the new Record API (while keeping the old one for backwards compatibility).
+
+Finally, structs are still in active development and new features, like `@derive`, should land in upcoming Elixir releases. For those interested, the [original maps and structs proposal is still availble](https://gist.github.com/josevalim/b30c881df36801611d13).
+
+## Comprehensions
+
+Erlang R17 also introduced recursion to anonymous functions. This feature, while still not available from Elixir, allows Elixir to provide a more flexible and extensible comprehension syntax.
+
+The most common use case of a comprehension are [list comprehensions](https://en.wikipedia.org/wiki/List_comprehension). For example, we can get all the square values of elements in a list as follows:
+
+```iex
+iex> for n <- [1, 2, 3, 4], do: n * n
+[1, 4, 9, 16]
+```
+
+We say the `n <- [1, 2, 3, 4]` part is a comprehension generator. In previous Elixir versions, Elixir supported only lists in generators. In Elixir v0.13.0, any Enumerable is supported (ranges, maps, etc):
+
+```iex
+iex> for n <- 1..4, do: n * n
+[1, 4, 9, 16]
+```
+
+As in previous Elixir versions, there is also support for a bitstring generator. In the example below, we receive a stream of RGB pixels as a binary and break it down into triplets:
+
+```iex
+iex> pixels = <<213, 45, 132, 64, 76, 32, 76, 0, 0, 234, 32, 15>>
+iex> for <<r::8, g::8, b::8 <- pixels>>, do: {r, g, b}
+[{213,45,132}, {64,76,32}, {76,0,0}, {234,32,15}]
+```
+
+By default, a comprehension returns a list as a result. However the result of a comprehension can be inserted into different data structures by passing the `:into` option. For example, we can use bitstring generators with the `:into` option to easily remove all spaces in a string:
+
+```iex
+iex> for <<c <- " hello world ">>, c != ?\s, into: "", do: <<c>>
+"helloworld"
+```
+
+Sets, maps and other dictionaries can also be given with the `:into` option. In general, the `:into` accepts any structure as long as it implements the [`Collectable` protocol](/docs/stable/Collectable.html).
+
+For example, the `IO` module provides streams, that are both `Enumerable` and `Collectable`. You can implement an echo terminal that returns whatever is typed into the shell, but in upcase, using comprehensions:
+
+```iex
+iex> stream = IO.stream(:stdio, :line)
+iex> for line <- stream, into: stream do
+...>   String.upcase(line) <> "\n"
+...> end
+```
+
+This makes comprehensions useful not only for working with in-memory collections but also with files, io devices, and other sources. In future releases, we will continue exploring how to make comprehensions more expressive, following in the footsteps of other functional programming research on the topic (like Comprehensive Comprehensions and Parallel Comprehensions).
+
+## Mix workflows
+
+The last big change we want to discuss in this release are the improvements done to Mix, Elixir's build tool. Mix is an essential tool to Elixir developers and helps developers to compile their projects, manage their dependencies, run tests and so on. 
+
+In previous releases, Mix was used to download and compile dependencies per environment. That meant the usual workflow was less than ideal: every time a dependency was updated, developers had to explicitly fetch and compile the dependencies for each environment. The workflow would be something like:
+
+```
+$ mix deps.get
+$ mix compile
+$ MIX_ENV=test mix deps.get
+$ mix test
+```
+
+In Elixir v0.13, `mix deps.get` only fetches dependencies and it does so accross all environments (unless an `--only` flag is specified). To support this new behaviour, dependencies now support the `:only` option:
+
+```elixir
+def deps do
+  [{:ecto, github: "elixir-lang/ecto"},
+   {:hackney, github: "benoitc/hackney", only: [:test]}]
+end
+```
+
+Dependencies now are also automatically compiled before you run a command. For example, `mix compile` will automatically compile pending dependencies for the current environment. `mix test` will do the same for test dependencies and so on, interrupting less the developer workflow.
+
+## hex.pm
+
+This release also marks the announcement of [hex.pm](http://hex.pm/), a package manager for the Erlang VM. Hex allows you to package and publish your projects while fetching them and performing dependency resolution in your applications.
+
+Currently Hex only integrates with Mix and contributions to extend it to other tools and other languages in the Erlang VM are welcome!
+
+## The next steps
+
+As seen in this announcement, this release dictates many of the developments that will happen in Elixir and its community in the following weeks. All projects are recommended to start moving from records to structs, paving the way for the deprecation of records before 1.0.
+
+The next months will also focus on integrating Elixir more tightly to OTP. During the keynote at Erlang Factory, [Catalyse Change](http://www.youtube.com/watch?v=Djv4C9H9yz4), Dave Thomas and I argued that there are many useful patterns, re-implemented everyday by developers, that could make development more productive within the Erlang VM if exposed accordingly.
+
+That said, in the next months we plan to:
+
+* Integrate applications configuration (provided by OTP) right into Mix;
+* Provide an Elixir logger that knows how to print and format Elixir exceptions and stacktraces;
+* Properly expose the functionality provided by Applications, Supervisors, GenServers and GenEvents and study how they can integrate with Elixir. For example, how to consume events from GenEvent as a [stream of data](/docs/stable/Stream.html)?
+* Study how patterns like tasks and agents can be integrated into the language, often picking up the lessons learned by libraries like [e2](http://e2project.org/erlang.html) and [functionality exposed by OTP itself](http://erlang.org/doc/man/rpc.html);
+* Rewrite the Mix and ExUnit guides to focus on applications and OTP as a whole, rebranding it to "Building Apps with Mix and OTP";
+
+You can learn more about Elixir in our [Getting Started guide](/getting_started/1.html) and download this release in the [v0.13 announcement](https://github.com/elixir-lang/elixir/releases/tag/v0.13.0). We hope to see you at [ElixirConf](http://elixirconf.com/) as well as pushing your packages to [hex.pm](http://hex.pm/).
diff --git a/crash-course.markdown b/crash-course.markdown
index 495a16a4b..b37f6ba25 100644
--- a/crash-course.markdown
+++ b/crash-course.markdown
@@ -1,9 +1,10 @@
 ---
+title: "Erlang/Elixir Syntax: A Crash Course"
 section: home
 layout: default
 ---
 
-# Erlang/Elixir Syntax: A Crash Course
+# {{ page.title }}
 
 This is a quick introduction to the Elixir syntax for Erlang developers and vice-versa. It is the absolute minimum amount of knowledge you need in order to understand Elixir/Erlang code, support interoperability, read the docs, sample code, etc.
 
@@ -101,7 +102,6 @@ Some operators are spelled differently.
     | =/=            | !==            | A negative match                        |
     | /=             | !=             | Not equals                              |
     | =<             | <=             | Less than or equals                     |
-    | !              | <-             | Send messages                           |
 
 
 ### Delimiters
@@ -261,7 +261,7 @@ setelement(1, { a, b, c }, d) %=> { d, b, c }
 
 ```elixir
 elem({ :a, :b, :c }, 0)        #=> :a
-setelem({ :a, :b, :c }, 0, :d) #=> { :d, :b, :c }
+set_elem({ :a, :b, :c }, 0, :d) #=> { :d, :b, :c }
 ```
 
 ### Lists and Binaries
@@ -298,75 +298,81 @@ lines.
 #=> true
 ```
 
-### Regular expressions
+### Keyword list
 
-Elixir supports a literal syntax for regular expressions. Such syntax allows regexes to be compiled at compilation time instead of runtime and does not require you to double escape special regex characters:
+Elixir offers a literal syntax for creating a list of two-item tuples where the first item in the tuple is an atom and calls them keyword lists:
 
 **Erlang**
 
 ```erlang
-{ ok, Pattern } = re:compile("abc\\s").
-re:run("abc ", Pattern).
-%=> { match, ["abc "] }
+[{another_key,20},{key,10}]
 ```
 
 **Elixir**
 
 ```elixir
-Regex.run %r/abc\s/, "abc "
-#=> ["abc "]
-```
-
-Regexes are also supported in heredocs, which is convenient when defining multiline regexes:
-
-```elixir
-is_regex %r"""
-This is a regex
-spawning several
-lines.
-"""
+kw = [another_key: 20, key: 10]
+kw[:another_key] #=> 20
 ```
 
-### Keyword list
+### Maps
 
-Elixir offers a literal syntax for creating a list of two-item tuples where the first item in the tuple is an atom and calls them keyword lists:
+Erlang R17 introduced maps, a key-value store, with no ordering. Keys and values can be any term. Creating, updating and matching maps in both languages is shown below:
 
 **Erlang**
 
 ```erlang
-[{another_key,20},{key,10}]
+Map = #{key => 0}
+Updated = Map#{key := 1}
+#{key := Value} = Updated
+Value =:= 1
 ```
 
 **Elixir**
 
 ```elixir
-kw = [another_key: 20, key: 10]
-kw[:another_key] #=> 20
+map = %{:key => 0}
+map = %{map | :key => 1}
+%{:key => value} = map
+value === 1
 ```
 
-### Records
+If the keys are all atoms, Elixir allows developers to use `key: 0` for defining the map as well as using `.key` for accessing fields:
 
-The syntax for records differs significantly between Erlang and Elixir. Please refer to [this section][1] in the Erlang book to read a detailed introduction to records in Erlang. And [this chapter][2] from Elixir's Getting Started guide provides a description of records in Elixir.
+```elixir
+map = %{key: 0}
+map = %{map | key: 1}
+map.key === 1
+```
 
-[1]: http://learnyousomeerlang.com/a-short-visit-to-common-data-structures#records
-[2]: http://elixir-lang.org/getting_started/4.html
+### Regular expressions
 
-In order to translate Erlang records into Elixir records, use `Record.extract()`. For example, to use the `ec2_instance_spec` record from [erlcloud][8]:
+Elixir supports a literal syntax for regular expressions. Such syntax allows regexes to be compiled at compilation time instead of runtime and does not require you to double escape special regex characters:
 
-```elixir
-defrecord :ec2_instance_spec, Record.extract(:ec2_instance_spec,
-                                from: "deps/erlcloud/include/erlcloud_ec2.hrl")
+**Erlang**
+
+```erlang
+{ ok, Pattern } = re:compile("abc\\s").
+re:run("abc ", Pattern).
+%=> { match, ["abc "] }
+```
 
-new_host = :ec2_instance_spec.new(
-    image_id:          "ami-6d3f9704",
-    instance_type:     "t1.micro",
-    availability_zone: "us-east-1b"
-)
+**Elixir**
 
-IO.puts inspect(new_host)
+```elixir
+Regex.run ~r/abc\s/, "abc "
+#=> ["abc "]
 ```
 
-[8]: https://github.com/gleber/erlcloud/blob/master/include/erlcloud_ec2.hrl#L11
+Regexes are also supported in heredocs, which is convenient when defining multiline regexes:
+
+```elixir
+is_regex ~r"""
+This is a regex
+spawning several
+lines.
+"""
+```
 
 <div id="modules"></div>
 
@@ -376,14 +382,14 @@ Each Erlang module lives in its own file which has the following structure:
 
 ```erlang
 -module(hello_module).
--export([some_fun/0, fun/1]).
+-export([some_fun/0, some_fun/1]).
 
 % A "Hello world" function
 some_fun() ->
   io:format('~s~n', ['Hello world!']).
 
 % This one works only with lists
-fun(List) when is_list(List) ->
+some_fun(List) when is_list(List) ->
   io:format('~s~n', List).
 
 % Non-exported functions are private
@@ -566,7 +572,7 @@ sum "a", "b"
 In addition, Elixir allows for default values for arguments, whereas Erlang does not.
 
 ```elixir
-def mul_by(x, n // 2) do
+def mul_by(x, n \\ 2) do
   x * n
 end
 
@@ -815,7 +821,7 @@ end.
 ```elixir
 pid = Kernel.self
 
-pid <- { :hello }
+send pid, { :hello }
 
 receive do
   { :hello } -> :ok
diff --git a/css/style.css b/css/style.css
index a499b6dd0..b5013362f 100644
--- a/css/style.css
+++ b/css/style.css
@@ -42,16 +42,6 @@ body {
 #container {
   background-color: #FFF;
 }
-::-moz-selection {
-  background: #000;
-  color: #fff;
-  text-shadow: none;
-}
-::selection {
-  background: #000;
-  color: #fff;
-  text-shadow: none;
-}
 a, a:visited {
   color: #4E2A8E;
   text-decoration: underline;
@@ -578,6 +568,7 @@ body.source           div.menu li.source          a {
   height: 150px;
   margin: 3px 25px 20px 0;
 }
+.no-border { border: 0 };
 
 /* Post titles
 -------------------------------------------------------------- */
diff --git a/docs.html b/docs.html
index 4c6afd2e5..73716c250 100644
--- a/docs.html
+++ b/docs.html
@@ -1,4 +1,5 @@
 ---
+title: Elixir Documentation
 section: docs
 layout: default
 ---
diff --git a/getting_started/1.markdown b/getting_started/1.markdown
index f4e711fca..90b31d259 100644
--- a/getting_started/1.markdown
+++ b/getting_started/1.markdown
@@ -1,37 +1,38 @@
 ---
 layout: getting_started
-title: 1 Introduction
+title: 1 Interactive Elixir
 guide: 1
-total_guides: 7
 ---
 
 # {{ page.title }}
 
-Welcome! In this tutorial we are going to show you how to get started with Elixir. We will start with how to install Elixir, how to use its interactive shell, basic data types and operators. In later chapters, we are going to discuss more advanced subjects such as macros, protocols and other features provided by Elixir.
+Welcome!
 
-To see Elixir in action, check out these introductory screencasts by Dave Thomas. The first one, [Nine Minutes of Elixir](http://www.youtube.com/watch?v=hht9s6nAAx8), provides a brief tour of the language. The second one is a 30-minute [introduction to Elixir](http://www.youtube.com/watch?v=a-off4Vznjs) that'll help you get started writing your first functions and creating your first processes in Elixir. Be sure to follow the next section of this guide to install Elixir on your machine and then follow along with the videos.
+In this tutorial we are going to show you how to get started with Elixir. This chapter will cover installation and how to get started with the Interactive Elixir shell called IEx.
 
-PeepCode also has a two hour video with Jos&eacute; Valim called [Meet Elixir](https://peepcode.com/products/elixir).
+If you find any errors in the tutorial or on the website, [please report a bug or send a pull request to our issue tracker](https://github.com/elixir-lang/elixir-lang.github.com). If you suspect it is a language bug, [please let us know in the language issue tracker](https://github.com/elixir-lang/elixir/issues).
 
-Keep in mind that Elixir is still in development, so if at any point you receive an error message and you are not sure how to proceed, [please let us know in the issues tracker](https://github.com/elixir-lang/elixir/issues). Having explanative and consistent error messages is one of the many features we aim for in Elixir.
+Let's get started!
 
-## 1.1 Installation
+## 1.1 Installing Erlang
 
-The only prerequisite for Elixir is Erlang, version R16B or later. You can find the source code for [Erlang here](http://www.erlang.org/download.html) or use one of the [precompiled packages](https://www.erlang-solutions.com/downloads/download-erlang-otp).
+The only prerequisite for Elixir is Erlang, version 17.0 or later, which can be easily installed with [Precompiled packages](https://www.erlang-solutions.com/downloads/download-erlang-otp). In case you want to install it directly from source, it can be found on [the Erlang website](http://www.erlang.org/download.html) or by following the excellent tutorial available in the [Riak documentation](http://docs.basho.com/riak/1.3.0/tutorials/installation/Installing-Erlang/).
 
-For Windows developers, we recommend the precompiled package. Those on a UNIX platform can probably get Erlang installed via one of the many package management tools.
+For Windows developers, we recommend the precompiled packages. Those on a UNIX platform can probably get Erlang installed via one of the many package management tools.
+
+> Note: Although many package management tools provide Erlang, Elixir requires Erlang 17 which has been released just recently. So have that in mind before picking your Erlang installation.
 
 After Erlang is installed, you should be able to open up the command line (or command prompt) and check the Erlang version by typing `erl`. You will see some information as follows:
 
-    Erlang R16B (erts-5.10.1) [source] [64-bit] [smp:2:2] [rq:2] [async-threads:0] [hipe] [kernel-poll:false]
+    Erlang/OTP 17 (erts-6) [64-bit] [smp:2:2] [async-threads:0] [hipe] [kernel-poll:false]
 
-Notice that depending on how you installed Erlang, it will not add Erlang binaries to your environment. Be sure to have Erlang binaries in your [PATH](http://en.wikipedia.org/wiki/Environment_variable), otherwise Elixir won't work!
+Notice that depending on how you installed Erlang, Erlang binaries won't be available in your PATH. Be sure to have Erlang binaries in your [PATH](http://en.wikipedia.org/wiki/Environment_variable), otherwise Elixir won't work!
 
 After Erlang is up and running, it is time to install Elixir. You can do that via Distributions, Precompiled package or Compiling from Source.
 
-### 1.1.1 Distributions
+### 1.2 Distributions
 
-This tutorial requires Elixir v0.10.2 or later and it may be available in some distributions:
+This tutorial requires Elixir v0.13 or later and it may be available in some distributions:
 
 * Homebrew for Mac OS X
   * Update your homebrew to latest with `brew update`
@@ -50,9 +51,13 @@ This tutorial requires Elixir v0.10.2 or later and it may be available in some d
 
 If you don't use any of the distributions above, don't worry, we also provide a precompiled package!
 
-### 1.1.2 Compiling from source (Unix and MinGW)
+### 1.3 Precompiled package
+
+Elixir provides a [precompiled package for every release](https://github.com/elixir-lang/elixir/releases/). After downloading and unzip-ing the package, you are ready to run the `elixir` and `iex` commands from the `bin` directory. It is recommended that you also add Elixir's `bin` path to your PATH environment variable to ease development.
+
+### 1.4 Compiling from source (Unix and MinGW)
 
-You can download and compile Elixir in few steps. You can get the [latest stable release here](https://github.com/elixir-lang/elixir/tags), unpack it and then run `make` inside the unpacked directory. After that, you are ready to run the `elixir` and `iex` commands from the `bin` directory. It is recommended that you add Elixir's `bin` path to your PATH environment variable to ease development:
+You can download and compile Elixir in few steps. You can get the [latest stable release here](https://github.com/elixir-lang/elixir/releases/), unpack it and then run `make` inside the unpacked directory. After that, you are ready to run the `elixir` and `iex` commands from the `bin` directory. It is recommended that you add Elixir's `bin` path to your PATH environment variable to ease development:
 
     $ export PATH="$PATH:/path/to/elixir/bin"
 
@@ -64,246 +69,19 @@ In case you are feeling a bit more adventurous, you can also compile from master
 
 If the tests pass, you are ready to go. Otherwise, feel free to open an issue [in the issues tracker on Github](https://github.com/elixir-lang/elixir).
 
-### 1.1.3 Precompiled package
-
-Elixir provides a [precompiled package for every release](https://github.com/elixir-lang/elixir/releases/). Precompiled packages are the best option if you are developing on Windows.
-
-After downloading and unzip-ing the package, you are ready to run the `elixir` and `iex` commands from the `bin` directory. It is recommended that you also add Elixir's `bin` path to your PATH environment variable to ease development.
-
-## 1.2 Interactive mode
+## 1.5 Interactive mode
 
 When you install Elixir, you will have three new executables: `iex`, `elixir` and `elixirc`. If you compiled Elixir from source or are using a packaged version, you can find these inside the `bin` directory.
 
-For now, let's start by running `iex` which stands for Interactive Elixir. In interactive mode, we can type any Elixir expression and get its result straight away. Let's warm up with some basic arithmetic expressions:
-
-```iex
-iex> 1 + 1
-2
-iex> 10 - 5
-5
-iex> 10 / 2
-5.0
-```
-
-Notice `10 / 2` returned a float `5.0` instead of an integer. This is expected. In Elixir the operator `/` always returns a float. If you want to do integer division or get the division remainder, you can invoke the `div` and `rem` functions:
-
-```iex
-iex> div(10, 2)
-5
-iex> div 10, 2
-5
-iex> rem 10, 3
-1
-```
+For now, let's start by running `iex` which stands for Interactive Elixir. In interactive mode, we can type any Elixir expression and get its result straight away. Let's warm up with some basic expressions:
 
-In the example above, we called two functions called `div` and `rem`. Notice that parentheses are not required in order to invoke a function. We are going to discuss more about this later. Let's move forward and see what other data types we have in Elixir.
+```text
+Interactive Elixir - press Ctrl+C to exit (type h() ENTER for help)
 
-## 1.3 Basic types
-
-Some basic types are:
-
-```iex
-iex> 1          # integer
-iex> 0x1F       # integer
-iex> 1.0        # float
-iex> :atom      # atom / symbol
-iex> {1,2,3}    # tuple
-iex> [1,2,3]    # list
-iex> <<1,2,3>>  # bitstring
-```
-
-Elixir by default imports many functions to work on these types:
-
-```iex
-iex> size { 1, 2, 3 }
-3
-
-iex> length [ 1, 2, 3 ]
-3
-```
-
-Elixir also supports UTF-8 encoded strings:
-
-```iex
-iex> "hellö"
-"hellö"
-```
-
-Strings support interpolation, too:
-
-```iex
-iex> name = "world"
-iex> "hello #{name}"
+iex> 40 + 2
+42
+iex> "hello" <> " world"
 "hello world"
 ```
 
-At the end of the day, strings are nothing more than a bunch of bytes packed together. We can verify this using the `is_binary` function:
-
-```iex
-iex> is_binary("hello")
-true
-iex> byte_size("hello")
-5
-```
-
-And a binary is nothing more than a bunch of bits packed together:
-
-```iex
-iex> is_bitstring("hello")
-true
-iex> bit_size("hello")
-40
-```
-
-Elixir allows you to create "raw" binaries too. Let's create a binary with three null bytes:
-
-```iex
-iex> is_binary <<0, 0, 0>>
-true
-```
-
-Note that a single-quoted expression in Elixir is a char list and is not the same as a double-quoted one:
-
-```iex
-iex> is_binary('hello')
-false
-iex> is_list('hello')
-true
-```
-
-We will go into more details about char lists in the next chapter. Elixir also provides `true` and `false` as booleans:
-
-```iex
-iex> true
-true
-iex> is_boolean false
-true
-```
-
-Booleans are represented internally as atoms:
-
-```iex
-iex> is_atom(true)
-true
-```
-
-Elixir also provides anonymous functions (note the dot between the variable and arguments when calling an anonymous function):
-
-```iex
-# function
-iex> x = fn(a, b) -> a + b end
-#Fun<erl_eval.12.111823515>
-iex> x.(1, 2)
-3
-```
-
-Elixir also provides `Port`, `Reference`s and `PID`s as data types (usually used in process communication), but they are out of the scope of a getting started tutorial. For now, let's take a look at the basic operators in Elixir before we move on to the next chapter.
-
-## 1.4 Operators
-
-As we saw earlier, Elixir provides `+`, `-`, `*`, `/` as arithmetic operators.
-
-Elixir also provides `++` and `--` to manipulate lists:
-
-```iex
-iex> [1,2,3] ++ [4,5,6]
-[1,2,3,4,5,6]
-iex> [1,2,3] -- [2]
-[1,3]
-```
-
-String concatenation is done via `<>`:
-
-```iex
-iex> "foo" <> "bar"
-"foobar"
-```
-
-Elixir also provides three boolean operators: `or`, `and` and `not`. These operators are strict in the sense that they expect a boolean (`true` or `false`) as their first argument:
-
-```iex
-iex> true and true
-true
-iex> false or is_atom(:example)
-true
-```
-
-Providing a non-boolean will raise an exception:
-
-```iex
-iex> 1 and true
-** (ArgumentError) argument error
-```
-
-`or` and `and` are short-circuit operators. They only execute the right side if the left side is not enough to determine the result:
-
-```iex
-iex> false and error("This error will never be raised")
-false
-
-iex> true or error("This error will never be raised")
-true
-```
-
-> Note: If you are an Erlang developer, `and` and `or` in Elixir actually map to the `andalso` and `orelse` operators in Erlang.
-
-Besides these boolean operators, Elixir also provides `||`, `&&` and `!` which accept arguments of any type. For these operators, all values except `false` and `nil` will evaluate to true:
-
-```iex
-# or
-iex> 1 || true
-1
-iex> false || 11
-11
-
-# and
-iex> nil && 13
-nil
-iex> true && 17
-17
-
-# !
-iex> !true
-false
-iex> !1
-false
-iex> !nil
-true
-```
-
-As a rule of thumb, use `and`, `or` and `not` when you are expecting booleans. If any of the arguments are non-boolean, use `&&`, `||` and `!`.
-
-Elixir also provides `==`, `!=`, `===`, `!==`, `<=`, `>=`, `<` and `>` as comparison operators:
-
-```iex
-iex> 1 == 1
-true
-iex> 1 != 2
-true
-iex> 1 < 2
-true
-```
-
-The difference between `==` and `===` is that the latter is more strict when comparing integers and floats:
-
-```iex
-iex> 1 == 1.0
-true
-iex> 1 === 1.0
-false
-```
-
-In Elixir, we can compare two different data types:
-
-```iex
-iex> 1 < :atom
-true
-```
-
-The reason we can compare different data types is for pragmatism. Sorting algorithms don't need to worry about different data types in order to sort. The overall sorting order is defined below:
-
-    number < atom < reference < functions < port < pid < tuple < list < bitstring
-
-You don't actually need to memorize this ordering, but it is important just to know an order exists.
-
-Well, that is it for the introduction. In the next chapter, we are going to discuss some basic functions, data types conversions and a bit of control-flow.
+It seems we are ready to go! We will use the interactive shell quite a lot in the next chapters to get a bit more familiar with the language constructs and basic types, starting in the next chapter.
\ No newline at end of file
diff --git a/getting_started/10.markdown b/getting_started/10.markdown
new file mode 100644
index 000000000..0a5209f40
--- /dev/null
+++ b/getting_started/10.markdown
@@ -0,0 +1,112 @@
+---
+layout: getting_started
+title: 10 Enumerables and Streams
+guide: 10
+---
+
+# {{ page.title }}
+
+## 10.1 Enumerables
+
+Elixir provides the concept of enumerables and [the `Enum` module](/docs/stable/Enum.html) to work with them. We have already learned two enumerables: lists and maps.
+
+```iex
+iex> Enum.map([1, 2, 3], fn x -> x * 2 end)
+[2, 4, 6]
+iex> Enum.map(%{1 => 2, 3 => 4}, fn {k, v} -> k * v end)
+[2, 12]
+```
+
+The `Enum` module provides a huge range of functions to transform, sort, group, filter and retrieve items from enumerables. It is one of the modules developers use frequently in their Elixir code.
+
+Elixir also provides ranges:
+
+```iex
+iex> Enum.map(1..3, fn x -> x * 2 end)
+[2, 4, 6]
+iex> Enum.reduce(1..3, 0, &+/2)
+6
+```
+
+Since the Enum module was designed to work across different data types, its API is limited to functions that are useful across many data types. For specific operations, you may need to reach to modules specific to the data types. For example, if you want to insert an element at a given position in a list, you should use the `List.insert_at/3` function from [the `List` module](/docs/stable/List.html), as it would make little sense to insert a value into, for example, a range.
+
+We say the functions in the `Enum` module are polymorphic because they can work with diverse data types. In particular, the functions in the `Enum` module can work with any data type that implements [the `Enumerable` protocol](/docs/stable/Enumerable.html). We are going to discuss Protocols in a later chapter, for now we are going to move on to a specific kind of enumerable called streams.
+
+## 10.2 Eager vs Lazy
+
+All the functions in the `Enum` module are eager. Many functions expect an enumerable and return a list back:
+
+```iex
+iex> odd? = &(rem(&1, 2) != 0)
+#Function<6.80484245/1 in :erl_eval.expr/5>
+iex> Enum.filter(1..3, odd?)
+[1, 3]
+```
+
+This means that when performing multiple operations with `Enum`, each operation is going to generate an intermediate list until we reach the result:
+
+```iex
+iex> 1..100_000 |> Enum.map(&(&1 * 3)) |> Enum.filter(odd?) |> Enum.sum
+7500000000
+```
+
+The example above has a pipeline of operations. We start with a range and then multiply each element in the range by 3. This first operation will now create and return a list with `100_000` items. Then we keep all odd elements from the list, generating a new list, now with `50_000` items, and then we sum all entries.
+
+As an alternative, Elixir provides [the `Stream` module](/docs/stable/Stream.html) which supports lazy operations:
+
+```iex
+iex> 1..100_000 |> Stream.map(&(&1 * 3)) |> Stream.filter(odd?) |> Enum.sum
+7500000000
+```
+
+Instead of generating intermediate lists, streams create a series of computations that are invoked only when we pass it to the `Enum` module. Streams are useful when working with large, *possibly infinite*, collections.
+
+## 10.3 Streams
+
+Streams are lazy, composable enumerables.
+
+They are lazy because, as shown in the example above, `1..100_000 |> Stream.map(&(&1 * 3))` returns a data type, an actual stream, that represents the `map` computation over the range `1..100_000`:
+
+```iex
+iex> 1..100_000 |> Stream.map(&(&1 * 3))
+#Stream<1..100_000, funs: [#Function<34.16982430/1 in Stream.map/2>]>
+```
+
+Furthermore, they are composable because we can pipe many stream operations:
+
+```iex
+iex> 1..100_000 |> Stream.map(&(&1 * 3)) |> Stream.filter(odd?)
+#Stream<1..100_000, funs: [...]>
+```
+
+Many functions in the `Stream` module accept any enumerable as argument and return a stream as result. It also provides functions for creating streams, possibly infinite. For example, `Stream.cycle/1` can be used to create a stream that cycles a given enumerable infinitely. Be careful to not call a function like `Enum.map/2` on such streams, as they would cycle forever:
+
+```iex
+iex> stream = Stream.cycle([1, 2, 3])
+#Function<15.16982430/2 in Stream.cycle/1>
+iex> Enum.take(stream, 10)
+[1, 2, 3, 1, 2, 3, 1, 2, 3, 1]
+```
+
+On the other hand, `Stream.unfold/2` can be used to generate values from a given initial value:
+
+```iex
+iex> stream = Stream.unfold("hełło", &String.next_codepoint/1)
+#Function<15.16982430/2 in Stream.cycle/1>
+iex> Enum.take(stream, 3)
+["h", "e", "ł"]
+```
+
+Another interesting function is `Stream.resource/3` which can be used to wrap around resources, guaranteeing they are opened right before enumeration and closed afterwards, even in case of failures. For example, we can use it to stream a file:
+
+```iex
+iex> stream = File.stream!("path/to/file")
+#Function<18.16982430/2 in Stream.resource/3>
+iex> Enum.take(stream, 10)
+```
+
+The example above will fetch the first 10 lines of the file you have selected. This means streams can be very useful for handling large files or even slow resources like network resources.
+
+The amount of functions and functionality in [`Enum`](/docs/stable/Enum.html) and [`Stream`](/docs/stable/Stream.html) modules can be daunting at first but you will get familiar with them case by case. In particular, focus on the `Enum` module first and only move to `Stream` for the particular scenarios where laziness is required to either deal with slow resources or large, possibly infinite, collections.
+
+Next we'll look at a feature central to Elixir, Processes, which allows us to write concurrent, parallel and distributed programs in an easy and understandable way.
diff --git a/getting_started/11.markdown b/getting_started/11.markdown
new file mode 100644
index 000000000..a4d665273
--- /dev/null
+++ b/getting_started/11.markdown
@@ -0,0 +1,136 @@
+---
+layout: getting_started
+title: 11 Processes
+guide: 11
+---
+
+# {{ page.title }}
+
+In Elixir, all code runs inside processes. Processes are isolated from each other, run concurrent to one another and communicate via message passing. Processes are not only the basis for concurrency in Elixir, but they also provide the means for building distributed and fault-tolerant programs.
+
+Elixir's processes should not be confused with operating system processes. Processes in Elixir are extremely lightweight in terms of memory and CPU (unlike threads in many other programming languages). Because of this, it is not uncommon to have dozens of thousands of processes running simultaneously.
+
+In this chapter, we will learn about the basic constructs for spawning new processes, as well as sending and receiving messages between different processes.
+
+## 11.1 spawn
+
+The basic mechanism for spawning new processes is with the auto-imported `spawn/1` function:
+
+```iex
+iex> spawn fn -> 1 + 2 end
+#PID<0.43.0>
+```
+
+`spawn/1` takes a function which it will execute in another process.
+
+Notice `spawn/1` returns a PID (process identifier). At this point, the process you spawned is very likely dead. The spawned process will execute the given function and exit after the function is done:
+
+```iex
+iex> pid = spawn fn -> 1 + 2 end
+#PID<0.44.0>
+iex> Process.alive?(pid)
+false
+```
+
+> Note: you will likely get different process identifiers than the ones we are getting in this guide.
+
+We can retrieve the PID of the current process by calling `self/0`:
+
+```iex
+iex> self()
+#PID<0.41.0>
+iex> Process.alive?(self())
+true
+```
+
+Processes get much more interesting when we are able to send and receive messages.
+
+## 11.2 send and receive
+
+We can send messages to a process with `send/2` and receive them with `receive/1`:
+
+```iex
+iex> send self(), {:hello, "world"}
+{:hello, "world"}
+iex> receive do
+...>   {:hello, msg}  -> msg
+...>   {:world, msg} -> "won't match"
+...> end
+"world"
+```
+
+When a message is sent to a process, the message is stored in the process mailbox. The `receive/2` block goes through the current process mailbox searching for a message that matches any of the given patterns. `receive/1` supports many clauses, like `case/2`, as well as guards in the clauses.
+
+If there is no message in the mailbox matching any of the patterns, the current process will wait until a matching message arrives. A timeout can also be specified:
+
+```iex
+iex> receive do
+...>   {:hello, msg}  -> msg
+...> after
+...>   1_000 -> "nothing after 1s"
+...> end
+"nothing after 1s"
+```
+
+A timeout of 0 can be given when you already expect the message to be in the mailbox.
+
+Let's put all together and send messages in between processes:
+
+```iex
+iex> parent = self()
+#PID<0.41.0>
+iex> spawn fn -> send(parent, {:hello, self()}) end
+#PID<0.48.0>
+iex> receive do
+...>   {:hello, pid} -> "Got hello from #{inspect pid}"
+...> end
+"Got hello from #PID<0.48.0>"
+```
+
+While in the shell, you may find the helper `flush/0` quite useful. It flushes and prints all the messages in the mailbox.
+
+```iex
+iex> send self(), :hello
+:hello
+iex> flush()
+:hello
+:ok
+```
+
+Before we finish this chapter, let's talk about process links.
+
+## 11.3 Links
+
+The most common form of spawning in Elixir is actually via `spawn_link/1`. Before we show an example with `spawn_link/1`, let's try to see what happens when a process fails:
+
+```iex
+iex> spawn fn -> raise "oops" end
+#PID<0.58.0>
+```
+
+Well... nothing happened. That's because processes are isolated. If we want the failure in one process to propagate to another one, we should link them. This can be done with `spawn_link/1`:
+
+```iex
+iex> spawn_link fn -> raise "oops" end
+#PID<0.60.0>
+** (EXIT from #PID<0.60.0>) {RuntimeError[message: "oops"], [{:erlang, :apply, 2, []}]}
+```
+
+When a failure happens in the shell, the shell automatically traps the failure and shows it nicely formatted. In order to understand what would really happen in our code, let's use `spawn_link/1` inside a file and run it:
+
+```iex
+# spawn.exs
+spawn_link fn -> raise "oops" end
+
+receive do
+  :hello -> "let's wait until the process fails"
+end
+```
+
+This time the process failed and brought the parent process down as they are linked. Linking can also be done manually by calling `Process.link/2`. We recommend you to take a look at [the `Process` module](/docs/stable/Process.html) for other functionality provided by processes.
+
+Process and links play an important role when building fault-tolerant systems. In Elixir applications we often link our processes to supervisors which will detect when a process die and start a new process in its place. This is only possible because processes don't share anything by default so there is no way the crash of a process can corrupt the state of another process!
+
+While other languages would require us to catch/handle exceptions, in Elixir we are actually fine with letting process fail because we expect supervisors to properly restart our systems. "Failing fast" is a common philosophy when writing Elixir software!
+
+Next we'll explore the world of IO.
diff --git a/getting_started/12.markdown b/getting_started/12.markdown
new file mode 100644
index 000000000..4d36165ad
--- /dev/null
+++ b/getting_started/12.markdown
@@ -0,0 +1,175 @@
+---
+layout: getting_started
+title: 12 IO
+guide: 12
+---
+
+# {{ page.title }}
+
+This chapter is a quick introduction to input/output mechanisms in Elixir and related modules, like [`IO`](/docs/stable/IO.html), [`File`](/docs/stable/File.html) and [`Path`](/docs/stable/Path.html).
+
+We had originally sketched this chapter to come much earlier in the getting started guide. However, we noticed the IO system provides a great opportunity to shed some light on some philosophies and curiosities of Elixir and the VM.
+
+## 12.1 The IO module
+
+The `IO` module in Elixir is the main mechanism for reading and writing to the standard io (`:stdio`), standard error (`:stderr`), files and other IO devices. Usage of the module is pretty straight-forward:
+
+```iex
+iex> IO.puts "hello world"
+"hello world"
+:ok
+iex> IO.gets "yes or no? "
+yes or no? yes
+"yes\n"
+```
+
+By default, the functions in the IO module use the standard input and output. We can pass the `:stderr` as argument to write to the standard error device:
+
+```iex
+iex> IO.puts :stderr, "hello world"
+"hello world"
+:ok
+```
+
+## 12.2 The File module
+
+The [`File`](/docs/stable/File.html) module contains functions that allows us to open files as IO devices. By default, files are opened in binary mode, which requires developers to use the specific `IO.binread/2` and `IO.binwrite/2` functions from the `IO` module:
+
+```iex
+iex> {:ok, file} = File.open "hello", [:write]
+{:ok, #PID<0.47.0>}
+iex> IO.binwrite file, "world"
+:ok
+iex> File.close file
+:ok
+iex> File.read "hello"
+{:ok, "world"}
+```
+
+A file can also be opened with `:utf8` encoding which allows the remaining functions in the `IO` module to be used:
+
+```iex
+iex> {:ok, file} = File.open "another", [:write, :utf8]
+{:ok, #PID<0.48.0>}
+```
+
+Besides functions for opening, reading and writing files, the `File` module has many functions that work on the filesystem. Those functions are named after their UNIX equivalents. For example, `File.rm/1` can be used to remove files, `File.mkdir/1` to create directories, `File.mkdir_p/1` creates directories guaranteeing their parents exists and there is even `File.cp_r/2` and `File.rm_rf/2` which copy and remove files and directories recursively.
+
+You will also notice that functions in the `File` module have two variants, one with `!` (bang) in its name and others without. For example, when we read the "hello" file above, we have used the one without `!`. Let's try some new examples:
+
+```iex
+iex> File.read "hello"
+{:ok, "world"}
+iex> File.read! "hello"
+"world"
+iex> File.read "unknown"
+{:error, :enoent}
+iex> File.read! "unknown"
+** (File.Error) could not read file unknown: no such file or directory
+```
+
+Notice that when the file does not exist, the version with `!` raises an error. That said, the version without `!` is preferred when you want to handle different outcomes with pattern matching. However, if you expect the file to be there, the bang variation is more useful as it raises a meaningful error message. That said, never write:
+
+```elixir
+{:ok, body} = File.read(file)
+```
+
+Instead write:
+
+```elixir
+case File.read(file) do
+  {:ok, body} -> # handle ok
+  {:error, r} -> # handle error
+end
+```
+
+or
+
+```elixir
+File.read!(file)
+```
+
+## 12.3 The Path module
+
+The majority of the functions in the File module expects paths as arguments. Most commonly, those paths will be binaries and they can be manipulated with the [`Path`](/docs/stable/Path.html) module:
+
+```iex
+iex> Path.join("foo", "bar")
+"foo/bar"
+iex> Path.expand("~/hello")
+"/Users/jose/hello"
+```
+
+With this we have covered the main modules for doing IO and interacting with the filesystem. Next we will discuss some curiosities and advanced topics regarding IO. Those sections are not necessary to write Elixir code, so feel free to skip them, but they do provide an overview of how the IO system is implemented in the VM and other curiosities.
+
+## 12.4 Processes and group leaders
+
+You may have noticed that `File.open/2` returned a tuple containing a PID:
+
+```iex
+iex> {:ok, file} = File.open "hello", [:write]
+{:ok, #PID<0.47.0>}
+```
+
+That's because the IO module actually works with processes. When you say `IO.write(pid, binary)`, the IO module will send a message to the process with the desired operation. Let's see what happens if we use our own process:
+
+```iex
+iex> pid = spawn fn ->
+...>  receive do: (msg -> IO.inspect msg)
+...> end
+#PID<0.57.0>
+iex> IO.write(pid, "hello")
+{:io_request, #PID<0.41.0>, #PID<0.57.0>, {:put_chars, :unicode, "hello"}}
+** (ErlangError) erlang error: :terminated
+```
+
+After `IO.write/2`, we can see the request sent by the IO module printed, which then fails since the IO module expected some kind of result, which we did not supply.
+
+The [`StringIO`](/docs/stable/StringIO.html) module provides an implementation of the IO device messages on top of a string:
+
+```iex
+iex> {:ok, pid} = StringIO.start("hello")
+{:ok, #PID<0.43.0>}
+iex> IO.read(pid, 2)
+"he"
+```
+
+By modelling IO devices with processes, the Erlang VM allows different nodes in the same network to exchange file processes and read/write files in between nodes. Of all IO devices, there is one that is special to each process, called group leader.
+
+When you write to `:stdio`, you are actually sending a message to the group leader, which writes to `:stdio`:
+
+```iex
+iex> IO.puts :stdio, "hello"
+hello
+:ok
+iex> IO.puts Process.group_leader, "hello"
+hello
+:ok
+```
+
+The group leader can be configured per process and is used in different situations, for example, when executing code in remote nodes, it guarantees messages printed in the remote node are redirected and printed in the "executor" one.
+
+## 12.5 `iodata` and `char_data`
+
+In all examples above, we have used binaries/strings when writing to files. In the chapter "Binaries, strings and char lists", we mentioned how strings are simply bytes while char lists are lists with codepoints.
+
+The functions in `IO` and `File` also allow lists to be given as arguments. Not only that, they also allow a mixed list of lists, integers and binaries to be given:
+
+```iex
+iex> IO.puts 'hello world'
+hello world
+:ok
+iex> IO.puts ['hello', ?\s, "world"]
+hello world
+:ok
+```
+
+However, this requires some attention. A char list needs to be encoded into bytes when written to disk and that depends on the encoding of the IO device. If the file is opened without encoding, the file is expected to be in raw mode, and the functions in the `IO` module starting with `bin*` must be used. Those functions expect an `iodata` as argument, i.e. it expects a list of bytes and binaries to be given. If you provide a list of codepoints and those codepoints have value more than 255, the operation will fail since we won't know how to encode them.
+
+On the other hand, `:stdio` and files opened with `:utf8` encoding work with the remaining functions in the `IO` module and those expect a `char_data` as argument, i.e. they expect a list of characters or strings to be given.
+
+Although this is a subtle difference, you only need to worry about those details if you intend to pass lists to those functions. Binaries are already represented by the underlying bytes and as such their representation is always raw.
+
+When working with iodata and char data, Elixir provides `iodata_to_binary/1` to convert any `iodata` to binary. The functions `String.from_char_data!/1` and `List.from_char_data!/1` can be used to convert char data into strings or char lists respectively. Unless you are working closely with some devices, you will rarely need to use those functions.
+
+This finishes our tour on IO devices and IO related functionality. We have learned about four Elixir modules, [`IO`](/docs/stable/IO.html), [`File`](/docs/stable/File.html), [`Path`](/docs/stable/Path.html) and [`StringIO`](/docs/stable/StringIO.html), as well as how the VM uses processes for the underlying IO mechanisms and how to use (char and io) lists for IO operations.
diff --git a/getting_started/13.markdown b/getting_started/13.markdown
new file mode 100644
index 000000000..1411ec074
--- /dev/null
+++ b/getting_started/13.markdown
@@ -0,0 +1,177 @@
+---
+layout: getting_started
+title: 13 alias, require and import
+guide: 13
+---
+
+# {{ page.title }}
+
+In order to facilitate software reuse, Elixir provides three directives. As we are going to see below, they are called directives because they have **lexical scope**.
+
+### 13.1 alias
+
+`alias` allows you to set up aliases for any given module name. Imagine our `Math` module uses a special list implementation for doing math specific operations:
+
+```elixir
+defmodule Math do
+  alias Math.List, as: List
+end
+```
+
+From now on, any reference to `List` will automatically expand to `Math.List`. In case one wants to access the original `List`, it can be done by accessing the module via `Elixir`:
+
+```elixir
+List.flatten             #=> uses Math.List.flatten
+Elixir.List.flatten      #=> uses List.flatten
+Elixir.Math.List.flatten #=> uses Math.List.flatten
+```
+
+> Note: All modules defined in Elixir are defined inside a main Elixir namespace. However, for convenience, you can omit "Elixir." when referencing them.
+
+Aliases are frequently used to define shortcuts. In fact, calling `alias` without an `as` option sets the alias automatically to the last part of the module name, for example:
+
+```elixir
+alias Math.List
+```
+
+Is the same as:
+
+```elixir
+alias Math.List, as: List
+```
+
+Note that `alias` is **lexically scoped**, which allows you to set aliases inside specific functions:
+
+```elixir
+defmodule Math do
+  def plus(a, b) do
+    alias Math.List
+    # ...
+  end
+
+  def minus(a, b) do
+    # ...
+  end
+end
+```
+
+In the example above, since we are invoking `alias` inside the function `plus/2`, the alias will just be valid inside the function `plus/2`. `minus/2` won't be affected at all.
+
+### 13.2 require
+
+Elixir provides macros as a mechanism for meta-programming (writing code that generates code).
+
+Macros are chunks of code that are executed and expanded at compilation time. This means, in order to use a macro, we need to guarantee its module and implementation are available during compilation. This is done with the `require` directive:
+
+```iex
+iex> Integer.odd?(3)
+** (CompileError) iex:1: you must require Integer before invoking the macro Integer.odd?/1
+iex> require Integer
+nil
+iex> Integer.odd?(3)
+true
+```
+
+In Elixir, `Integer.odd?/1` is defined as a macro so it can be used as guards. This means that, in order to invoke `Integer.odd?/1`, we need to first require the `Integer` module.
+
+In general a module does not need to be required before usage, except if we want to use the macros available in that module. An attempt to call a macro that was not loaded will raise an error. Note that like the `alias` directive, `require` is also lexically scoped. We will talk more about macros in a later chapter.
+
+### 13.3 import
+
+We use `import` whenever we want to easily access functions or macros from other modules without using the qualified name. For instance, if we want to use the `duplicate` function from `List` several times, we can simply import it:
+
+```iex
+iex> import List, only: [duplicate: 2]
+nil
+iex> duplicate :ok, 3
+[:ok, :ok, :ok]
+```
+
+In this case, we are importing only the function `duplicate` (with arity 2) from `List`. Although `only:` is optional, its usage is recommended. `except` could also be given as an option.
+
+`import` also supports `:macros` and `:functions` to be given to `:only`. For example, to import all macros, one could write:
+
+```elixir
+import Integer, only: :macros
+```
+
+Or to import all functions, you could write:
+
+```elixir
+import Integer, only: :functions
+```
+
+Note that `import` is also **lexically scoped**, this means we can import specific macros inside specific functions:
+
+```elixir
+defmodule Math do
+  def some_function do
+    import List, only: [duplicate: 2]
+    # call duplicate
+  end
+end
+```
+
+In the example above, the imported `List.duplicate/2` is only visible within that specific function. `duplicate/2` won't be available in any other function in that module (or any other module for that matter).
+
+Note that importing a module automatically requires it.
+
+## 13.4 Aliases
+
+At this point, you may be wondering, what exactly an Elixir alias is and how it is represented?
+
+An alias in Elixir is a capitalized identifier (like `String`, `Keyword`, etc) which is converted to an atom during compilation. For instance, the `String` alias translates by default to the atom `:"Elixir.String"`:
+
+```iex
+iex> is_atom(String)
+true
+iex> to_string(String)
+"Elixir.String"
+iex> :"Elixir.String"
+String
+```
+
+By using the `alias/2` directive, we are simply changing what an alias translates to.
+
+Aliases work as described because in the Erlang VM (and consequently Elixir), modules are represented by atoms. For example, that's the mechanism we use to call Erlang modules:
+
+```iex
+iex> :lists.flatten([1,[2],3])
+[1, 2, 3]
+```
+
+This is also the mechanism that allows us to dynamically call a given function in a module:
+
+```iex
+iex> mod = :lists
+:lists
+iex> mod.flatten([1,[2],3])
+[1,2,3]
+```
+
+In other words, we are simply calling the function `flatten` on the atom `:lists`.
+
+## 13.5 Nesting
+
+Now that we have talked about aliases, we can talk about nesting and how it works in Elixir. Consider the following example:
+
+```elixir
+defmodule Foo do
+  defmodule Bar do
+  end
+end
+```
+
+The example above will define two modules `Foo` and `Foo.Bar`. The second can be accessed as `Bar` inside `Foo` as long as they are in the same lexical scope. If later the developer decides to move `Bar` to another file, it will need to be referenced by its full name (`Foo.Bar`) or an alias needs to be set using the `alias` directive discussed above.
+
+In other words, the code above is exactly the same as:
+
+```elixir
+defmodule Elixir.Foo do
+  defmodule Elixir.Foo.Bar do
+  end
+  alias Elixir.Foo.Bar, as: Bar
+end
+```
+
+As we will see in later chapters, aliases also play a crucial role in macros, to guarantee they are hygienic. With this we are almost finishing our tour about Elixir modules, the last topic to cover is module attributes.
diff --git a/getting_started/14.markdown b/getting_started/14.markdown
new file mode 100644
index 000000000..70bf2b05c
--- /dev/null
+++ b/getting_started/14.markdown
@@ -0,0 +1,174 @@
+---
+layout: getting_started
+title: 14 Module attributes
+guide: 14
+---
+
+# {{ page.title }}
+
+Module attributes in Elixir serve three purposes:
+
+1. They serve to annotate the module, often with information to be used by the user or the VM.
+2. They work as constants.
+3. They work as a temporary module storage to be used during compilation.
+
+Let's check each case, one by one.
+
+## 14.1 As annotations
+
+Elixir brings the concept of module attributes from Erlang. For example:
+
+```elixir
+defmodule MyServer do
+  @vsn 2
+end
+```
+
+In the example above, we are explicitly setting the version attribute for that module. `@vsn` is used by the code reloading mechanism in the Erlang VM to check if a module has been updated or not. If no version is specified, the version is set to the MD5 checksum of the module functions.
+
+Elixir has a handful of reserved attributes. Here are just a few of them, the most commonly used ones:
+
+* `@moduledoc` - provides documentation for the current module.
+* `@doc` - provides documentation for the function or macro that follows the attribute.
+* `@behaviour` - (notice the British spelling) used for specifying an OTP or user-defined behaviour.
+* `@before_compile` - provides a hook that will be invoked before the module is compiled. This makes it possible to inject functions inside the module exactly before compilation.
+
+`@moduledoc` and `@doc` are by far the most used attributes, and we expect you to use them a lot. Elixir treats documentation as first-class and provides many functions to access documentation:
+
+```iex
+iex> defmodule MyModule do
+...>  @moduledoc "It does **x**"
+...>
+...>  @doc """
+...>  Returns the version
+...>  """
+...>  def version, do: 1
+...> end
+{:module, MyModule, <<70, 79, 82, ...>>, {:version, 0}}
+iex> h MyModule
+* MyModule
+
+It does **x**
+
+iex> h MyModule.version
+* def version()
+
+Returns the version
+
+```
+
+Elixir promotes the use of markdown with heredocs to write readable documentation. Heredocs are multiline strings, they start and end with triple quotes, keeping the formatting of the inner text:
+
+```elixir
+defmodule Math do
+  @moduledoc """
+  This module provides mathematical functions
+  as sin, cos and constants like pi.
+
+  ## Examples
+
+      Math.pi
+      #=> 3.1415...
+
+  """
+end
+```
+
+We also provide a tool called [ExDoc](https://github.com/elixir-lang/ex_doc) which is used to generate HTML pages from the documentation.
+
+You can take a look at the docs for [Module](/docs/stable/Module.html) for a complete list of supported attributes. Elixir also uses attributes to define [typespecs](/docs/stable/Kernel.Typespec.html), via:
+
+* `@spec` - provides a specification for a function.
+* `@callback` - provides a specification for the behavior callback.
+* `@type` - defines a type to be used in `@spec`.
+* `@typep` - defines a private type to be used in `@spec`.
+* `@opaque` - defines an opaque type to be used in `@spec`.
+
+This section covers built-in attributes. However, attributes can also be used by developers or extended by libraries to support custom behaviour.
+
+## 14.2 As constants
+
+Elixir developers will often use module attributes to be used as constants:
+
+```elixir
+defmodule MyServer do
+  @initial_state %{host: "147.0.0.1", port: 3456}
+  IO.inspect @initial_state
+end
+```
+
+> Note: Unlike Erlang, user defined attributes are not stored in the module by default. The value exists only during compilation time. A developer can configure an attribute to behave closer to Erlang by calling [`Module.register_attribute/3`](/docs/stable/Module.html#register_attribute/3).
+
+Trying to access an attribute that was not defined will print a warning:
+
+```elixir
+defmodule MyServer do
+  @unknown
+end
+warning: undefined module attribute @unknown, please remove access to @unknown or explicitly set it to nil before access
+```
+
+Finally, attributes can also be read inside functions:
+
+```elixir
+defmodule MyServer do
+  @my_data 14
+  def first_data, do: @my_data
+  @my_data 13
+  def second_data, do: @my_data
+end
+
+MyServer.first_data #=> 14
+MyServer.second_data #=> 13
+```
+
+Notice that reading an attribute inside a function takes a snapshot of its current value. In other words, the value is read at compilation time and not at runtime. As we are going to see, this makes attributes useful to be used as storage during module compilation.
+
+## 14.3 As temporary storage
+
+One of the projects in the Elixir organization is [the `Plug` project](https://github.com/elixir-lang/plug), which is meant to be a common foundation for building web libraries and frameworks in Elixir.
+
+The Plug library also allows developers to define their own plugs which can be run in a web server:
+
+```elixir
+defmodule MyPlug do
+  use Plug.Builder
+
+  plug :set_header
+  plug :send_ok
+
+  def set_header(conn, _opts) do
+    put_resp_header(conn, "x-header", "set")
+  end
+
+  def send_ok(conn, _opts) do
+    send(conn, 200, "ok")
+  end
+end
+
+IO.puts "Running MyPlug with Cowboy on http://localhost:4000"
+Plug.Adapters.Cowboy.http MyPlug, []
+```
+
+In the example above, we have used the `plug/1` macro to connect functions that will be invoked when there is a web request. Internally, every time you call `plug/1`, the Plug library stores the given argument in a `@plugs` attribute. Just before the module is compiled, Plug runs a callback that defines a method (`call/2`) which handles http requests. This method will run all plugs inside `@plugs` in order.
+
+In order to understand the underlying code, we'd need macros, so we will revisit this pattern in the meta-programming guide. However the focus here is exactly on how using module attributes as storage allow developers to create DSLs.
+
+Another example comes from the ExUnit framework which uses module attributes as annotation and storage:
+
+```elixir
+defmodule MyTest do
+  use ExUnit.Case
+
+  @tag :external
+  test "contacts external service" do
+    # ...
+  end
+end
+```
+
+Tags in ExUnit are used to annotate tests. Tags can be later used to filter tests. For example, you can avoid running external tests on your machine because they are slow and dependent on other services, while they can still be enabled in your build system.
+
+We hope this section shines some light on how Elixir supports meta-programming and how module attributes play an important role when doing so.
+
+In the next chapters we'll explore structs and protocols before moving to exception handling and other constructs like sigils and comprehensions.
diff --git a/getting_started/15.markdown b/getting_started/15.markdown
new file mode 100644
index 000000000..2f8286c3a
--- /dev/null
+++ b/getting_started/15.markdown
@@ -0,0 +1,99 @@
+---
+layout: getting_started
+title: 15 Structs
+guide: 15
+---
+
+# {{ page.title }}
+
+In early chapters, we have learned about maps:
+
+```iex
+iex> map = %{a: 1, b: 2}
+%{a: 1, b: 2}
+iex> map[:a]
+1
+iex> %{map | a: 3}
+%{a: 3, b: 2}
+```
+
+Structs are extensions on top of maps that bring default values, compile-time guarantees and polymorphism into Elixir.
+
+To define a struct, we just need to call `defstruct/1` inside a module:
+
+```iex
+iex> defmodule User do
+...>   defstruct name: "jose", age: 27
+...> end
+{:module, User,
+ <<70, 79, 82, ...>>, {:__struct__, 0}}
+```
+
+We can now create "instances" of this struct by using the `%User{}` syntax:
+
+```iex
+iex> %User{}
+%User{name: "jose", age: 27}
+iex> %User{name: "eric"}
+%User{name: "eric", age: 27}
+iex> is_map(%User{})
+true
+```
+
+Structs give compile-time guarantees that the provided fields exist in the struct:
+
+```iex
+iex> %User{oops: :field}
+** (CompileError) iex:3: unknown key :oops for struct User
+```
+
+When discussing maps, we demonstrated how we can access and update existing fields of a map. The same applies to structs:
+
+```iex
+iex> jose = %User{}
+%User{name: "jose", age: 27}
+iex> jose.name
+"jose"
+iex> eric = %{jose | name: "eric"}
+%User{name: "eric", age: 27}
+iex> %{user | oops: :field}
+** (ArgumentError) argument error
+```
+
+By using the update syntax, the VM is aware no new keys will be added to the map/struct, allowing the maps to share their structure in memory. In the example above, both `jose` and `eric` share the same key structure in memory.
+
+Structs can also be used in pattern matching and they guarantee the structs are of the same type:
+
+```iex
+iex> %User{name: name} = jose
+%User{name: "jose", age: 27}
+iex> name
+"jose"
+iex> %User{} = %{}
+** (MatchError) no match of right hand side value: %{}
+```
+
+Matching works because structs store a field named `__struct__` inside the map:
+
+```iex
+iex> jose.__struct__
+User
+```
+
+Overall, a struct is just a bare map with default fields. Notice we say it is a bare map because none of the protocols implemented for maps are available for structs. For example, you can't enumerate nor access a struct:
+
+```iex
+iex> user = %User{}
+%User{name: "jose", age: 27}
+iex> user[:name]
+** (Protocol.UndefinedError) protocol Access not implemented for %User{age: 27, name: "jose"}
+```
+
+A struct also is not a dictionary and therefore can't be used with the `Dict` module:
+
+```iex
+iex> Dict.get(%User{}, :name)
+** (ArgumentError) unsupported dict: %User{name: "jose", age: 27}
+```
+
+We will cover how structs interacts with protocols in the next chapter.
diff --git a/getting_started/16.markdown b/getting_started/16.markdown
new file mode 100644
index 000000000..c2ef0b1d7
--- /dev/null
+++ b/getting_started/16.markdown
@@ -0,0 +1,196 @@
+---
+layout: getting_started
+title: 16 Protocols
+guide: 16
+---
+
+# {{ page.title }}
+
+Protocols are a mechanism to achieve polymorphism in Elixir. Dispatching on a protocol is available to any data type as long as it implements the protocol. Let's see an example.
+
+In Elixir, only `false` and `nil` are treated as false. Everything else evaluates to true. Depending on the application, it may be important to specify a `blank?` protocol that returns a boolean for other data types that should be considered blank. For instance, an empty list or an empty binary could be considered blanks.
+
+We could define this protocol as follows:
+
+```elixir
+defprotocol Blank do
+  @doc "Returns true if data is considered blank/empty"
+  def blank?(data)
+end
+```
+
+The protocol expects a function called `blank?` that receives one argument to be implemented. We can implement this protocol for different Elixir data types as follows:
+
+```elixir
+# Integers are never blank
+defimpl Blank, for: Integer do
+  def blank?(_), do: false
+end
+
+# Just empty list is blank
+defimpl Blank, for: List do
+  def blank?([]), do: true
+  def blank?(_),  do: false
+end
+
+# Just empty map is blank
+defimpl Blank, for: Map do
+  # Keep in mind we could not pattern match on %{} because
+  # it matches on all maps. We can however check if the size
+  # is zero (and size is a fast operation).
+  def blank?(map), do: map_size(map) == 0
+end
+
+# Just the atoms false and nil are blank
+defimpl Blank, for: Atom do
+  def blank?(false), do: true
+  def blank?(nil),   do: true
+  def blank?(_),     do: false
+end
+```
+
+And we would do so for all native data types. The types available are:
+
+* `Atom`
+* `BitString`
+* `Float`
+* `Function`
+* `Integer`
+* `List`
+* `Map`
+* `PID`
+* `Port`
+* `Reference`
+* `Tuple`
+
+Now with the protocol defined and implementations in hand, we can invoke it:
+
+```iex
+iex> Blank.blank?(0)
+false
+iex> Blank.blank?([])
+true
+iex> Blank.blank?([1, 2, 3])
+false
+```
+
+Passing a data type that does not implement the protocol raises an error:
+
+```iex
+iex> Blank.blank?("hello")
+** (Protocol.UndefinedError) protocol Blank not implemented for "hello"
+```
+
+## 16.1 Protocols and structs
+
+The power of Elixir's extensibility comes when protocols and structs are used together.
+
+In the previous chapter, we have learned that although structs are maps, they do not share protocol implementations with maps. Let's define a `User` struct as in the previous chapter:
+
+```iex
+iex> defmodule User do
+...>   defstruct name: "jose", age: 27
+...> end
+{:module, User,
+ <<70, 79, 82, ...>>, {:__struct__, 0}}
+```
+
+And then check:
+
+```iex
+iex> Blank.blank?(%{})
+true
+iex> Blank.blank?(%User{})
+** (Protocol.UndefinedError) protocol Blank not implemented for %User{age: 27, name: "jose"}
+```
+
+Instead of sharing protocol implementation with maps, structs require their own protocol implementation:
+
+```elixir
+defimpl Blank, for: User do
+  def blank?(_), do: false
+end
+```
+
+If desired you could come up with your own semantics for a user being blank. Not only that, you could use structs to build more robust data types, like queues, and implemented all relevant protocols, like `Enumerable` and possibly `Blank` for such data type.
+
+In many cases though, developers may want to provide a default implementation for structs, as explicitly implementing the protocol for all structs can be tedious. That's when falling back to Any comes in handy.
+
+### 16.2 Falling back to Any
+
+It may be convenient to provide a default implementation for all types. This can be achieved by setting `@fallback_to_any` to `true` in the protocol definition:
+
+```elixir
+defprotocol Blank do
+  @fallback_to_any true
+  def blank?(data)
+end
+```
+
+Which can now be implemented as:
+
+```elixir
+defimpl Blank, for: Any do
+  def blank?(_), do: false
+end
+```
+
+Now all data types (including structs) that we have not implemented the `Blank` protocol for will be considered non-blank.
+
+### 16.3 Built-in protocols
+
+Elixir ships with some built-in protocols. In previous chapters, we have discussed the `Enum` module which provides many functions that work with any data structure that implements the `Enumerable` protocol:
+
+```iex
+iex> Enum.map [1, 2, 3], fn(x) -> x * 2 end
+[2,4,6]
+iex> Enum.reduce 1..3, 0, fn(x, acc) -> x + acc end
+6
+```
+Another useful example is the `String.Chars` protocol, which specifies how to convert a data structure with characters to a string. It's exposed via the `to_string` function:
+
+```iex
+iex> to_string :hello
+"hello"
+```
+
+Notice that string interpolation in Elixir calls the `to_string` function:
+
+```iex
+iex> "age: #{25}"
+"age: 25"
+```
+
+The snippet above only works because numbers implement the `String.Chars` protocol. Passing a tuple, for example, will lead to an error:
+
+```iex
+iex> tuple = {1, 2, 3}
+{1, 2, 3}
+iex> "tuple: #{tuple}"
+** (Protocol.UndefinedError) protocol String.Chars not implemented for {1, 2, 3}
+```
+
+When there is a need to "print" a more complex data structure, one can simply use the `inspect` function, based on the `Inspect` protocol:
+
+```iex
+iex> "tuple: #{inspect tuple}"
+"tuple: {1, 2, 3}"
+```
+
+The `Inspect` protocol is the protocol used to transform any data structure into a readable textual representation. This is what tools like IEx use to print results:
+
+```iex
+iex> {1, 2, 3}
+{1,2,3}
+iex> %User{}
+%User{name: "jose", age: 27}
+```
+
+Keep in mind that, by convention, whenever the inspected value starts with `#`, it is representing a data structure in non-valid Elixir syntax. This means the inspect protocol is not reversible as information may be lost along the way:
+
+```iex
+iex> inspect &(&1+2)
+"#Function<6.71889879/1 in :erl_eval.expr/5>"
+```
+
+There are other protocols in Elixir but this covers the most common ones. In the next chapter we will learn a bit more about error handling and exceptions in Elixir.
diff --git a/getting_started/17.markdown b/getting_started/17.markdown
new file mode 100644
index 000000000..ec5b886e6
--- /dev/null
+++ b/getting_started/17.markdown
@@ -0,0 +1,175 @@
+---
+layout: getting_started
+title: 17 try, catch and rescue
+guide: 17
+---
+
+# {{ page.title }}
+
+Elixir has three error mechanisms: errors, throws and exits. In this chapter we will explore each of them and include remarks about when each should be used.
+
+## 17.1 Errors
+
+A sample error can be retrieved by trying to add a number into an atom:
+
+```iex
+iex> :foo + 1
+** (ArithmeticError) bad argument in arithmetic expression
+     :erlang.+(:foo, 1)
+```
+
+A runtime error can be raised any time by using the `raise/1` macro:
+
+```iex
+iex> raise "oops"
+** (RuntimeError) oops
+```
+
+Other errors can be raised with `raise/2` passing the error name and a list of keyword arguments:
+
+```iex
+iex> raise ArgumentError, message: "invalid argument foo"
+** (ArgumentError) invalid argument foo
+```
+
+You can also define your own errors using the `defexception/2` macro. The most common case is to define an exception with a message field:
+
+```iex
+iex> defexception MyError, message: "default message"
+iex> raise MyError
+** (MyError) default message
+iex> raise MyError, message: "custom message"
+** (MyError) custom message
+```
+
+Exceptions can be rescued by using the `try/rescue` construct:
+
+```iex
+iex> try do
+...>   raise "oops"
+...> rescue
+...>   e in RuntimeError -> e
+...> end
+RuntimeError[message: "oops"]
+```
+
+The example above rescues the runtime error and returns the error itself which is then printed in the `iex` session. In practice Elixir developers rarely use the `try/rescue` construct though. For example, many languages would force you to rescue an error when a file cannot open succcessfully. Elixir instead provides a `File.read/1` function which returns a tuple containing information if the file was opened with success or not:
+
+```iex
+iex> File.read "hello"
+{:error, :enoent}
+iex. File.write "hello", "world"
+:ok
+iex> File.read "hello"
+{:ok, "world"}
+````
+
+There is no `try/rescue` here. In case you want to handle multiple outcomes of opening a file, you can simply use pattern matching with `case`:
+
+```iex
+iex> case File.read "hello" do
+...>   {:ok, body} -> IO.puts "got ok"
+...>   {:error, body} -> IO.puts "got error"
+...> end
+```
+
+At the end of the day, it is up to your application to decide if an error while opening a file is exceptional or not. That's why Elixir doesn't impose exceptions on `File.read/1` and many other functions. Instead we leave it up to the developer to choose the best way to proceed.
+
+For the cases where you do expect a file to exist (and the lack of a file is truly an error) you can simply use `File.read!/1`:
+
+```iex
+iex> File.read! "unknown"
+** (File.Error) could not read file unknown: no such file or directory
+    (elixir) lib/file.ex:305: File.read!/1
+```
+
+In other words, we avoid using `try/rescue` because **we don't use errors for control flow**. In Elixir, we take errors literally: they are reserved to unexpected and/or exceptional situations. In case you actually need flow control constructs, throws must be used. That's what we are going to see next.
+
+## 17.2 Throws
+
+In Elixir, one can throw a value to be caught later. `throw` and `catch` are reserved for situations where it is not possible to retrieve a value unless by using `throw` and `catch`.
+
+Those situations are quite uncommon in practice unless when interfacing with a library that does not provide the proper APIs. For example, let's imagine the `Enum` module did not provide any API for finding a value and we need to find the first number that is a multiple of 13:
+
+```iex
+iex> try do
+...>   Enum.each -50..50, fn(x) ->
+...>     if rem(x, 13) == 0, do: throw(x)
+...>   end
+...>   "Got nothing"
+...> catch
+...>   x -> "Got #{x}"
+...> end
+"Got -39"
+```
+
+However, in practice one can simply use `Enum.find/2`:
+
+```iex
+iex> Enum.find -50..50, &(rem(&1, 13) == 0)
+-39
+```
+
+## 17.3 Exits
+
+Every Elixir code runs inside processes that communicates with each other. When a process dies, it sends an `exit` signal. A process can also die by explicitly sending an exit signal:
+
+```iex
+iex> spawn_link fn -> exit(1) end
+#PID<0.56.0>
+** (EXIT from #PID<0.56.0>) 1
+```
+
+In the example above, the linked process died by sending an `exit` signal with value of 1. The Elixir shell automatically handles those messages and prints them to the terminal.
+
+`exit` can also be "caught" using `try/catch`:
+
+```iex
+iex> try do
+...>   exit "I am exiting"
+...> catch
+...>   :exit, _ -> "not really"
+...> end
+"not really"
+```
+
+Using `try/catch` is already uncommon and using it to catch exits is even more rare.
+
+`exit` signals are an important part of the fault tolerant system provided by the Erlang VM. Processes usually run under supervision trees which are themselves processes that just wait for `exit` signals of the supervised processes. Once an exit signal is received, the supervision strategy kicks in and the supervised process is restarted.
+
+It is exactly this supervision system that makes constructs like `try/catch` and `try/rescue` so uncommon in Elixir. Instead of rescuing a certain error, we'd rather "fail fast" since the supervision tree will guarantee our application will go back to a known initial state after the error.
+
+## 17.4 After
+
+Somtimes it is necessary to use `try/after` to guarantee a resource is cleaned up after some particular action. For example, we can open a file and guarantee it is closed with `try/after` block:
+
+```iex
+iex> {:ok, file} = File.open "sample", [:utf8, :write]
+iex> try do
+...>   IO.write file, "josé"
+...>   raise "oops, something went wrong"
+...> after
+...>   File.close(file)
+...> end
+** (RuntimeError) oops, something went wrong
+```
+
+## 17.5 Variables scope
+
+It is important to bear in mind that variables defined inside `try/catch/rescue/after` blocks do not leak to the outer context. This is because the `try` block may fail and as such the variables may never be bound in the first place. In other words, this code is invalid:
+
+```iex
+iex> try do
+...>   from_try = true
+...> after
+...>   from_after = true
+...> end
+iex> from_try
+** (RuntimeError) undefined function: from_try/0
+iex> from_after
+** (RuntimeError) undefined function: from_after/0
+```
+
+This finishes our introduction to `try`, `catch` and `rescue`. You will find they are used less frequently in Elixir than in other languages although they may be handy in some situations where a library or some particular code is not playing "by the rules".
+
+It is time to talk about some Elixir constructs like comprehensions and sigils.
diff --git a/getting_started/18.markdown b/getting_started/18.markdown
new file mode 100644
index 000000000..d927ecda6
--- /dev/null
+++ b/getting_started/18.markdown
@@ -0,0 +1,94 @@
+---
+layout: getting_started
+title: 18 Comprehensions
+guide: 18
+---
+
+# {{ page.title }}
+
+In Elixir, it is common to loop over Enumerables, often filtering some results, and mapping to another list of values. Comprehensions are syntax sugar for such constructs, grouping those common tasks into the `for` special form.
+
+For example, we can get all the square values of elements in a list as follows:
+
+```iex
+iex> for n <- [1, 2, 3, 4], do: n * n
+[1, 4, 9, 16]
+```
+
+A comprehension is made of three parts: generators, filters and collectables.
+
+## 18.1 Generators and filters
+
+In the expression above, `n <- [1, 2, 3, 4]` is the generator. It is literally generating values to be used in the comprehensions. Any enumerable can be passed in the right-hand side the generator expression:
+
+```iex
+iex> for n <- 1..4, do: n * n
+[1, 4, 9, 16]
+```
+
+Generator expressions also support pattern matching, ignoring all non-matching patterns. Imagine that instead of a range, we have a keyword list where the key is the atom `:good` or `:bad` and we only want to calculate the square of the good values:
+
+```iex
+iex> values = [good: 1, good: 2, bad: 3, good: 4]
+iex> for {:good, n} <- values, do: n * n
+[1, 4, 16]
+```
+
+Alternatively, filters can be used to filter some particular elements out. For example, we can get the square of only odd numbers:
+
+```iex
+iex> require Integer
+iex> for n <- 1..4, Integer.odd?(n), do: n * n
+[1, 9]
+```
+
+A filter will keep all values except `nil` or `false`.
+
+Comprehensions in general provide a much more concise representation than using the equivalent functions from the `Enum` and `Stream` modules. Furthermore, comprehensions also allow multiple generators and filters to be given. Here is an example that receives a list of directories and deletes all files in those directories:
+
+```elixir
+for dir  <- dirs,
+    file <- File.ls!(dir),
+    path = Path.join(dir, file),
+    File.regular?(path) do
+  File.rm!(path)
+end
+```
+
+Keep in mind that variable assignments inside the comprehension, be it in generators, filters or inside the block, are not reflected outside of the comprehension.
+
+## 18.2 Bitstring generators
+
+Bitstring generators are also supported and are very useful when you need to organize bitstring streams. The example below receives a list of pixels from a binary with their respective red, green and blue values and convert them into triplets:
+
+```iex
+iex> pixels = <<213, 45, 132, 64, 76, 32, 76, 0, 0, 234, 32, 15>>
+iex> for <<r::8, g::8, b::8 <- pixels>>, do: {r, g, b}
+[{213,45,132},{64,76,32},{76,0,0},{234,32,15}]
+```
+
+A bitstring generator can be mixed with the "regular" enumerable generators and provide filters as well.
+
+## 18.3 Into
+
+In the examples above, the comprehension returned a list as a result.
+
+However, the result of a comprehension can be inserted into different data structures by passing the `:into` option. For example, we can use bitstring generators with the `:into` option to easily remove all spaces in a string:
+
+```iex
+iex> for <<c <- " hello world ">>, c != ?\s, into: "", do: <<c>>
+"helloworld"
+```
+
+Sets, maps and other dictionaries can also be given with the `:into` option. In general, the `:into` accepts any structure as long as it implements the `Collectable` protocol.
+
+For example, the `IO` module provides streams, that are both `Enumerable` and `Collectable`. You can implement an echo terminal that returns whatever is typed, but in upcase, using comprehensions:
+
+```iex
+iex> stream = IO.stream(:stdio, :line)
+iex> for line <- stream, into: stream do
+...>   String.upcase(line) <> "\n"
+...> end
+```
+
+Now type any string into the terminal and you will see the same value will be printed in upcase. Unfortunately, this example also got your shell stuck in the comprehension, so you will need to hit `Ctrl+C` twice to get out of it. :)
diff --git a/getting_started/19.markdown b/getting_started/19.markdown
new file mode 100644
index 000000000..d0f806adc
--- /dev/null
+++ b/getting_started/19.markdown
@@ -0,0 +1,181 @@
+---
+layout: getting_started
+title: 19 Sigils
+guide: 19
+---
+
+# {{ page.title }}
+
+We have already learned Elixir provides double-quoted strings and single-quoted char lists. However, this only covers the surface of structures that have textual representation in the language. Atoms are, for example, another structure which are mostly created via the `:atom` representation.
+
+One of Elixir's goals is extensibility: developers should be able to extend the language to particular domains. Computer science has become such a wide field that it is impossible for a language to tackle many fields as part of its core. Our best bet is to rather make the language extensible, so developers, companies and communities can extend the language to their relevant domains.
+
+In the chapter, we are going to explore sigils, which are one of the mechanisms provided by the language for working with textual representations.
+
+## 19.1 Regular expressions
+
+Sigils start with the tilde (`~`) character which is followed by a letter and then a separator. The most common sigil in Elixir is `~r` for [regular expressions](https://en.wikipedia.org/wiki/Regular_Expressions):
+
+```iex
+# A regular expression that returns true if the text has foo or bar
+iex> regex = ~r/foo|bar/
+~r/foo|bar/
+iex> "foo" =~ regex
+true
+iex> "bat" =~ regex
+false
+```
+
+Elixir provides Perl-compatible regular expressions (regexes), as implemented by the [PCRE](http://www.pcre.org/) library. Regexes also support modifiers. For example, the `i` modifier makes a regular expression case insensitive:
+
+```iex
+iex> "HELLO" =~ ~r/hello/
+false
+iex> "HELLO" =~ ~r/hello/i
+true
+```
+
+Check out the [`Regex` module](/docs/stable/Regex.html) for more information on other modifiers and the supported operations with regular expressions.
+
+So far, all examples have used `/` to delimit a regular expression. However sigils support 8 different separators:
+
+```
+~r/hello/
+~r|hello|
+~r"hello"
+~r'hello'
+~r(hello)
+~r[hello]
+~r{hello}
+~r<hello>
+```
+
+The reasoning in supporting different operators is that different separators can be more convenient to different sigils. For example, using parentheses for regular expressions may be a confusing choice as they can get mixed with the parentheses inside the regex. However, parentheses can be handy for other sigils, as we will see in the next section.
+
+## 19.2 Strings, char lists and words sigils
+
+Besides regular expressions, Elixir ships with three other sigils.
+
+The `~s` sigil is used to generate strings, similar to double quotes:
+
+```iex
+iex> ~s(this is a string with "quotes")
+"this is a string with \"quotes\""
+```
+
+While `~c` is used to generate char lists:
+
+```iex
+iex> ~c(this is a string with "quotes")
+'this is a string with "quotes"'
+```
+
+The `~w` sigil is used to generate a list of words separated by white space:
+
+```iex
+iex> ~w(foo bar bat)
+["foo", "bar", "bat"]
+```
+
+The `~w` sigil also accepts the `c`, `s` and `a` modifiers to choose the format of the result:
+
+```iex
+iex> ~w(foo bar bat)a
+[:foo, :bar, :bat]
+```
+
+Besides lowercase sigils, Elixir supports uppercase sigils. While both `~s` and `~S` will return strings, the first one allows escape codes and interpolation while the second does not:
+
+```elixir
+iex> ~s(String with escape codes \x26 interpolation)
+"String with escape codes & interpolation"
+iex> ~S(String without escape codes and without #{interpolation})
+"String without escape codes and without \#{interpolation}"
+```
+
+The following escape codes can be used in strings and char lists:
+
+* `\"` – double quote
+* `\'` – single quote
+* `\\` – single backslash
+* `\a` – bell/alert
+* `\b` – backspace
+* `\d` - delete
+* `\e` - escape
+* `\f` - form feed
+* `\n` – newline
+* `\r` – carriage return
+* `\s` – space
+* `\t` – tab
+* `\v` – vertial tab
+* `\DDD`, `\DD`, `\D` - character with octal representation DDD, DD or D (example: `\377`)
+* `\xDD`	- character with hexadecimal representation DD (example: `\x13`)
+* `\x{D...}` -	character with hexadecimal representation with one or more hexadecimal digits (example: `\x{abc13}`)
+
+Sigils also support heredocs which is when tripe double- or single-quotes are used as separators:
+
+```iex
+iex> ~s"""
+...> this is
+...> a heredoc string
+...> """
+```
+
+The most common case for heredoc sigils is when writing documentation. For example, if you need to write escape characters in your documentation, it can become error prone as we would need to double-escape some characters:
+
+```elixir
+@doc """
+Converts double-quotes to single-quotes.
+
+## Examples
+
+    iex> convert("\\\"foo\\\"")
+    "'foo'"
+
+"""
+def convert(...)
+```
+
+By using using `~S`, we can avoid this problem altogether:
+
+```elixir
+@doc ~S"""
+Converts double-quotes to single-quotes.
+
+## Examples
+
+    iex> convert("\"foo\"")
+    "'foo'"
+
+"""
+def convert(...)
+```
+
+## 19.3 Custom sigils
+
+As hinted at the beginning of this chapter, sigils in Elixir are extensible. In fact, the sigil `~r/foo/i` is equivalent to calling the `sigil_r` function with two arguments:
+
+```iex
+iex> sigil_r(<<"foo">>, 'i')
+~r"foo"i
+```
+
+That said, we can access the documentation for the `~r` sigil via the `sigil_r` function:
+
+```iex
+iex> h sigil_r
+...
+```
+
+We can also provide our own sigils by simply implementing the proper function. For example, let's implement the `~i(13)` sigil that returns an integer:
+
+```iex
+iex> defmodule MySigils do
+...>   def sigil_i(binary, []), do: binary_to_integer(binary)
+...> end
+iex> import MySigils
+iex> ~i(13)
+13
+```
+
+Sigils can also be used to do compile-time work with the help of macros. For example, regular expressions in Elixir are compiled into efficient representation during compilation of the source code, therefore skipping this step at runtime. If you have interest in the subject, we recommend you to learn more about macros and check how those sigils are implemented in the `Kernel` module.
diff --git a/getting_started/2.markdown b/getting_started/2.markdown
index fe02223aa..0561b440f 100644
--- a/getting_started/2.markdown
+++ b/getting_started/2.markdown
@@ -1,697 +1,354 @@
 ---
 layout: getting_started
-title: 2 Diving in
+title: 2 Basic types
 guide: 2
-total_guides: 7
 ---
 
 # {{ page.title }}
 
-In this chapter we'll go a bit deeper into the basic data-types, learn some control flow mechanisms and talk about anonymous functions.
-
-## 2.1 Lists and tuples
-
-Elixir provides both lists and tuples:
-
- ```iex
-iex> is_list [1,2,3]
-true
-iex> is_tuple {1,2,3}
-true
-```
-
-While both are used to store items, they differ on how those items are stored in memory. Lists are implemented as linked lists (where each item in the list points to the next item) while tuples are stored contiguously in memory.
-
-This means that accessing a tuple element is very fast (constant time) and can be achieved using the `elem` function:
-
- ```iex
-iex> elem { :a, :b, :c }, 0
-:a
- ```
-
-On the other hand, updating a tuple is expensive as it needs to duplicate the tuple contents in memory. Updating a tuple can be done with the `set_elem` function:
+In this chapter we will learn more about Elixir basic types: integers, floats, atoms, lists and strings. Some basic types are:
 
 ```iex
-iex> set_elem { :a, :b, :c }, 0, :d
-{:d,:b,:c}
- ```
+iex> 1          # integer
+iex> 0x1F       # integer
+iex> 1.0        # float
+iex> :atom      # atom / symbol
+iex> "elixir"   # string
+iex> [1, 2, 3]  # list
+iex> {1, 2, 3}  # tuple
+```
 
-> Note: If you are an Erlang developer, you will notice that we used the `elem` and `set_elem` functions instead of Erlang's `element` and `setelement`. The reason for this choice is that Elixir attempts to normalize Erlang API's to always receive the "subject" of the function as the first argument and employ zero-based access.
+## 2.1 Basic arithmetic
 
-Since updating a tuple is expensive, when we want to add or remove elements, we use lists. Since lists are linked, it means accessing the first element of the list is very cheap. Accessing the n-th element, however, will require the algorithm to pass through n-1 nodes before reaching the n-th. We can access the `head` of the list as follows:
+Open up `iex`  and type the following expressions:
 
 ```iex
-# Match the head and tail of the list
-iex> [head | tail] = [1,2,3]
-[1,2,3]
-iex> head
-1
-iex> tail
-[2,3]
-
-# Put the head and the tail back together
-iex> [head | tail]
-[1,2,3]
-iex> length [head | tail]
+iex> 1 + 2
 3
+iex> 5 * 5
+25
+iex> 10 / 2
+5.0
 ```
 
-In the example above, we have matched the head of the list to the variable `head` and the tail of the list to the variable `tail`. This is called **pattern matching**. We can also pattern match tuples:
+Notice that `10 / 2` returned a float `5.0` instead of an integer `5`. This is expected. In Elixir, the operator `/` always returns a float. If you want to do integer division or get the division remainder, you can invoke the `div` and `rem` functions:
 
 ```iex
-iex> { a, b, c } = { :hello, "world", 42 }
-{ :hello, "world", 42 }
-iex> a
-:hello
-iex> b
-"world"
+iex> div(10, 2)
+5
+iex> div 10, 2
+5
+iex> rem 10, 3
+1
 ```
 
-A pattern match will error in case the sides can't match. This is, for example, the case when the tuples have different sizes:
+Notice that parentheses are not required in order to invoke a function.
+
+Elixir also supports shortcut notations for entering binary, octal and hexadecimal numbers:
 
 ```iex
-iex> { a, b, c } = { :hello, "world" }
-** (MatchError) no match of right hand side value: {:hello,"world"}
+iex> 0b1010
+10
+iex> 0777
+511
+iex> 0x1F
+31
 ```
 
-And also when comparing different types:
+Float numbers require a dot followed by at least one digit and also support `e` for the exponent number:
 
 ```iex
-iex> { a, b, c } = [:hello, "world", '!']
-** (MatchError) no match of right hand side value: [:hello,"world",'!']
+iex> 1.0
+1.0
+iex> 1.0e-10
+1.0e-10
 ```
 
-More interestingly, we can match on specific values. The example below asserts that the left side will only match the right side in case that the right side is a tuple that starts with the atom `:ok` as a key:
+Floats in Elixir are 64 bit double precision.
 
-```iex
-iex> { :ok, result } = { :ok, 13 }
-{:ok,13}
-iex> result
-13
-
-iex> { :ok, result } = { :error, :oops }
-** (MatchError) no match of right hand side value: {:error,:oops}
-```
+## 2.2 Booleans
 
-Pattern matching allows developers to easily destruct data types such as tuples and lists. As we will see in following chapters, it is one of the foundations of recursion in Elixir. However, in case you can't wait to iterate through and manipulate your lists, the [`Enum` module](/docs/stable/Enum.html) provides several helpers to manipulate lists (and other enumerables in general) while the [`List` module](/docs/stable/List.html) provides several helpers specific to lists:
+Elixir supports `true` and `false` as booleans.
 
 ```iex
-iex> Enum.at [1,2,3], 0
-1
-iex> List.flatten [1,[2],3]
-[1,2,3]
+iex> true
+true
+iex> true == false
+false
 ```
 
-## 2.2 Keyword lists
+Elixir provides a bunch of predicate functions to check for a value type. For example, the `is_boolean/1` function can be used to check if a value is a boolean or not:
 
-Elixir also provides a special syntax to create a list of keywords. They can be created as follows:
+> Note: Functions in Elixir are indentified by name and by number of arguments (i.e. arity). Therefore, `is_boolean/1` identifies a function named `is_boolean` that takes 1 argument. `is_boolean/2` identifies a different (nonexistent) function with the same name but different arity.
 
 ```iex
-iex> [a: 1, b: 2]
-[a: 1, b: 2]
+iex> is_boolean(true)
+true
+iex> is_boolean(1)
+false
 ```
 
-Keyword lists are nothing more than a list of two element tuples where the first element of the tuple is an atom:
+You can also use `is_integer/1`, `is_float/1` or `is_number/1` to check, respectively, if an argument is an integer, a float or either.
 
- ```iex
-iex> [head | tail] = [a: 1, b: 2]
-[a: 1, b: 2]
-iex> head
-{ :a, 1 }
-```
+> Note: at any moment you can type `h` in the shell to print information on how to use the shell. The `h` helper can also be used to access documentation for any function. For example, typing `h is_integer/1` is going to print the documentation for the `is_integer/1` function. It also works with operators and other constructs (try `h ==/2`).
 
-The [`Keyword` module](/docs/stable/Keyword.html) contains several functions that allow you to manipulate a keyword list ignoring duplicated entries or not. For example:
+## 2.3 Atoms
 
- ```iex
-iex> keywords = [foo: 1, bar: 2, foo: 3]
-iex> Keyword.get keywords, :foo
-1
-iex> Keyword.get_values keywords, :foo
-[1,3]
-```
-
-Since keyword lists are very frequently passed as arguments, they do not require brackets when given as the last argument in a function call. For instance, the examples below are valid and equivalent:
+Atoms are constants where their name is their own value. Some other languages call these symbols.
 
 ```iex
-iex> if(2 + 2 == 4, [do: "OK"])
-"OK"
-iex> if(2 + 2 == 4, do: "OK")
-"OK"
-iex> if 2 + 2 == 4, do: "OK"
-"OK"
+iex> :hello
+:hello
+iex> :hello == :world
+false
 ```
 
-## 2.3 Strings (binaries) and char lists (lists)
-
-In Elixir, a double-quoted value is not the same as a single-quoted one:
+The booleans `true` and `false` are, in fact, atoms:
 
 ```iex
-iex> "hello" == 'hello'
-false
-iex> is_binary "hello"
+iex> true == :true
 true
-iex> is_list 'hello'
+iex> is_atom(false)
 true
 ```
 
-We say a double-quoted value is a **string**, which is represented by a binary. A single-quoted value is a **char list**, which is represented by a list.
+## 2.4 Strings
 
-In fact, both double-quoted and single-quoted representations are just a shorter representation of binaries and lists respectively. Given that `?a` in Elixir returns the ASCII integer for the letter `a`, we could also write:
+Strings in Elixir are inserted in between double quotes, and they are encoded in UTF-8:
 
 ```iex
-iex> is_integer ?a
-true
-iex> <<?a, ?b, ?c>>
-"abc"
-iex> [?a, ?b, ?c]
-'abc'
+iex> "hellö"
+"hellö"
 ```
 
-In such cases, Elixir detects that all characters in the binary and in the list are printable and returns the quoted representation. However, adding a non-printable character forces them to be printed differently:
+Elixir also supports string interpolation:
 
 ```iex
-iex> <<?a, ?b, ?c, 1>>
-<<97,98,99,1>>
-
-iex> [?a, ?b, ?c, 1]
-[97,98,99,1]
+iex> "hellö #{:world}"
+"hellö world"
 ```
 
-In Elixir, strings (double-quoted) are preferred unless you want to explicitly iterate over a char list (which is sometimes common when interfacing with Erlang code from Elixir). As lists, binaries also support pattern matching:
+Strings can have line breaks in them or introduce them using escape sequences:
 
 ```iex
-iex> <<a, b, c>> = "foo"
-"foo"
-iex> a
-102
+iex> "hello
+...> world"
+"hello\nworld"
+iex> "hello\nworld"
+"hello\nworld"
 ```
 
-It is also possible to match on the "tail" of a binary, extracting the first bytes and matching the rest into a binary:
+You can print a string using the `IO.puts/1` function from the `IO` module:
 
 ```iex
-iex> <<f :: integer, rest :: binary>> = "foo"
-"foo"
-iex> f
-102
-iex> rest
-"oo"
+iex> IO.puts "hello\nworld"
+hello
+world
+:ok
 ```
 
-In the example above, we tagged each segment in the binary. The first segment has integer type (the default), which captures the ascii code for the letter "f". The remaining bytes "oo" are assigned into the binary `rest`.
-
-The binary/bitstring syntax in Elixir is very powerful, allowing you to match on bytes, bits, utf8 codepoints and much more. You can find more about it [in Elixir docs](http://elixir-lang.org/docs/master/Kernel.SpecialForms.html#<<>>/1). Meanwhile, let's talk more about Unicode.
-
-## 2.4 Unicode support
+Notice the `IO.puts/1` function returns the atom `:ok` as result after printing.
 
-A string in Elixir is a binary which is encoded in UTF-8. For example, the string "é" is a UTF-8 binary containing two bytes:
+Strings in Elixir are represented internally by binaries which are sequences of bytes:
 
 ```iex
-iex> string = "é"
-"é"
-iex> size(string)
-2
+iex> is_binary("hellö")
+true
 ```
 
-In order to easily manipulate strings, Elixir provides a [`String` module](http://elixir-lang.org/docs/stable/String.html):
+We can also get the number of bytes in a string:
 
 ```iex
-# returns the number of bytes
-iex> size "héllò"
-7
-
-# returns the number of characters as perceived by humans
-iex> String.length "héllò"
-5
+iex> byte_size("hellö")
+6
 ```
 
-> Note: to retrieve the number of elements in a data structure, you will use a function named `length` or `size`. Their usage is not arbitrary. The first is used when the number of elements needs to be calculated. For example, calling `length(list)` will iterate the whole list to find the number of elements in that list. `size` is the opposite, it means the value is pre-calculated and stored somewhere and therefore retrieving its value is a cheap operation. That said, we use `size` to get the size of a binary, which is cheap, but retrieving the number of unicode characters uses `String.length`, since the whole string needs to be iterated.
-
-Each character in the string "héllò" above is an Unicode codepoint. One may use `String.codepoints` to split a string into smaller strings representing its codepoints:
+Notice the number of bytes in that string is 6, even though it has 5 characters. That's because the character "ö" takes 2 bytes to be represented in UTF-8. We can get the actual length of the string, based on the number of characters, by using the `String.length/1` function:
 
 ```iex
-iex> String.codepoints "héllò"
-["h", "é", "l", "l", "ó"]
+iex> String.length("hellö")
+5
 ```
 
-The Unicode standard assigns an integer value to each character. Elixir allows a developer to retrieve or insert a character based on its integer codepoint value as well:
+The [String module](/docs/stable/String.html) contains a bunch of functions that operate on strings as defined in the Unicode standard:
 
 ```iex
-# Getting the integer codepoint
-iex> ?h
-104
-iex> ?é
-233
-
-# Inserting a codepoint based on its hexadecimal value
-iex> "h\xE9ll\xF2"
-"héllò"
+iex> String.upcase("hellö")
+"HELLÖ"
 ```
 
-UTF-8 also plays nicely with pattern matching. In the example below, we are extracting the first UTF-8 codepoint of a String and assigning the rest of the string to the variable `rest`:
+Keep in mind `single-quoted` and `double-quoted` strings are not equivalent in Elixir as they are represented by different types:
 
 ```iex
-iex> << eacute :: utf8, rest :: binary >> = "épa"
-"épa"
-iex> eacute
-233
-iex> << eacute :: utf8 >>
-"é"
-iex> rest
-"pa"
+iex> 'hellö' == "hellö"
+false
 ```
 
-In general, you will find working with binaries and strings in Elixir a breeze. Whenever you want to work with raw binaries, one can use [Erlang's binary module](http://www.erlang.org/doc/man/binary.html), and use [Elixir's String module](http://elixir-lang.org/docs/stable/String.html) when you want to work on strings, which are simply UTF-8 encoded binaries.
+We will talk more about Unicode support and the difference between single and double-quoted strings in the "Binaries, strings and char lists" chapter.
 
-## 2.5 Blocks
+## 2.5 Anonymous functions
 
-One of the first control flow constructs we usually learn is the conditional `if`. In Elixir, we could write `if` as follow:
+Functions are delimited by the keywords `fn` and `end`:
 
 ```iex
-iex> if true, do: 1 + 2
+iex> add = fn a, b -> a + b end
+#Function<12.71889879/2 in :erl_eval.expr/5>
+iex> is_function(add)
+true
+iex> is_function(add, 2)
+true
+iex> is_function(add, 1)
+false
+iex> add.(1, 2)
 3
 ```
 
-The `if` expression can also be written using the block syntax:
+Functions are "first class citizens" in Elixir meaning they can be passed as arguments to other functions just as integers and strings can. In the example, we have passed the function in the variable `add` to the `is_function/1` function which correctly returned `true`. We can also check the arity of the function by calling `is_function/2`.
 
-```iex
-iex> if true do
-...>   a = 1 + 2
-...>   a + 10
-...> end
-13
-```
+Note a dot (`.`) in between the variable and parenthesis is required to invoke an anonymous function.
 
-You can think of `do`/`end` blocks as a convenience for passing a group of expressions to `do:`. It is exactly the same as:
+Anonymous functions are closures, and as such they can access variables that are in scope when the function is defined:
 
 ```iex
-iex> if true, do: (
-...>   a = 1 + 2
-...>   a + 10
-...> )
-13
-```
-
-We can pass an `else` clause in the block syntax:
-
-```elixir
-if false do
-  :this
-else
-  :that
-end
-```
-
-It is important to notice that `do`/`end` always binds to the farthest function call. For example, the following expression:
-
-```elixir
-is_number if true do
-  1 + 2
-end
+iex> add_two = fn a -> add.(a, 2) end
+#Function<6.71889879/1 in :erl_eval.expr/5>
+iex> add_two.(2)
+4
 ```
 
-Would be parsed as:
-
-```elixir
-is_number(if true) do
-  1 + 2
-end
-```
-
-Which is not what we want since `do` is binding to the farthest function call, in this case `is_number`. Adding explicit parenthesis is enough to resolve the ambiguity:
-
-```elixir
-is_number(if true do
-  1 + 2
-end)
-```
-
-## 2.6 Control flow structures
-
-In this section we'll describe Elixir's main control flow structures.
-
-### 2.6.1 Revisiting pattern matching
-
-At the beginning of this chapter we have seen some pattern matching examples:
+Keep in mind that a variable assigned inside a function does not affect its surrounding environment:
 
 ```iex
-iex> [h | t] = [1,2,3]
-[1, 2, 3]
-iex> h
-1
-iex> t
-[2, 3]
+iex> x = 42
+42
+iex> (fn -> x = 0 end).()
+0
+iex> x
+42
 ```
 
-In Elixir, `=` is not an assignment operator as in programming languages like Java, Ruby, Python, etc. `=` is actually a match operator which will check if the expressions on both left and right side match.
+## 2.6 (Linked) Lists
 
-Many control-flow structures in Elixir rely extensively on pattern matching and the ability for different clauses to match. In some cases, you may want to match against the value of a variable, which can be achieved with the `^` operator:
+Elixir uses square brackets to specify a list of values. Values can be of any type:
 
 ```iex
-iex> x = 1
-1
-iex> ^x = 1
-1
-iex> ^x = 2
-** (MatchError) no match of right hand side value: 2
-iex> x = 2
-2
-```
-
-In Elixir, it is a common practice to assign a value to underscore `_` if we don't intend to use it. For example, if only the head of the list matters to us, we can assign the tail to underscore:
-
-```iex
-iex> [h | _] = [1,2,3]
-[1, 2, 3]
-iex> h
-1
-```
-
-The variable `_` in Elixir is special in that it can never be read from. Trying to read from it gives an unbound variable error:
-
-```iex
-iex> _
-** (ErlangError) erlang error {:unbound_var, :_}
+iex> [1, 2, true, 3]
+[1, 2, true, 3]
+iex> length [1, 2, 3]
+3
 ```
 
-Although pattern matching allows us to build powerful constructs, its usage is limited. For instance, you cannot make function calls on the left side of a match. The following example is invalid:
+Two lists can be concatenated and subtracted using the `++/2` and `--/2` operators:
 
 ```iex
-iex> length([1,[2],3]) = 3
-** (ErlangError) erlang error :illegal_pattern
-```
-
-### 2.6.2 Case
-
-A `case` allows us to compare a value against many patterns until we find a matching one:
-
-```elixir
-case { 1, 2, 3 } do
-  { 4, 5, 6 } ->
-    "This won't match"
-  { 1, x, 3 } ->
-    "This will match and assign x to 2"
-  _ ->
-    "This will match any value"
-end
-```
-
-As in the `=` operator, any assigned variable will be overridden in the match clause. If you want to pattern match against a variable, you need to use the `^` operator:
-
-```elixir
-x = 1
-case 10 do
-  ^x -> "Won't match"
-  _  -> "Will match"
-end
-```
-
-Each match clause also supports special conditions specified via guards:
-
-```elixir
-case { 1, 2, 3 } do
-  { 4, 5, 6 } ->
-    "This won't match"
-  { 1, x, 3 } when x > 0 ->
-    "This will match and assign x"
-  _ ->
-    "No match"
-end
-```
-
-In the example above, the second clause will only match when x is positive. The Erlang VM only allows a limited set of expressions as guards:
-
-* comparison operators (`==`, `!=`, `===`, `!==`, `>`, `<`, `<=`, `>=`);
-* boolean operators (`and`, `or`) and negation operators (`not`, `!`);
-* arithmetic operators (`+`, `-`, `*`, `/`);
-* `<>` and `++` as long as the left side is a literal;
-* the `in` operator;
-* all the following type check functions (the number preceded by slash represents number of arguments):
-
-    * is_atom/1
-    * is_binary/1
-    * is_bitstring/1
-    * is_boolean/1
-    * is_float/1
-    * is_function/1
-    * is_function/2
-    * is_integer/1
-    * is_list/1
-    * is_number/1
-    * is_pid/1
-    * is_port/1
-    * is_record/1
-    * is_record/2
-    * is_reference/1
-    * is_tuple/1
-    * is_exception/1
-
-* plus these functions:
-
-    * abs(Number)
-    * bit_size(Bitstring)
-    * byte_size(Bitstring)
-    * div(Number, Number)
-    * elem(Tuple, n)
-    * float(Term)
-    * hd(List)
-    * length(List)
-    * node()
-    * node(Pid|Ref|Port)
-    * rem(Number, Number)
-    * round(Number)
-    * self()
-    * size(Tuple|Bitstring)
-    * tl(List)
-    * trunc(Number)
-    * tuple_size(Tuple)
-
-Many independent guard clauses can also be given at the same time. For example, consider a function that checks if the first element of a tuple or a list is zero. It could be written as:
-
-```elixir
-def first_is_zero?(tuple_or_list) when
-  elem(tuple_or_list, 0) == 0 or hd(tuple_or_list) == 0 do
-  true
-end
-```
-
-However, the example above will always fail. If the argument is a list, calling `elem` on a list will raise an error. If the element is a tuple, calling `hd` on a tuple will also raise an error. To fix this, we can rewrite it to become two different clauses:
-
-```elixir
-def first_is_zero?(tuple_or_list)
-    when elem(tuple_or_list, 0) == 0
-    when hd(tuple_or_list) == 0 do
-  true
-end
+iex> [1, 2, 3] ++ [4, 5, 6]
+[1, 2, 3, 4, 5, 6]
+iex> [1, true, 2, false, 3, true] -- [true, false]
+[1, 2, 3, true]
 ```
 
-In such cases, if there is an error in one of the guards, it won't affect the next one.
-
-### 2.6.3 Functions
-
-In Elixir, anonymous functions can accept many clauses and guards, similar to the `case` mechanism we have just seen:
-
-```elixir
-f = fn
-  x, y when x > 0 -> x + y
-  x, y -> x * y
-end
-
-f.(1, 3)  #=> 4
-f.(-1, 3) #=> -3
-```
-
-As Elixir is an immutable language, the binding of the function is also immutable. This means that setting a variable inside the function does not affect its outer scope:
-
-```elixir
-x = 1
-(fn -> x = 2 end).()
-x #=> 1
-```
-
-### 2.6.4 Receive
-
-This next control-flow mechanism is essential to Elixir's actors. In Elixir, the code is run in separate processes that exchange messages between them. Those processes are not Operating System processes (they are actually quite light-weight) but are called so since they do not share state with each other.
-
-In order to exchange messages, each process has a mailbox where the received messages are stored. The `receive` mechanism allows us to go through this mailbox searching for a message that matches the given pattern. Here is an example that uses the arrow operator `<-` to send a message to the current process and then collects this message from its mailbox:
+Throughout the tutorial, we will talk a lot about the head and tail of a list. The head is the first element of a list and the tail is the remainder of a list. They can be retrieved with the functions `hd/1` and `tl/1`. Let's assign a list to a variable and retrieve its head and tail:
 
 ```iex
-# Get the current process id
-iex> current_pid = self
-
-# Spawn another process that will send a message to current_pid
-iex> spawn fn ->
-  current_pid <- { :hello, self }
-end
-<0.36.0>
-
-
-# Collect the message
-iex> receive do
-...>   { :hello, pid } ->
-...>     IO.puts "Hello from #{inspect(pid)}"
-...> end
-Hello from <0.36.0>
+iex> list = [1,2,3]
+iex> hd(list)
+1
+iex> tl(list)
+[2, 3]
 ```
 
-You may not see exactly `<0.36.0>` back, but something similar. If there are no messages in the mailbox, the current process will hang until a matching message arrives unless an after clause is given:
+Getting the head or the tail of an empty list is an error:
 
 ```iex
-iex> receive do
-...>   :waiting ->
-...>     IO.puts "This may never come"
-...> after
-...>   1000 -> # 1 second
-...>     IO.puts "Too late"
-...> end
-Too late
+iex> hd []
+** (ArgumentError) argument error
 ```
 
-Notice we spawned a new process using the `spawn` function passing another function as argument. We will talk more about those processes and even how to exchange messages in between different nodes in a later chapter.
+Oops!
 
-### 2.6.5 Try
+## 2.7 Tuples
 
-`try` in Elixir is used to catch values that are thrown. Let's start with an example:
+Elixir uses curly brackets to define tuples. As lists, tuples can hold any value:
 
 ```iex
-iex> try do
-...>   throw 13
-...> catch
-...>   number -> number
-...> end
-13
+iex> {:ok, "hello"}
+{:ok, "hello"}
+iex> size {:ok, "hello"}
+2
 ```
 
-`try/catch` is a control-flow mechanism, useful in rare situations where your code has complex exit strategies and it is easier to `throw` a value back up in the stack. `try` also supports guards in `catch` and an `after` clause that is invoked regardless of whether or not the value was caught:
+Tuples store elements contiguously in memory. This means accessing a tuple element per index or getting the tuple size is a fast operation (indexes start from zero):
 
 ```iex
-iex> try do
-...>   throw 13
-...> catch
-...>   nan when not is_number(nan) -> nan
-...> after
-...>   IO.puts "Didn't catch"
-...> end
-Didn't catch
-** throw 13
-    erl_eval:expr/3
+iex> tuple = {:ok, "hello"}
+{:ok, "hello"}
+iex> elem(tuple, 1)
+"hello"
+iex> tuple_size(tuple)
+2
 ```
 
-Notice that a thrown value which hasn't been caught halts the software. For this reason, Elixir considers such clauses unsafe (since they may or may not fail) and does not allow variables defined inside `try/catch/after` to be accessed from the outer scope:
+It is also possible to set an element at a particular index in a tuple with `set_elem/3`:
 
 ```iex
-iex> try do
-...>   new_var = 1
-...> catch
-...>   value -> value
-...> end
-1
-iex> new_var
-** (UndefinedFunctionError) undefined function: IEx.Helpers.new_var/0
+iex> tuple = {:ok, "hello"}
+{:ok, "hello"}
+iex> set_elem(tuple, 1, "world")
+{:ok, "world"}
+iex> tuple
+{:ok, "hello"}
 ```
 
-The common strategy is to explicitly return all arguments from `try`:
+Notice that `set_elem/3` returned a new tuple. The original tuple stored in the `tuple` variable was not modified because Elixir data types are immutable. By being immutable, Elixir code is easier to reason about as you never need to worry if a particular code is mutating your data structure in place.
 
-```elixir
-{ x, y } = try do
-  x = calculate_some_value()
-  y = some_other_value()
-  { x, y }
-catch
-  _ -> { nil, nil }
-end
+By being immutable, Elixir also helps eliminate common cases where concurrent code has race conditions because two different entities are trying to change a data structure at the same time.
 
-x #=> returns the value of x or nil for failures
-```
+## 2.8 Lists or tuples?
 
-### 2.6.6 If and Unless
+What is the difference between lists and tuples?
 
-Besides the four main control-flow structures above, Elixir provides some extra control-flow structures to help on our daily work. For example, `if` and `unless`:
+Lists are stored in memory as linked lists. This means each element in a list points to the next element, and then to the next element, until it reaches the end of a list. We call each of those pairs in a list a **cons cell**:
 
 ```iex
-iex> if true do
-iex>   "This works!"
-iex> end
-"This works!"
-
-iex> unless true do
-iex>   "This will never be seen"
-iex> end
-nil
+iex> list = [1|[2|[3|[]]]]
+[1, 2, 3]
 ```
 
-Remember that `do/end` blocks in Elixir are simply a shortcut to the keyword notation. So one could also write:
+This means accessing the length of a list is a linear operation: we need to traverse the whole list in order to figure out its size. Updating a list is fast as long as we are prepending elements:
 
 ```iex
-iex> if true, do: "This works!"
-"This works!"
-```
-
-Or even more complex examples like:
-
-```elixir
-# This is equivalent...
-if false, do: 1 + 2, else: 10 + 3
-
-# ... to this
-if false do
-  1 + 2
-else
-  10 + 3
-end
+iex> [0] ++ list
+[0, 1, 2, 3]
+iex> list ++ [4]
+[1, 2, 3, 4]
 ```
 
-In Elixir, all values except `false` and `nil` evaluate to true. Therefore there is no need to explicitly convert the `if` argument to a boolean. If you want to check if one of many conditions are true, you can use the `cond` macro.
+The first operation is fast because we are simply adding a new cons that points to the remaining of `list`. The second one is slow because we need to rebuild the whole list and add a new element to the end.
 
-### 2.6.7 Cond
+Tuples, on the other hand, are stored contiguously in memory. This means getting the tuple size or accessing an element by index is fast. However, updating or adding elements to tuples is expensive because it requires copying the whole tuple in memory.
 
-Whenever you want to check for many conditions at the same time, Elixir allows developers to use `cond` instead of nesting many `if` expressions:
+Those performance characteristics dictate the usage of those data structures. One very common use case for tuples is to use them to return extra information from a function. For example, `File.read/1` is a function that can be used to read file contents and it returns tuples:
 
-```elixir
-cond do
-  2 + 2 == 5 ->
-    "This will never match"
-  2 * 2 == 3 ->
-    "Nor this"
-  1 + 1 == 2 ->
-    "But this will"
-end
-```
-
-If none of the conditions return true, an error will be raised. For this reason, it is common to see a last condition equal to `true`, which will always match:
-
-```elixir
-cond do
-  2 + 2 == 5 ->
-    "This will never match"
-  2 * 2 == 3 ->
-    "Nor this"
-  true ->
-    "This will always match (equivalent to else)"
-end
+```iex
+iex> File.read("path/to/existing/file")
+{:ok, "... contents ..."}
+iex> File.read("path/to/unknown/file")
+{:error, :enoent}
 ```
 
-## 2.7 Built-in functions
-
-Elixir ships with many built-in functions automatically available in the current scope. In addition to the control flow expressions seen above, Elixir also adds: `elem` and `set_elem` to read and set values in tuples, `inspect` that returns the representation of a given data type as a binary, and many others. All of these functions imported by default are available in [`Kernel`](/docs/stable/Kernel.html) and [Elixir special forms are available in `Kernel.SpecialForms`](/docs/stable/Kernel.SpecialForms.html).
-
-All of these functions and control flow expressions are essential for building Elixir programs. In some cases though, one may need to use functions available from Erlang, let's see how.
-
-## 2.8 Calling Erlang functions
-
-One of Elixir's assets is easy integration with the existing Erlang ecosystem. Erlang ships with a group of libraries called OTP (Open Telecom Platform). Besides being a standard library, OTP provides several facilities to build OTP applications with supervisors that are robust, distributed and fault-tolerant.
+If the path given to `File.read/1` exists, it returns a tuple with the atom `:ok` as first element and the file contents as second. Otherwise, it returns a tuple with `:error` and the error reason.
 
-Since an Erlang module is nothing more than an atom, invoking those libraries from Elixir is quite straight-forward. For example, we can call the [function `flatten` from the module `lists`](http://www.erlang.org/doc/man/lists.html#flatten-1) or interact with [the `math` module](http://www.erlang.org/doc/man/math.html) as follows:
+Most of the time, Elixir is going to guide you to do the right thing. For example, there is a `elem/2` function to access a tuple item but there is no built-in equivalent for lists:
 
 ```iex
-iex> :lists.flatten [1,[2],3]
-[1,2,3]
-iex> :math.sin :math.pi
-1.2246467991473532e-16
+iex> tuple = {:ok, "hello"}
+{:ok, "hello"}
+iex> elem(tuple, 1)
+"hello"
 ```
 
-Erlang's OTP is very well documented and we will learn more about building OTP applications in the Mix chapters:
+When "counting" the number of elements in a data structure, Elixir also abides by a simple rule: the function should be named `size` if the operation is in constant time (i.e. the value is pre-calculated) or `length` if the operation requires explicit counting.
 
-* [OTP docs](http://www.erlang.org/doc/)
-* [Standard library docs](http://www.erlang.org/doc/man/STDLIB_app.html)
+For example, we have used 4 counting functions so far: `byte_size/1` (for the number of bytes in a string), `tuple_size/1` (for the tuple size), `length/1` (for the list length) and `String.length/1` (for the number of characters in a string). That said, we use `byte_size` to get the number of bytes in a string, which is cheap, but retrieving the number of unicode characters uses `String.length`, since the whole string needs to be iterated.
 
-That's all for now. The next chapter will discuss how to organize our code into modules so it can be easily reused between different applications.
+Elixir also provides `Port`, `Reference` and `PID` as data types (usually used in process communication), and we will take a quick look at them when talking about processes. For now, let's take a look at some of the basic operators that go with our basic types.
diff --git a/getting_started/20.markdown b/getting_started/20.markdown
new file mode 100644
index 000000000..f9286d166
--- /dev/null
+++ b/getting_started/20.markdown
@@ -0,0 +1,43 @@
+---
+layout: getting_started
+title: 20 Where to go next
+guide: 20
+last: true
+---
+
+# {{ page.title }}
+
+Eager to learn more? Keep on reading!
+
+## 20.1 Build your first Elixir project
+
+In order to get your first project started, Elixir ships with a build tool called [`Mix`](/getting_started/mix/1.html). You can get your new project started by simply running:
+
+    mix new path/to/new/project
+
+You can learn more about Mix and other applications that ship with Elixir in the links below:
+
+* [Mix - a build tool for Elixir](/getting_started/mix/1.html)
+* [ExUnit - a unit test framework](/getting_started/ex_unit/1.html)
+
+## 20.2 Community and other resources
+
+On the sidebar, you can find the link to some Elixir books and screencasts. They are plenty of Elixir resources out there, like conference talks, open source projects, and other learning material produced by the community.
+
+Remember that in case of any difficulties, you can always visit the **#elixir-lang** channel on **irc.freenode.net** or send a message to the [mailing list](http://groups.google.com/group/elixir-lang-talk). You can be sure that there will be someone willing to help. And to keep posted on the latest news and announcements, follow the [blog](http://elixir-lang.org/blog/) and follow language developments on the [elixir-core mailing list](http://groups.google.com/group/elixir-lang-core).
+
+Don't forget [you can also check the source code of Elixir itself](https://github.com/elixir-lang/elixir), which is mostly written in Elixir (mainly the `lib` directory), or [explore Elixir's documentation](http://elixir-lang.org/docs.html).
+
+## 20.3 A Byte of Erlang
+
+As the main page of this site puts it:
+
+> Elixir is a programming language built on top of the Erlang VM.
+
+Sooner than later, an Elixir developer will want to interface with existing Erlang libraries. Here's a list of online resources that cover Erlang's fundamentals and its more advanced features:
+
+* This [Erlang Syntax: A Crash Course](http://elixir-lang.org/crash-course.html) provides a concise intro to Erlang's syntax. Each code snippet is accompanied by equivalent code in Elixir. This is an opportunity for you to not only get some exposure to the Erlang's syntax but also review some of the things you have learned in the present guide.
+
+* Erlang's official website has a short [tutorial](http://www.erlang.org/course/concurrent_programming.html) with pictures that briefly describe Erlang's primitives for concurrent programming.
+
+* [Learn You Some Erlang for Great Good!](http://learnyousomeerlang.com/) is an excellent introduction to Erlang, its design principles, standard library, best practices and much more. If you are serious about Elixir, you'll want to get a solid understanding of Erlang principles. Once you have read through the crash course mentioned above, you'll be able to safely skip the first couple of chapters in the book that mostly deal with the syntax. When you reach [The Hitchhiker's Guide to Concurrency](http://learnyousomeerlang.com/the-hitchhikers-guide-to-concurrency) chapter, that's where the real fun starts.
diff --git a/getting_started/3.markdown b/getting_started/3.markdown
index 8e297cb2c..a457d9a08 100644
--- a/getting_started/3.markdown
+++ b/getting_started/3.markdown
@@ -1,469 +1,114 @@
 ---
 layout: getting_started
-title: 3 Modules
+title: 3 Basic operators
 guide: 3
-total_guides: 7
 ---
 
 # {{ page.title }}
 
-In Elixir, you can group several functions into a module. In the previous chapter, for example, we invoked functions from the [module `List`](/docs/stable/List.html):
+In the previous chapter, we saw Elixir provides `+`, `-`, `*`, `/` as arithmetic operators, plus the functions `div/2` and `rem/2` for integer division and remainder.
 
-```iex
-iex> List.flatten [1,[2],3]
-[1, 2, 3]
-```
-
-In order to create our own modules in Elixir, all we have to do is to call the `defmodule` function and use `def` to define our functions:
+Elixir also provides `++` and `--` to manipulate lists:
 
 ```iex
-iex> defmodule Math do
-...>   def sum(a, b) do
-...>     a + b
-...>   end
-...> end
-
-iex> Math.sum(1, 2)
-3
-```
-
-Before diving into modules, let's first have a brief overview about compilation.
-
-## 3.1 Compilation
-
-Most of the time it is convenient to write modules into files so they can be compiled and reused. Let's assume we have a file named `math.ex` with the following contents:
-
-```elixir
-defmodule Math do
-  def sum(a, b) do
-    a + b
-  end
-end
+iex> [1,2,3] ++ [4,5,6]
+[1,2,3,4,5,6]
+iex> [1,2,3] -- [2]
+[1,3]
 ```
 
-This file can be compiled using `elixirc` (remember, if you installed Elixir from a package or compiled it, `elixirc` will be inside the bin directory):
-
-    elixirc math.ex
-
-This will generate a file named `Elixir.Math.beam` containing the bytecode for the defined module. Now, if we start `iex` again, our module definition will be available (considering `iex` is being started in the same directory the bytecode file is):
+String concatenation is done with `<>`:
 
 ```iex
-iex> Math.sum(1, 2)
-3
-```
-
-Elixir projects are usually organized into three directories:
-
-* ebin - contains the compiled bytecode
-* lib - contains elixir code (usually `.ex` files)
-* test - contains tests (usually `.exs` files)
-
-Whenever interacting with an existing library, you may need to explicitly tell Elixir to look for bytecode in the `ebin` directory:
-
-    iex -pa ebin
-
-Where `-pa` stands for `path append`. The same option can also be passed to `elixir` and `elixirc` executables. You can execute `elixir` and `elixirc` without arguments to get a list of options.
-
-## 3.2 Scripted mode
-
-In addition to the Elixir file `.ex`, Elixir also supports `.exs` files for scripting. Elixir treats both files exactly the same way, the only difference is in intention. `.ex` files are meant to be compiled while `.exs` files are used for scripting, without the need for compilation. For instance, one can create a file called `math.exs`:
-
-```elixir
-defmodule Math do
-  def sum(a, b) do
-    a + b
-  end
-end
-
-# IO.puts expects a list or a binary, so we use the string representation of the sum
-IO.puts to_string(Math.sum(1, 2))
+iex> "foo" <> "bar"
+"foobar"
 ```
 
-And execute it as:
-
-    elixir math.exs
-
-The file will be compiled in memory and executed, printing "3" as the result. No bytecode file will be created.
-
-## 3.3 Functions and private functions
-
-Inside a module, we can define functions with `def` and private functions with `defp`. A function defined with `def` is available to be invoked from other modules while a private function can only be invoked locally.
-
-```elixir
-defmodule Math do
-  def sum(a, b) do
-    do_sum(a, b)
-  end
-
-  defp do_sum(a, b) do
-    a + b
-  end
-end
-
-Math.sum(1, 2)    #=> 3
-Math.do_sum(1, 2) #=> ** (UndefinedFunctionError)
-```
-
-Function declarations also support guards and multiple clauses. If a function has several clauses, Elixir will try each clause until it finds one that matches. Here is the implementation of a function that checks if the given number is zero or not:
-
-```elixir
-defmodule Math do
-  def zero?(0) do
-    true
-  end
-
-  def zero?(x) when is_number(x) do
-    false
-  end
-end
-
-Math.zero?(0)  #=> true
-Math.zero?(1)  #=> false
-
-Math.zero?([1,2,3])
-#=> ** (FunctionClauseError)
-```
-
-Giving an argument that does not match any of the clauses raises an error.
-
-Named functions also support default arguments:
-
-```elixir
-defmodule Concat do
-  def join(a, b, sep // " ") do
-    a <> sep <> b
-  end
-end
-
-IO.puts Concat.join("Hello", "world")      #=> Hello world
-IO.puts Concat.join("Hello", "world", "_") #=> Hello_world
-```
-
-Any expression is allowed to serve as a default value, but it won't be evaluated during the function definition; it will simply be stored for later use. Every time the function is invoked and any of its default values have to be used, the expression for that default value will be evaluated:
-
-```elixir
-defmodule DefaultTest do
-  def dowork(x // IO.puts "hello") do
-    x
-  end
-end
-```
+Elixir also provides three boolean operators: `or`, `and` and `not`. These operators are strict in the sense that they expect a boolean (`true` or `false`) as their first argument:
 
 ```iex
-iex> DefaultTest.dowork 123
-123
-iex> DefaultTest.dowork
-hello
-:ok
-```
-
-If a function with default values has multiple clauses, it is recommended to create a separate clause without an actual body, just for declaring defaults:
-
-```elixir
-defmodule Concat do
-  def join(a, b // nil, sep // " ")
-
-  def join(a, b, _sep) when nil?(b) do
-    a
-  end
-
-  def join(a, b, sep) do
-    a <> sep <> b
-  end
-end
-
-IO.puts Concat.join("Hello", "world")      #=> Hello world
-IO.puts Concat.join("Hello", "world", "_") #=> Hello_world
-IO.puts Concat.join("Hello")               #=> Hello
-```
-
-When using default values, one must be careful to avoid overlapping function definitions. Consider the following example:
-
-```elixir
-defmodule Concat do
-  def join(a, b) do
-    IO.puts "***First join"
-    a <> b
-  end
-
-  def join(a, b, sep // " ") do
-    IO.puts "***Second join"
-    a <> sep <> b
-  end
-end
+iex> true and true
+true
+iex> false or is_atom(:example)
+true
 ```
 
-If we save the code above in a file named "concat.ex" and compile it, Elixir will emit the following warning:
-
-    concat.ex:7: this clause cannot match because a previous clause at line 2 always matches
-
-The compiler is telling us that invoking the `join` function with two arguments will always choose the first definition of `join` whereas the second one will only be invoked when three arguments are passed:
-
-    $ iex concat.ex
+Providing a non-boolean will raise an exception:
 
 ```iex
-iex> Concat.join "Hello", "world"
-***First join
-"Helloworld"
-```
-
-```iex
-iex> Concat.join "Hello", "world", "_"
-***Second join
-"Hello_world"
-```
-
-### 3.4 Recursion
-
-Due to immutability, loops in Elixir (and in functional programming languages) are written differently from conventional imperative languages. For example, in an imperative language, one would write:
-
-```c
-for(i = 0; i < array.length; i++) {
-  array[i] = array[i] * 2
-}
-```
-
-In the example above, we are mutating the array which is not possible in Elixir. Therefore, functional languages rely on recursion: a function is called recursively until a condition is reached. Consider the example below that manually sums all the items in the list:
-
-```elixir
-defmodule Math do
-  def sum_list([h|t], acc) do
-    sum_list(t, h + acc)
-  end
-
-  def sum_list([], acc) do
-    acc
-  end
-end
-
-Math.sum_list([1,2,3], 0) #=> 6
+iex> 1 and true
+** (ArgumentError) argument error
 ```
 
-In the example above, we invoke `sum_list` giving a list `[1,2,3]` and the initial value `0` as arguments. When a function has many clauses, we will try each clause until we find one that matches according to the pattern matching rules. In this case, the list `[1,2,3]` matches against `[h|t]` which assigns `h = 1` and `t = [2,3]` while `acc` is set to 0.
-
-Then, we add the head of the list to the accumulator `h + acc` and call `sum_list` again, recursively, passing the tail of the list as argument. The tail will once again match `[h|t]` until the list is empty, as seen below:
-
-```elixir
-sum_list [1,2,3], 0
-sum_list [2,3], 1
-sum_list [3], 3
-sum_list [], 6
-```
-
-When the list is empty, it will match the final clause which returns the final result of `6`. In imperative languages, such implementation would usually fail for large lists because the stack (in which our execution path is kept) would grow until it reaches a limit. Elixir, however, does tail call optimization in which the stack does not grow when a function exits by calling another function.
-
-Recursion and tail call optimization are an important part of Elixir and are commonly used to create loops, especially in cases where a process needs to wait and respond to messages (using the `receive` macro we saw in the previous chapter). However, recursion as above is rarely used to manipulate lists, since [the `Enum` module](/docs/stable/Enum.html) already abstracts such use cases. For instance, the example above could be simply written as:
+`or` and `and` are short-circuit operators. They only execute the right side if the left side is not enough to determine the result:
 
-```elixir
-Enum.reduce([1,2,3], 0, fn(x, acc) -> x + acc end)
-```
-
-## 3.5 Directives
-
-In order to facilitate software reuse, Elixir supports three directives. As we are going to see below, they are called directives because they have **lexical scope**.
-
-### 3.5.1 alias
-
-`alias` allows you to setup aliases for any given module name. Imagine our `Math` module has a special list for doing math specific operations:
-
-```elixir
-defmodule Math do
-  alias Math.List, as: List
-end
-```
-
-From now on, any reference to `List` will automatically expand to `Math.List`. In case one wants to access the original `List`, it can be done by accessing the module via `Elixir`:
-
-```elixir
-List.values             #=> uses Math.List.values
-Elixir.List.values      #=> uses List.values
-Elixir.Math.List.values #=> uses Math.List.values
-```
-
-> Note: All modules defined in Elixir are defined inside a main Elixir namespace. However, for convenience, you can omit the Elixir main namespace.
-
-Calling `alias` without an `as` option sets the alias automatically to the last part of the module name, for example:
-
-```elixir
-alias Math.List
-```
-
-Is the same as:
-
-```elixir
-alias Math.List, as: List
-```
-
-Notice that `alias` is **lexically scoped**, which allows you to set aliases inside specific functions:
-
-```elixir
-defmodule Math do
-  def add(a, b) do
-    alias Math.List
-    # ...
-  end
-
-  def minus(a, b) do
-    # ...
-  end
-end
-```
-
-In the example above, since we are invoking `alias` inside the function `add`, the alias will just be valid inside the function `add`. `minus` won't be affected at all.
-
-### 3.5.2 require
-
-In general, a module does not need to be required before usage, except if we want to use the macros available in that module. For instance, suppose we created our own `my_if` implementation in a module named `MyMacros`. If we want to invoke it, we need to first explicitly require `MyMacros`:
-
-```elixir
-defmodule Math do
-  require MyMacros
-  MyMacros.my_if do_something, it_works
-end
-```
-
-An attempt to call a macro that was not loaded will raise an error. Note that like the `alias` directive, `require` is also lexically scoped. We will talk more about macros in chapter 5.
-
-### 3.5.3 import
-
-We use `import` whenever we want to easily access functions or macros from other modules without using the qualified name. For instance, if we want to use the `duplicate` function from `List` several times in a module and we don't want to always type `List.duplicate`, we can simply import it:
-
-```elixir
-defmodule Math do
-  import List, only: [duplicate: 2]
-
-  def some_function do
-    # call duplicate
-  end
-end
-```
-
-In this case, we are importing only the function `duplicate` (with arity 2) from `List`. Although `only:` is optional, its usage is recommended. `except` could also be given as an option.
-
-`import` also supports selectors, to filter what you want to import. We have four selectors:
-
-* `:default` - imports all functions and macros, except the ones starting by underscore;
-* `:all` - imports all functions and macros;
-* `:functions` - imports all functions;
-* `:macros` - imports all macros;
-
-For example, to import all macros, one could write:
-
-```elixir
-import MyMacros, only: :macros
-```
-
-Or to import all functions, you could write:
-
-```elixir
-import MyFunctions, only: :functions
-```
-
-Note that `import` is also **lexically scoped**, this means we can import specific macros inside specific functions:
-
-```elixir
-defmodule Math do
-  def some_function do
-    import List, only: [duplicate: 2]
-    # call duplicate
-  end
-end
-```
-
-In the example above, the imported `List.duplicate` is only visible within that specific function. `duplicate` won't be available in any other function in that module (or any other module for that matter).
-
-Note that importing a module automatically requires it. Furthermore, `import` also accepts the `as:` option which is automatically passed to `alias` in order to create an alias.
-
-## 3.6 Module attributes
-
-Elixir brings the concept of module attributes from Erlang. For example:
+```iex
+iex> false and error("This error will never be raised")
+false
 
-```elixir
-defmodule MyServer do
-  @vsn 2
-end
+iex> true or error("This error will never be raised")
+true
 ```
 
-In the example above, we are explicitly setting the version attribute for that module. `@vsn` is used by the code reloading mechanism in the Erlang VM to check if a module has been updated or not. If no version is specified, the version is set to the MD5 checksum of the module functions.
-
-Elixir has a handful of reserved attributes. Here are just a few of them, the most commonly used ones. Take a look at the docs for [Module](http://elixir-lang.org/docs/stable/Module.html) for a complete list of supported attributes.
-
-* `@moduledoc` - provides documentation for the current module;
-* `@doc` - provides documentation for the function or macro that follows the attribute;
-* `@behaviour` - (notice the British spelling) used for specifying an OTP or user-defined behaviour;
-* `@before_compile` - provides a hook that will be invoked before the module is compiled. This makes it possible to inject functions inside the module exactly before compilation;
+> Note: If you are an Erlang developer, `and` and `or` in Elixir actually map to the `andalso` and `orelse` operators in Erlang.
 
-The following attributes are part of [typespecs](http://www.erlang.org/doc/reference_manual/typespec.html) and are also supported by Elixir:
+Besides these boolean operators, Elixir also provides `||`, `&&` and `!` which accept arguments of any type. For these operators, all values except `false` and `nil` will evaluate to true:
 
-* `@spec` - provides a specification for a function;
-* `@callback` - provides a specification for the behavior callback;
-* `@type` - defines a type to be used in `@spec`;
-* `@typep` - defines a private type to be used in `@spec`;
-* `@opaque` - defines an opaque type to be used in `@spec`;
-
-In addition to the built-in attributes outlined above, custom attributes may also be added:
-
-```elixir
-defmodule MyServer do
-  @my_data 13
-  IO.inspect @my_data #=> 13
-end
+```iex
+# or
+iex> 1 || true
+1
+iex> false || 11
+11
+
+# and
+iex> nil && 13
+nil
+iex> true && 17
+17
+
+# !
+iex> !true
+false
+iex> !1
+false
+iex> !nil
+true
 ```
 
-Unlike Erlang, user defined attributes are not stored in the module by default since it is common in Elixir to use such attributes to store temporary data. A developer can configure an attribute to behave closer to Erlang by calling [`Module.register_attribute/3`](/docs/stable/Module.html#register_attribute/3).
+As a rule of thumb, use `and`, `or` and `not` when you are expecting booleans. If any of the arguments are non-boolean, use `&&`, `||` and `!`.
 
-Finally, notice that attributes can also be read inside functions:
+Elixir also provides `==`, `!=`, `===`, `!==`, `<=`, `>=`, `<` and `>` as comparison operators:
 
-```elixir
-defmodule MyServer do
-  @my_data 11
-  def first_data, do: @my_data
-  @my_data 13
-  def second_data, do: @my_data
-end
-
-MyServer.first_data #=> 11
-MyServer.second_data #=> 13
+```iex
+iex> 1 == 1
+true
+iex> 1 != 2
+true
+iex> 1 < 2
+true
 ```
 
-Notice that reading an attribute inside a function takes a snapshot of its current value. In other words, the value is read at compilation time and not at runtime. Check [the documentation for the module `Module` documentation](/docs/stable/Module.html) for other functions to manipulate module attributes.
+The difference between `==` and `===` is that the latter is more strict when comparing integers and floats:
 
-## 3.7 Nesting
-
-Modules in Elixir can be nested too:
-
-```elixir
-defmodule Foo do
-  defmodule Bar do
-  end
-end
+```iex
+iex> 1 == 1.0
+true
+iex> 1 === 1.0
+false
 ```
 
-The example above will define two modules `Foo` and `Foo.Bar`. The second can be accessed as `Bar` inside `Foo` as long as they are in the same scope. If later the developer decides to move `Bar` to another file, it will need to be referenced by its full name (`Foo.Bar`) or an alias needs to be set using the `alias` directive discussed above.
+In Elixir, we can compare two different data types:
 
-## 3.8 Aliases
-
-In Erlang (and consequently in the Erlang VM), modules and functions are represented by atoms. For instance, this is valid Erlang code:
-
-```elixir
-Mod = lists,
-Mod:flatten([1,[2],3]).
+```iex
+iex> 1 < :atom
+true
 ```
 
-In the example above, we store the atom `lists` in the variable `Mod` and then invoke the function `flatten` in it. In Elixir, the same idiom is allowed:
+The reason we can compare different data types is pragmatism. Sorting algorithms don't need to worry about different data types in order to sort. The overall sorting order is defined below:
 
-```iex
-iex> mod = :lists
-:lists
-iex> mod.flatten([1,[2],3])
-[1,2,3]
-```
+    number < atom < reference < functions < port < pid < tuple < maps < list < bitstring
 
-In other words, we are simply calling the function `flatten` on the atom `:lists`. This mechanism is exactly what empowers Elixir aliases. An alias in Elixir is a capitalized identifier (like `List`, `Keyword`, etc) which is converted to an atom representing a module during compilation. For instance, the `List` alias translates by default to the atom `Elixir.List`:
+You don't actually need to memorize this ordering, but it is important just to know an order exists.
 
-```iex
-iex> is_atom(List)
-true
-iex> to_binary(List)
-"Elixir.List"
-```
+Well, that is it for the introduction. In the next chapter, we are going to discuss some basic functions, data type conversions and a bit of control-flow.
diff --git a/getting_started/4.markdown b/getting_started/4.markdown
index 95cd7d42a..28a0288e6 100644
--- a/getting_started/4.markdown
+++ b/getting_started/4.markdown
@@ -1,364 +1,175 @@
 ---
 layout: getting_started
-title: 4 Records, Protocols & Exceptions
+title: 4 Pattern matching
 guide: 4
-total_guides: 7
 ---
 
 # {{ page.title }}
 
-Elixir provides both records and protocols. This chapter will outline the main features of both and provide some examples. More specifically, we will learn how to use `defrecord`, `defprotocol` and `defimpl`. At the end, we will briefly talk about exceptions in Elixir.
+In this chapter, we will show how the `=` operator in Elixir is actually a match operator and how to use it to pattern match inside data structures. Finally, we will learn about the pin operator `^` used to access previously bound values.
 
-## 4.1 Records
+## 4.1 The match operator
 
-Records are simple structures that hold values. For example, we can define a `FileInfo` record that is supposed to store information about files as follows:
-
-```elixir
-defrecord FileInfo, atime: nil, accesses: 0
-```
-
-The line above will define a module named `FileInfo` which contains a function named `new` that returns a new record and other functions to read and set the values:
+We have used the `=` operator a couple times to assign variables in Elixir.
 
 ```iex
-iex> file_info = FileInfo.new(atime: { 2010, 4, 17 }, accesses: 42)
-iex> file_info.atime
-{2010, 4, 17}
-iex> file_info.atime({ 2012, 10, 13 }) #=> Returns a new FileInfo
-FileInfo[atime: {2012, 10, 13}, accesses: 42]
-iex> file_info.atime
-{2010, 4, 17}
-```
-
-Notice that when we change the `atime` field of the record, we re-store the record in the `file_info` variable. This is because as almost everything else in Elixir, records are immutable. So changing the `atime` field does not update the record in place. Instead, it returns a new record with the new value set.
-
-A record is simply a tuple where the first element is the record module name. We can get the record raw representation as follows:
-
-```elixir
-inspect FileInfo.new, raw: true
-#=> "{ FileInfo, nil, 0 }"
-```
-
-Besides defining readers and writers for each attribute, Elixir records also define an `update_#{attribute}` function to update values. Such functions expect a function as argument that receives the current value and must return the new one. For example, every time the file is accessed, the accesses counter can be incremented with:
-
-```elixir
-file_info = FileInfo.new(accesses: 10)
-file_info = file_info.update_accesses(fn(x) -> x + 1 end)
-file_info.accesses #=> 11
-```
-
-### 4.1.1 Pattern matching
-
-Elixir also allows one to pattern match against records. For example, imagine we want to check if a file was accessed or not based on the `FileInfo` record above, we could implement it as follows:
-
-```elixir
-defmodule FileAccess do
-  def was_accessed?(FileInfo[accesses: 0]), do: false
-  def was_accessed?(FileInfo[]),            do: true
-end
-```
-
-The first clause will only match if a `FileInfo` record is given and its `accesses` field is equal to zero. The second clause will match any `FileInfo` record and nothing more. We can also link the value of `accesses` to a variable as follows:
-
-```elixir
-def was_accessed?(FileInfo[accesses: accesses]), do: accesses > 0
-```
-
-The pattern matching syntax can also be used to create new records:
-
-```elixir
-file_info = FileInfo[accesses: 0]
-```
-
-Whenever using the bracket syntax above, Elixir expands the record to a tuple at compilation time. That said, the clause above:
-
-```elixir
-def was_accessed?(FileInfo[accesses: 0]), do: false
-```
-
-Is effectively the same as:
-
-```elixir
-def was_accessed?({ FileInfo, _, 0 }), do: false
+iex> x = 1
+1
+iex> x
+1
 ```
 
-Using the bracket syntax is a powerful mechanism not only due to pattern matching but also regarding performance, since it provides faster times compared to `FileInfo.new` and `file_info.accesses`. The downside is that we hardcode the record name. For this reason, Elixir allows you to mix and match both styles as you may find fit.
-
-For more information on records, [check out the documentation for the `defrecord` macro](http://elixir-lang.org/docs/master/Kernel.html#defrecord/3)
-
-## 4.2 Protocols
-
-Protocols are a mechanism to achieve polymorphism in Elixir. Dispatching a protocol is available to any data type as long as it implements the protocol. Let's consider a practical example.
-
-In Elixir, only `false` and `nil` are treated as false. Everything else evaluates to true. Depending on the application, it may be important to specify a `blank?` protocol that returns a boolean for other data types that should be considered blank. For instance, an empty list or an empty binary could be considered blanks.
+In Elixir, the `=` operator is actually called *the match operator*. Let's see why:
 
-We could define this protocol as follows:
-
-```elixir
-defprotocol Blank do
-  @doc "Returns true if data is considered blank/empty"
-  def blank?(data)
-end
-```
-
-The protocol expects a function called `blank?` that receives one argument to be implemented. We can implement this protocol for some Elixir data types in the following way:
-
-```elixir
-# Integers are never blank
-defimpl Blank, for: Integer do
-  def blank?(_), do: false
-end
-
-# Just empty list is blank
-defimpl Blank, for: List do
-  def blank?([]), do: true
-  def blank?(_),  do: false
-end
-
-# Just the atoms false and nil are blank
-defimpl Blank, for: Atom do
-  def blank?(false), do: true
-  def blank?(nil),   do: true
-  def blank?(_),     do: false
-end
+```iex
+iex> 1 = x
+1
+iex> 2 = x
+** (MatchError) no match of right hand side value: 1
 ```
 
-And we would do so for all native data types. The types available are:
-
-* `Record`
-* `Tuple`
-* `Atom`
-* `List`
-* `BitString`
-* `Integer`
-* `Float`
-* `Function`
-* `PID`
-* `Port`
-* `Reference`
-* `Any`
-
-Now, with the protocol defined and implementations in hand, we can invoke it:
-
-```elixir
-Blank.blank?(0)       #=> false
-Blank.blank?([])      #=> true
-Blank.blank?([1,2,3]) #=> false
-```
+Notice that `1 = x` is a valid expression, and it matched because both the left and right side are equal to 1. When the sides do not match, a `MatchError` is raised.
 
-Notice however that passing a data type that does not implement the protocol raises an error:
+A variable can only be assigned on the left side of `=`:
 
 ```iex
-iex> Blank.blank?("hello")
-** (UndefinedFunctionError) undefined function: Blank.BitString.blank?/1
-```
+iex> 1 = unknown
+** (RuntimeError) undefined function: unknown/0
+````
 
-### 4.2.1 Fallback to any
+Since there is no variable `unknown` previously defined, Elixir imagined you were trying to call a function named `unknown/0`, but there isn't such function.
 
-In some cases, it may be convenient to provide a default implementation for all types. This can be achieved by setting `@fallback_to_any` to `true` in the protocol definition:
-
-```elixir
-defprotocol Blank do
-  @fallback_to_any true
-  def blank?(data)
-end
-```
+## 4.2 Pattern matching
 
-Which can now be implemented as:
+The match operator is not only used to match against simple values, but it is also useful for destructuring more complex data types. For example, we can pattern match on tuples:
 
-```elixir
-defimpl Blank, for: Any do
-  def blank?(_), do: false
-end
+```iex
+iex> {a, b, c} = {:hello, "world", 42}
+{:hello, "world", 42}
+iex> a
+:hello
+iex> b
+"world"
 ```
-Now all data types that we have not implemented the `Blank` protocol for will be considered non-blank.
-
-### 4.2.2 Using protocols with records
 
-The power of Elixir extensibility comes when protocols and records are mixed.
+A pattern match will error in case the sides can't match. This is, for example, the case when the tuples have different sizes:
 
-For instance, Elixir provides a `HashDict` implementation that is an efficient data structure to store many keys. Let's take a look at how it works:
-
-```elixir
-dict = HashDict.new
-dict = HashDict.put(dict, :hello, "world")
-HashDict.get(dict, :hello) #=> "world"
+```iex
+iex> {a, b, c} = {:hello, "world"}
+** (MatchError) no match of right hand side value: {:hello, "world"}
 ```
 
-If we inspect our `HashDict`, we can see it is a simple tuple:
+And also when comparing different types:
 
-```elixir
-inspect(dict, raw: true)
-#=> { HashDict, 1, [{:hello,"world"}] }
+```iex
+iex> {a, b, c} = [:hello, "world", "!"]
+** (MatchError) no match of right hand side value: [:hello, "world", "!"]
 ```
 
-Since `HashDict` is a data structure that contains values, it would be convenient to implement the `Blank` protocol for it too:
-
-```elixir
-defimpl Blank, for: HashDict do
-  def blank?(dict), do: HashDict.size(dict) == 0
-end
-```
+More interestingly, we can match on specific values. The example below asserts that the left side will only match the right side when the right side is a tuple that starts with the atom `:ok`:
 
-And now we can test it:
+```iex
+iex> {:ok, result} = {:ok, 13}
+{:ok, 13}
+iex> result
+13
 
-```elixir
-dict = HashDict.new(hello: "world")
-Blank.blank?(dict)         #=> false
-Blank.blank?(HashDict.new) #=> true
+iex> {:ok, result} = {:error, :oops}
+** (MatchError) no match of right hand side value: {:error, :oops}
 ```
 
-Excellent! The best of all is that we implemented the `Blank` protocol for an existing data structure (`HashDict`) without a need to wrap it or recompile it, which allows developers to easily extend previously defined protocols. Note this only worked because, when we defined the protocol, we have added `Record` to the list of types supported by the protocol:
+We can pattern match on lists:
 
-```elixir
-@only [Atom, Record, Tuple, List, BitString, Any]
+```iex
+iex> [a, b, c] = [1, 2, 3]
+[1, 2, 3]
+iex> a
+1
 ```
 
-Keep in mind that `Record` needs to come before `Tuple`, since all records are tuples (but not all tuples are records).  For this reason, in case a record does not implement a given protocol, Elixir will fall back to the tuple implementation of that protocol if one exists. So one can add a default protocol implementation for all records by simply defining a default implementation for tuples.
-
-### 4.2.3 Built-in protocols
-
-Elixir ships with some built-in protocols. Here are a couple of them:
-
-* `Access` - specifies how to access an element. This is the protocol that empowers bracket access in Elixir. For example:
+A list also supports matching on its own head and tail:
 
 ```iex
-iex> x = [a: 1, b: 2]
-[{:a, 1}, {:b, 2}]
-iex> x[:a]
+iex> [head | tail] = [1, 2, 3]
+[1, 2, 3]
+iex> head
 1
-iex> x[:b]
-2
+iex> tail
+[2, 3]
 ```
 
-* `Enumerable` - any data structures that can be enumerated must implement this protocol. This protocol is consumed by the `Enum` module which provides functions like `map`, `reduce` and others:
+Similar to the `hd/1` and `tl/1` functions, we can't match an empty list with a head and tail pattern:
 
 ```iex
-iex> Enum.map [1,2,3], fn(x) -> x * 2 end
-[2,4,6]
-iex> Enum.reduce 1..3, 0, fn(x, acc) -> x + acc end
-6
+iex> [h|t] = []
+** (MatchError) no match of right hand side value: []
 ```
 
-* `Binary.Inspect` - this protocol is used to transform any data structure into a readable textual representation. This is what tools like IEx use to print results:
+The `[head | tail]` format is not only used on pattern matching but also for prepending items to a list:
 
 ```iex
-iex> { 1, 2, 3 }
-{1,2,3}
-iex> HashDict.new
-#HashDict<[]>
+iex> list = [1, 2, 3]
+[1, 2, 3]
+iex> [0|list]
+[0, 1, 2, 3]
 ```
 
-  Keep in mind that whenever the inspected value starts with `#`, it is representing a data structure in non-valid Elixir syntax. For those, the true representation can be retrieved by calling `inspect` directly and passing `raw` as an option:
+Pattern matching allows developers to easily destructure data types such as tuples and lists. As we will see in following chapters, it is one of the foundations of recursion in Elixir and applies to other types as well, like maps and binaries.
 
-```iex
-iex> inspect HashDict.new, raw: true
-"{HashDict,0,[]}"
-```
+## 4.3 The pin operator
 
-* `String.Chars` - specifies how to convert a data structure with characters to a string. It's exposed via the `to_string` function:
+Variables in Elixir can be rebound:
 
 ```iex
-iex> to_string :hello
-"hello"
+iex> x = 1
+1
+iex> x = 2
+2
 ```
 
-  Notice that string interpolation in Elixir calls the `to_string` function:
+The pin operator `^` can be used when there is no interest in rebinding a variable but rather in matching against its value prior to the match:
 
 ```iex
-iex> "age: #{25}"
-"age: 25"
+iex> x = 1
+1
+iex> ^x = 2
+** (MatchError) no match of right hand side value: 2
+iex> {x, ^x} = {2, 1}
+{2, 1}
+iex> x
+2
 ```
 
-  The example above only works because numbers implement the `String.Chars` protocol. Passing a tuple, for example, will lead to an error:
+Notice that if a variable is mentioned more than once in a pattern, all references should bind to the same pattern:
 
 ```iex
-iex> tuple = {1, 2, 3}
-{1, 2, 3}
-iex> "tuple: #{tuple}"
-** (Protocol.UndefinedError) protocol String.Chars not implemented for {1, 2, 3}
+iex> {x, x} = {1, 1}
+1
+iex> {x, x} = {1, 2}
+** (MatchError) no match of right hand side value: {1, 2}
 ```
 
-  When there is a need to "print" a more complex data structure, one can simply use the `inspect` function:
+In some cases, you don't care about a particular value in a pattern. It is a common practice to bind those values to the underscore, `_`. For example, if only the head of the list matters to us, we can assign the tail to underscore:
 
 ```iex
-iex> "tuple: #{inspect tuple}"
-"tuple: {1, 2, 3}"
-```
-
-Elixir defines other protocols which can be verified in Elixir's documentation. Frameworks and libraries that you use may define a couple of specific protocols as well. Use them wisely to write code that is easy to maintain and extend.
-
-## 4.3 Exceptions
-
-Exception handling would have its own chapter in many languages, but here they play a much lesser role.
-
-An exception can be rescued inside a `try` block with the `rescue` keyword:
-
-```elixir
-# rescue only runtime error
-try do
-  raise "some error"
-rescue
-  RuntimeError -> "rescued"
-end
-
-# rescue runtime and argument errors
-try do
-  raise "some error"
-rescue
-  [RuntimeError, ArgumentError] -> "rescued"
-end
-
-# rescue and assign to x
-try do
-  raise "some error"
-rescue
-  x in [RuntimeError] ->
-    # all exceptions have a message
-    x.message
-end
+iex> [h | _] = [1, 2, 3]
+[1, 2, 3]
+iex> h
+1
 ```
 
-Notice that `rescue` works with exception names and doesn't allow guards nor pattern matching. This limitation is intentional: developers should not use exception values to drive their software. In fact, **exceptions in Elixir should only be used under exceptional circumstances**.
-
-For example, software that does log partitioning and rotation over the network may face network issues or an eventual instability when accessing the file system. These scenarios are not exceptional in this particular software and must be handled accordingly. Therefore, the software can read some file using `File.read` and match the result:
+The variable `_` is special in that it can never be read from. Trying to read from it gives an unbound variable error:
 
-```elixir
-case File.read(file) do
-  { :ok, contents }  ->
-    # We were able to access the file
-    # Proceed as expected
-  { :error, reason } ->
-    # Oops, something went wrong
-    # We need to handle the error accordingly
-end
+```iex
+iex> _
+** (CompileError) iex:1: unbound variable _
 ```
 
-Notice that `File.read` does not raise an exception in case something goes wrong; it returns a tuple containing `{ :ok, contents }` in case of success and `{ :error, reason }` in case of failure. This allows us to use Elixir's pattern matching constructs to control how our application should behave.
-
-On the other hand, a CLI interface that needs to access or manipulate a file given by the user may necessarily expect a file to be there. If the given file does not exist, there is nothing to do but fail. Then you may use `File.read!`, which raises an exception instead:
+Although pattern matching allows us to build powerful constructs, its usage is limited. For instance, you cannot make function calls on the left side of a match. The following example is invalid:
 
 ```iex
-iex> contents = File.read!("/inexistent/file")
-** (File.Error) could not read file /inexistent/file: no such file or directory
+iex> length([1,[2],3]) = 3
+** (ErlangError) erlang error :illegal_pattern
 ```
 
-This pattern is common throughout the Elixir standard library, and many libraries provide both forms.
-
-Finally, exceptions are simply records and can be defined with `defexception`, which has a similar API to `defrecord`. But remember, in Elixir you will use those sparingly.
-
-This showcases Elixir's philosophy of not using exceptions for control-flow. If you feel like you need to rescue an exception in order to change how your code works, you should probably return an atom or tuple instead to allow pattern matching.
-
-Next, let's take a look at how Elixir tackles productivity by building some macros using `defmacro` and `defmacrop`!
-
-> Note: In order to ease integration with Erlang APIs, Elixir also supports "catching errors" coming from Erlang with `try/catch`, as it works in Erlang:
->
->
->     try do
->       :erlang.error(:oops)
->     catch
->       :error, :oops ->
->         "Got Erlang error"
->     end
->
->
-> The first atom can be one of `:error`, `:throw` or `:exit`. Keep in mind that catching errors is as discouraged as rescuing exceptions in Elixir.
+This finishes our introduction to pattern matching. As we will see in the next chapter, pattern matching is very common in many language constructs.
diff --git a/getting_started/5.markdown b/getting_started/5.markdown
index b72deeba5..80d0744e0 100644
--- a/getting_started/5.markdown
+++ b/getting_started/5.markdown
@@ -1,300 +1,258 @@
 ---
 layout: getting_started
-title: 5 Macros
+title: 5 case, cond and if
 guide: 5
-total_guides: 7
 ---
 
 # {{ page.title }}
 
-An Elixir program can be represented by its own data structures. This chapter will describe what those structures look like and how to manipulate them to create your own macros.
+In this chapter, we will learn about the `case`, `cond` and `if` control-flow structures.
 
-## 5.1 Building blocks of an Elixir program
+## 5.1 case
 
-The building block of Elixir is a tuple with three elements. The function call `sum(1,2,3)` is represented in Elixir as:
-
-```elixir
-{ :sum, [], [1, 2, 3] }
-```
-
-You can get the representation of any expression by using the `quote` macro:
+`case` allows us to compare a value against many patterns until we find a matching one:
 
 ```iex
-iex> quote do: sum(1, 2, 3)
-{ :sum, [], [1, 2, 3] }
+iex> case {1, 2, 3} do
+...>   {4, 5, 6} ->
+...>     "This clause won't match"
+...>   {1, x, 3} ->
+...>     "This clause will match and bind x to 2 in this clause"
+...>   _ ->
+...>     "This clause would match any value"
+...> end
 ```
 
-Operators are also represented as such tuples:
+If you want to pattern match against an existing variable, you need to use the `^` operator:
 
 ```iex
-iex> quote do: 1 + 2
-{ :+, [], [1, 2] }
+iex> x = 1
+1
+iex> case 10 do
+...>   ^x -> "Won't match"
+...>   _  -> "Will match"
+...> end
 ```
 
-Even a tuple is represented as a call to `{}`:
+Clauses also allow extra conditions to be specified via guards:
 
 ```iex
-iex> quote do: { 1, 2, 3 }
-{ :{}, [], [1, 2, 3] }
+iex> case {1, 2, 3} do
+...>   {1, x, 3} when x > 0 ->
+...>     "Will match"
+...>   _ ->
+...>     "Won't match"
+...> end
 ```
 
-Variables are also represented using tuples, except the last element is an atom, instead of a list:
+The first clause above will only match when `x` is positive. The Erlang VM only allows a limited set of expressions in guards:
+
+* comparison operators (`==`, `!=`, `===`, `!==`, `>`, `<`, `<=`, `>=`)
+* boolean operators (`and`, `or`) and negation operators (`not`, `!`)
+* arithmetic operators (`+`, `-`, `*`, `/`)
+* `<>` and `++` as long as the left side is a literal
+* the `in` operator
+* all the following type check functions:
+
+    * `is_atom/1`
+    * `is_binary/1`
+    * `is_bitstring/1`
+    * `is_boolean/1`
+    * `is_float/1`
+    * `is_function/1`
+    * `is_function/2`
+    * `is_integer/1`
+    * `is_list/1`
+    * `is_map/1`
+    * `is_number/1`
+    * `is_pid/1`
+    * `is_port/1`
+    * `is_reference/1`
+    * `is_tuple/1`
+
+* plus these functions:
+
+    * `abs(number)`
+    * `bit_size(bitstring)`
+    * `byte_size(bitstring)`
+    * `div(integer, integer)`
+    * `elem(tuple, n)`
+    * `hd(list)`
+    * `length(list)`
+    * `map_size(map)`
+    * `node()`
+    * `node(pid | ref | port)`
+    * `rem(integer, integer)`
+    * `round(number)`
+    * `self()`
+    * `size(tuple | bitstring)`
+    * `tl(list)`
+    * `trunc(number)`
+    * `tuple_size(tuple)`
+
+Keep in mind errors in guards do not leak but simply make the guard fail:
 
 ```iex
-iex> quote do: x
-{ :x, [], Elixir }
+iex> hd(1)
+** (ArgumentError) argument error
+    :erlang.hd(1)
+iex> case 1 do
+...>   x when hd(x) -> "Won't match"
+...>   x -> "Got: #{x}"
+...> end
+"Got 1"
 ```
 
-When quoting more complex expressions, we can see the representation is composed of such tuples, which are nested on each other resembling a tree where each tuple is a node:
+If none of the clauses match, an error is raised:
 
 ```iex
-iex> quote do: sum(1, 2 + 3, 4)
-{ :sum, [], [1, { :+, [], [2, 3] }, 4] }
-```
-
-In general, each node (tuple) above follows the following format:
-
-```elixir
-{ tuple | atom, list, list | atom }
-```
-
-* The first element of the tuple is an atom or another tuple in the same representation;
-* The second element of the tuple is an list of metadata, it may hold information like the node line number;
-* The third element of the tuple is either a list of arguments for the function call or an atom. When an atom, it means the tuple represents a variable.
-
-Besides the node defined above, there are also five Elixir literals that when quoted return themselves (and not a tuple). They are:
-
-```elixir
-:sum         #=> Atoms
-1.0          #=> Numbers
-[1,2]        #=> Lists
-"binaries"   #=> Strings
-{key, value} #=> Tuples with two elements
-```
-
-With those basic structures in mind, we are ready to define our own macro.
-
-## 5.2 Defining our own macro
-
-A macro can be defined using `defmacro`. For instance, in just a few lines of code we can define a macro called `unless` which does the opposite of `if`:
-
-```elixir
-defmodule MyMacro do
-  defmacro unless(clause, options) do
-    quote do: if(!unquote(clause), unquote(options))
-  end
-end
+iex> case :ok do
+...>   :error -> "Won't match"
+...> end
+** (CaseClauseError) no case clause matching: :ok
 ```
 
-Similarly to `if`, `unless` expects two arguments: a `clause` and `options`:
+Note anonymous functions can also have multiple clauses and guards:
 
 ```elixir
-require MyMacro
-MyMacro.unless var, do: IO.puts "false"
+iex> f = fn
+...>   x, y when x > 0 -> x + y
+...>   x, y -> x * y
+...> end
+#Function<12.71889879/2 in :erl_eval.expr/5>
+iex> f.(1, 3)
+4
+iex> f.(-1, 3)
+-3
 ```
 
-However, since `unless` is a macro, its arguments are not evaluated when it's invoked but are instead passed literally. For example, if one calls:
+The number of arguments in each anonymous function clause needs to be the same, otherwise an error is raised.
 
-```elixir
-unless 2 + 2 == 5, do: call_function()
-```
+### 5.2 cond
 
-Our `unless` macro will receive the following:
+`case` is useful when you need to match against different values. However, in many circumstances, we want to check different conditions and find the first one that evaluates to true. In such cases, one may use `cond`:
 
-```elixir
-unless({:==, [], [{:+, [], [2, 2]}, 5]}, { :call_function, [], [] })
-```
-
-Then our `unless` macro will call `quote` to return a tree representation of the `if` clause. This means we are transforming our `unless` into an `if`!
-
-There is a common mistake when quoting expressions which is that developers usually forget to `unquote` the proper expression. In order to understand what `unquote` does, let's simply remove it:
-
-```elixir
-defmacro unless(clause, options) do
-  quote do: if(!clause, options)
-end
+```iex
+iex> cond do
+...>   2 + 2 == 5 ->
+...>     "This will not be true"
+...>   2 * 2 == 3 ->
+...>     "Nor this"
+...>   1 + 1 == 2 ->
+...>     "But this will"
+...> end
+"But this will"
 ```
 
-When called as `unless 2 + 2 == 5, do: call_function()`, our `unless` would then literally return:
+This is equivalent to `else if` clauses in many imperative languages (although used way less frequently here).
 
-```elixir
-if(!clause, options)
-```
+If none of the conditions return true, an error is raised. For this reason, it may be necessary to add a last condition equal to `true`, which will always match:
 
-Which would fail because the clause and options variables are not defined in the current scope. If we add `unquote` back:
-
-```elixir
-defmacro unless(clause, options) do
-  quote do: if(!unquote(clause), unquote(options))
-end
+```iex
+iex> cond do
+...>   2 + 2 == 5 ->
+...>     "This is never true"
+...>   2 * 2 == 3 ->
+...>     "Nor this"
+...>   true ->
+...>     "This is always true (equivalent to else)"
+...> end
 ```
 
-`unless` will then return:
+Finally, note `cond` considers any value besides `nil` and `false` to be true:
 
-```elixir
-if(!(2 + 2 == 5), do: call_function())
+```iex
+iex> cond do
+...>   hd([1,2,3]) ->
+...>     "1 is considered as true"
+...> end
+"1 is considered as true"
 ```
 
-In other words, `unquote` is a mechanism to inject expressions into the tree being quoted and it is an essential tool for meta-programming. Elixir also provides `unquote_splicing` allowing us to inject many expressions at once.
-
-We can define any macro we want, including ones that override the built-in macros provided by Elixir. For instance, you can redefine `case`, `receive`, `+`, etc. The only exceptions are Elixir special forms that cannot be overridden, [the full list of special forms is available in `Kernel.SpecialForms`](/docs/stable/Kernel.SpecialForms.html).
+### 5.3 if and unless
 
-## 5.3 Macros hygiene
+Besides `case` and `cond`, Elixir also provides the macros `if/2` and `unless/2` which are useful when you need to check for just one condition:
 
-Elixir macros have late resolution. This guarantees that a variable defined inside a quote won't conflict with a variable defined in the context where that macro is expanded. For example:
-
-```elixir
-defmodule Hygiene do
-  defmacro no_interference do
-    quote do: a = 1
-  end
-end
-
-defmodule HygieneTest do
-  def go do
-    require Hygiene
-    a = 13
-    Hygiene.no_interference
-    a
-  end
-end
-
-HygieneTest.go
-# => 13
-```
-
-In the example above, even if the macro injects `a = 1`, it does not affect the variable `a` defined by the `go` function. In case the macro wants to explicitly affect the context, it can use `var!`:
-
-```elixir
-defmodule Hygiene do
-  defmacro interference do
-    quote do: var!(a) = 1
-  end
-end
-
-defmodule HygieneTest do
-  def go do
-    require Hygiene
-    a = 13
-    Hygiene.interference
-    a
-  end
-end
-
-HygieneTest.go
-# => 1
+```iex
+iex> if true do
+...>   "This works!"
+...> end
+"This works!"
+iex> unless true do
+...>   "This will never be seen"
+...> end
+nil
 ```
 
-Variables hygiene only works because Elixir annotates variables with their context. For example, a variable `x` defined at the line 3 of a module, would be represented as:
-
-    { :x, [line: 3], nil }
-
-However, a quoted variable is represented as:
+If the condition given to `if/2` returns `false` or `nil`, the body given between `do/end` is not executed and it simply returns `nil`. The opposite happens with `unless/2`.
 
-```elixir
-defmodule Sample do
-  def quoted do
-    quote do: x
-  end
-end
+They also support `else` blocks:
 
-Sample.quoted #=> { :x, [line: 3], Sample }
+```iex
+iex> if nil do
+...>   "This won't be seen"
+...> else
+...>   "This will"
+...> end
+"This will"
 ```
 
-Notice that the third element in the quoted variable is the atom `Sample`, instead of `nil`, which marks the variable as coming from the `Sample` module. Therefore, Elixir considers those two variables come from different contexts and handle them accordingly.
-
-Elixir provides similar mechanisms for imports and aliases too. This guarantees macros will behave as specified by its source module rather than conflicting with the target module.
+> Note: An interesting note regarding `if/2` and `unless/2` is that they are implemented as macros in the language; they are special language constructs as they would be in many languages. You can check the documentation and the source of `if/2` in [the `Kernel` module docs](/docs/stable/Kernel.html). The `Kernel` module is also where operators like `+/2` and functions like `is_function/2` are defined, all automatically imported and available in your code by default.
 
-## 5.4 Private macros
+### 5.4 `do` blocks
 
-Elixir also supports private macros via `defmacrop`. As private functions, these macros are only available inside the module that defines them, and only at compilation time. A common use case for private macros is to define guards that are frequently used in the same module:
+At this point, we have learned four control structures: `case`, `cond`, `if` and `unless`, and they were all wrapped in `do`/`end` blocks. It happens we could also write `if` as follows:
 
-```elixir
-defmodule MyMacros do
-  defmacrop is_even?(x) do
-    quote do
-      rem(unquote(x), 2) == 0
-    end
-  end
-
-  def add_even(a, b) when is_even?(a) and is_even?(b) do
-    a + b
-  end
-end
+```iex
+iex> if true, do: 1 + 2
+3
 ```
 
-It is important that the macro is defined before its usage. Failing to define a macro before its invocation will raise an error at runtime, since the macro won't be expanded and will be translated to a function call:
+In Elixir, `do`/`end` blocks are a convenience for passing a group of expressions to `do:`. These are equivalent:
 
-```elixir
-defmodule MyMacros do
-  def four, do: two + two
-  defmacrop two, do: 2
-end
-
-MyMacros.four #=> ** (UndefinedFunctionError) undefined function: two/0
+```iex
+iex> if true do
+...>   a = 1 + 2
+...>   a + 10
+...> end
+13
+iex> if true, do: (
+...>   a = 1 + 2
+...>   a + 10
+...> )
+13
 ```
 
-## 5.5 Code execution
-
-To finish our discussion about macros, we are going to briefly discuss how code execution works in Elixir. Code execution in Elixir is done in two steps:
+We say the second syntax is using **keyword lists**. We can pass `else` using this syntax:
 
-1) All the macros in the code are expanded recursively;
-
-2) The expanded code is compiled to Erlang bytecode and executed
-
-This behavior is important to understand because it affects how we think about our code structure. Consider the following code:
-
-```elixir
-defmodule Sample do
-  case System.get_env("FULL") do
-    "true" ->
-      def full?(), do: true
-    _ ->
-      def full?(), do: false
-  end
-end
+```iex
+iex> if false, do: :this, else: :that
+:that
 ```
 
-The code above will define a function `full?` which will return true or false depending on the value of the environment variable `FULL` at **compilation time**. In order to execute this code, Elixir will first expand all macros. Considering that `defmodule` and `def` are macros, the code will expand to something like:
+It is important to keep one small detail in mind when using `do`/`end` blocks: they always bind to the farthest function call. For example, the following expression:
 
-```elixir
-:elixir_module.store Sample, fn ->
-  case System.get_env("FULL") do
-    "true" ->
-      :elixir_def.store(Foo, :def, :full?, [], true)
-    _ ->
-      :elixir_def.store(Foo, :def, :full?, [], false)
-end
+```iex
+iex> is_number if true do
+...>  1 + 2
+...> end
 ```
 
-This code will then be executed, define a module `Foo` and store the appropriate function based on the value of the environment variable `FULL`. We achieve this by using the modules `:elixir_module` and `:elixir_def`, which are Elixir internal modules written in Erlang.
-
-There are two lessons to take away from this example:
-
-1) a macro is always expanded, regardless if it is inside a `case` branch that won't actually match when executed;
+Would be parsed as:
 
-2) we cannot invoke a function or macro just after it is defined in a module. For example, consider:
-
-```elixir
-defmodule Sample do
-  def full?, do: true
-  IO.puts full?
-end
+```iex
+iex> is_number(if true) do
+...>  1 + 2
+...> end
 ```
 
-  The example above will fail because it translates to:
+Which leads to an undefined function error as Elixir attempts to invoke `is_number/2`. Adding explicit parentheses is enough to resolve the ambiguity:
 
-```elixir
-:elixir_module.store Sample, fn ->
-  :elixir_def.store(Foo, :def, :full?, [], true)
-  IO.puts full?
-end
+```iex
+iex> is_number(if true do
+...>  1 + 2
+...> end)
+true
 ```
 
-At the moment the module is being defined, there isn't **yet** a function named `full?` defined in the module, so `IO.puts full?` will cause the compilation to fail.
-
-## 5.6 Don't write macros
-
-Although macros are a powerful construct, the first rule of the macro club is **don't write macros**. Macros are harder to write than ordinary Elixir functions, and it's considered to be bad style to use them when they're not necessary. Elixir already provides elegant mechanisms to write your every day code and macros should be saved as last resort.
-
-With those lessons, we finish our introduction to macros. Next, let's move to the next chapter which will discuss several topics such as documentation, partial application and others.
+Keyword lists play an important role in the language and are quite common in many functions and macros. We will explore them a bit more in a future chapter. Now it is time to talk about "Binaries, strings and char lists".
diff --git a/getting_started/6.markdown b/getting_started/6.markdown
index 6f047f4f2..b46790134 100644
--- a/getting_started/6.markdown
+++ b/getting_started/6.markdown
@@ -1,293 +1,184 @@
 ---
 layout: getting_started
-title: 6 Other topics
+title: 6 Binaries, strings and char lists
 guide: 6
-total_guides: 7
 ---
 
 # {{ page.title }}
 
-This chapter contains different small topics that are part of Elixir's day to day work. We will learn about writing documentation, list and binary comprehensions, partial function application and more!
-
-## 6.1 String sigils
-
-Elixir provides string sigils via the token `%`:
-
-```elixir
-%s(String with escape codes \x26 interpolation)
-%S(String without escape codes and without #{interpolation})
-```
-
-Sigils starting with an uppercase letter never escape characters or do interpolation. Notice the separators are not necessarily parenthesis, but any non-alphanumeric character:
-
-```elixir
-%s-another string-
-```
-
-Internally, `%s` is translated as a call to `sigil_s`. For instance, the docs for `%s` are available in the macro [`sigil_s/2`](/docs/stable/Kernel.html#sigil_s/2) defined in `Kernel` module.
-
-The sigils defined in Elixir by default are:
-
-* `%c` and `%C` - Returns a char list;
-* `%r` and `%R` - Returns a regular expression;
-* `%s` and `%S` - Returns a string;
-* `%w` and `%W` - Returns a list of "words" split by whitespace;
-
-## 6.2 Heredocs
-
-Elixir supports heredocs as a way to define long strings. Heredocs are delimited by triple double-quotes for string or triple single-quotes for char lists:
-
-```elixir
-"""
-String heredoc
-"""
-
-'''
-Charlist heredoc
-'''
-```
-
-The heredoc ending must be in a line on its own, otherwise it is part of the heredoc:
-
-```elixir
-"""
-String heredocs in Elixir use """
-"""
-```
-
-Notice the sigils discussed in the previous section are also available as heredocs:
-
-```elixir
-%S"""
-A heredoc without escaping or interpolation
-"""
-```
-
-## 6.3 Documentation
-
-Elixir uses module attributes described in chapter 3 to drive its documentation system. For instance, consider the following example:
-
-```elixir
-defmodule MyModule do
-  @moduledoc "it does x"
-
-  @doc "returns the version"
-  def version, do: 1
-end
-```
-
-In the example above, we are adding a module documentation to `MyModule` via `@moduledoc` and using `@doc` to document each function. When compiled, we are able to inspect the documentation attributes at runtime (remember to start iex in the same directory in which you compiled the module):
-
-    $ elixirc my_module.ex
-    $ iex
+In "Basic Types", we learned about strings and used the `is_binary/1` function for checks:
 
 ```iex
-iex> MyModule.__info__(:docs)
-[{ { :version, 0 }, 5, :def, [], "Returns the version" }]
-iex> MyModule.__info__(:moduledoc)
-{1,"It does X"}
+iex> string = "hello"
+"hello"
+iex> is_binary string
+true
 ```
 
-`__info__(:docs)` returns a list of tuples where each tuple contains a function/arity pair, the line the function was defined on, the kind of the function (either `def` or `defmacro`, private functions defined with `defp` or `defmacrop` cannot be documented), the function arguments and its documentation. The comment will be either a binary or `nil` (not given) or `false` (explicit no doc).
+In this chapter, we will understand what binaries are, how they associate with strings, and what a single-quoted value, `'like this'`, means in Elixir.
 
-Similarly, `__info__(:moduledoc)` returns a tuple with the line the module was defined on and its documentation.
+## 6.1 UTF-8 and Unicode
 
-Elixir promotes the use of markdown with heredocs to write readable documentation:
+A string is a UTF-8 encoded binary. In order to understand exactly what we mean by that, we need to understand the difference between bytes and codepoints.
 
-```elixir
-defmodule Math do
-  @moduledoc """
-  This module provides mathematical functions
-  as sin, cos and constants like pi.
+The Unicode standard assigns codepoints to many of the characters we know. For example, the letter `a` has codepoint `97` while the letter `ł` has codepoint `322`. When writing the string `"hełło"` to disk, we need to convert this codepoint to bytes. If we adopted a rule that said one byte represents one codepoint, we wouldn't be able to write `"hełło"`, because it uses the codepoint `322` for `ł`, and one byte can only represent a number from `0` to `255`. But of course, given you can actually read `"hełło"` on your screen, it must be represented *somehow*. That's where encodings come in.
 
-  ## Examples
+When representing codepoints in bytes, we need to encode them somehow. Elixir chose the UTF-8 encoding as its main and default encoding. When we say a string is a UTF-8 encoded binary, we mean a string is a bunch of bytes organized in a way to represent certain codepoints, as specified by the UTF-8 encoding.
 
-      Math.pi
-      #=> 3.1415...
-
-  """
-end
-```
-
-## 6.4 IEx Helpers
-
-Elixir's interactive console (IEx) ships with many functions to make the developer's life easier. One of these functions is called `h`, which shows documentation directly at the command line:
+Since we have codepoints like `ł` assigned with the number `322`, we actually need more than one byte to represent it. That's why we see a difference when we calculate the `byte_size/1` of a string compared to its `String.length/1`:
 
 ```iex
-iex> h()
-# IEx.Helpers
-...
-:ok
+iex> string = "hełło"
+"hełło"
+iex> byte_size string
+7
+iex> String.length string
+5
 ```
 
-As you can see, invoking `h()` prints the documentation of `IEx.Helpers`. From there, we can navigate to any of the other helpers by giving its name and arity to get more information:
+UTF-8 requires one byte to represent the codepoints `h`, `e` and `o`, but two bytes to represent `ł`. In Elixir, you can get a codepoint's value by using `?`:
 
 ```iex
-iex> h(c/2)
-* def c(files, path // ".")
-...
-:ok
+iex> ?a
+97
+iex> ?ł
+322
 ```
 
-This functionality can also be used to print the documentation for any Elixir module in the system:
+You can also use the functions in [the `String` module](/docs/stable/String.html) to split a string in its codepoints:
 
 ```iex
-iex> h(Enum)
-...
-iex> h(Enum.each/2)
-...
+iex> String.codepoints("hełło")
+["h", "e", "ł", "ł", "o"]
 ```
 
-The documentation for built-in functions can also be accessed directly or indirectly from the `Kernel` module:
+You will see that Elixir has excellent support for working with strings. It also supports many of the Unicode operations. In fact, Elixir passes all the tests showcased in the ["The string type is broken"](http://mortoray.com/2013/11/27/the-string-type-is-broken/) article.
 
-```iex
-iex> h(is_atom/1)
-...
-iex> h(Kernel.is_atom/1)
-...
-```
+However, strings are just part of the story. If a string is a binary, and we have used the `is_binary/1` function, Elixir must have an underlying type empowering strings. And it does. Let's talk about binaries!
 
-## 6.5 Function capture
+## 6.2 Binaries (and bitstrings)
 
-Functions in Elixir are identified by their name and arity (the number of arguments it expects). Since passing functions around is a common practice in Elixir, Elixir provides the capture operator `&` as a convenience. Consider this example:
+In Elixir, you can define a binary using `<<>>`:
 
 ```iex
-iex> list = ["foo", "bar", "baz"]
-["foo","bar","baz"]
-iex> Enum.map list, fn(x) -> size(x) end
-[3,3,3]
+iex> <<0, 1, 2, 3>>
+<<0, 1, 2, 3>>
+iex> byte_size <<0, 1, 2, 3>>
+4
 ```
 
-We could write the second line using the capture operator as:
+A binary is just a sequence of bytes. Of course, those bytes can be organized in any way, even in a sequence that does not make them a valid string:
 
 ```iex
-iex> Enum.map list, &size/1
-[3,3,3]
+iex> String.valid?(<<239, 191, 191>>)
+false
 ```
 
-The capture operator retrieves the function size with arity 1 as an anonymous function and passes it down to `Enum.map/2`. Remote calls can also be captured:
+The string concatenation operation is actually a binary concatenation operator:
 
 ```iex
-iex> fun = &Kernel.size/1
-&Kernel.size/1
-iex> fun.("hello")
-5
+iex> <<0, 1>> <> <<2, 3>>
+<<0, 1, 2, 3>>
 ```
 
-A capture also allows the captured functions to be partially applied, for example:
+A common trick in Elixir is to concatenate the null byte `<<0>>` to a string to see its inner binary representation:
 
 ```iex
-iex> fun = &atom_to_binary(&1, :utf8)
-#Function<6.17052888 in :erl_eval.expr/5>
-iex> fun.(:hello)
-"hello"
+iex> "hełło" <> <<0>>
+<<104, 101, 197, 130, 197, 130, 111, 0>>
 ```
 
-In the example above, we use `&1` as a placeholder, generating a function with one argument. The capture above is equivalent to `fn(x) -> atom_to_binary(x, :utf8) end`.
-
-Since operators are treated as regular function calls in Elixir, they are also supported, although they require explicit parentheses:
+Each number given to a binary is meant to represent a byte and therefore must go up to 255. Binaries allow modifiers to be given to store numbers bigger than 255 or to convert a codepoint to its utf8 representation:
 
 ```iex
-iex> fun = &(&1 + &2)
-iex> fun.(1, 2)
-3
+iex> <<255>>
+<<255>>
+iex> <<256>> # truncated
+<<0>>
+iex> <<256 :: size(16)>> # use 16 bits (2 bytes) to store the number
+<<1, 0>>
+iex> <<256 :: utf8>> # the number is a codepoint
+"Ā"
+iex> <<256 :: utf8, 0>>
+<<196, 128, 0>>
 ```
 
-The capture operator is a handy way of capturing functions and passing them around as anonymous functions. To learn more, [read the documentation](http://elixir-lang.org/docs/stable/Kernel.SpecialForms.html#&/1).
-
-## 6.6 Use
-
-`use` is a macro that provides a common API for extension. For instance, in order to use the `ExUnit` test framework that ships with Elixir, you simply need to use `ExUnit.Case` in your module:
-
-```elixir
-defmodule AssertionTest do
-  use ExUnit.Case, async: true
-
-  test "always pass" do
-    true = true
-  end
-end
-```
+If a byte has 8 bits, what happens if we pass a size of 1 bit?
 
-This allows `ExUnit.Case` to configure and set up the module for testing, for example, by making the `test` macro used above available.
-
-The implementation of the `use` macro is actually quite trivial. When you invoke `use` with a module, it invokes a hook called `__using__` in this module. For example, the `use` call above is simply a translation to:
-
-```elixir
-defmodule AssertionTest do
-  require ExUnit.Case
-  ExUnit.Case.__using__(async: true)
-
-  test "always pass" do
-    true = true
-  end
-end
+```iex
+iex> <<1 :: size(1)>>
+<<1 :: size(1)>>
+iex> <<2 :: size(1)>> # truncated
+<<0>>
+iex> is_binary(<< 1 :: size(1)>>)
+false
+iex> is_bitstring(<< 1 :: size(1)>>)
+true
+iex> bit_size(<< 1 :: size(1)>>)
+1
 ```
 
-In general, we recommend APIs to provide a `__using__` hook in case they want to expose functionality to developers.
+The value is no longer a binary, but a bitstring -- just a bunch of bits! So a binary is a bitstring where the number of bits is divisible by 8!
 
-## 6.7 Comprehensions
-
-Elixir also provides list and bit comprehensions. List comprehensions allow you to quickly build a list from another list:
+We can also pattern match on binaries / bitstrings:
 
 ```iex
-iex> lc n inlist [1,2,3,4], do: n * 2
-[2,4,6,8]
+iex> <<0, 1, x>> = <<0, 1, 2>>
+<<0, 1, 2>>
+iex> x
+2
+iex> <<0, 1, x>> = <<0, 1, 2, 3>>
+** (MatchError) no match of right hand side value: <<0, 1, 2, 3>>
 ```
 
-Or, using keywords blocks:
+Note each entry in the binary is expected to match exactly 8 bits. However, we can match on the rest of the binary modifier:
 
-```elixir
-lc n inlist [1,2,3,4] do
-  n * 2
-end
+```iex
+iex> <<0, 1, x :: binary>> = <<0, 1, 2, 3>>
+<<0, 1, 2, 3>>
+iex> x
+<<2, 3>>
 ```
 
-A comprehension accepts many generators (given by `inlist` or `inbits` operators) as well as filters:
+The pattern above only works if the binary is at the end of `<<>>`. Similar results can be retrieved with the string concatenation operator `<>`:
 
 ```iex
-# A comprehension with a generator and a filter
-iex> lc n inlist [1,2,3,4,5,6], rem(n, 2) == 0, do: n
-[2,4,6]
-
-# A comprehension with two generators
-iex> lc x inlist [1,2], y inlist [2,3], do: x*y
-[2,3,4,6]
+iex> "he" <> rest = "hello"
+"hello"
+iex> rest
+"llo"
 ```
 
-Elixir provides generators for both lists and bitstrings:
-
-```iex
-# A list generator:
-iex> lc n inlist [1,2,3,4], do: n * 2
-[2,4,6,8]
+This finishes our tour of bitstrings, binaries and strings. A string is a UTF-8 encoded binary, and a binary is a bitstring where the number of bits is divisible by 8. Although this shows the flexibility Elixir provides to work with bits and bytes, 99% of the time you will be working with binaries and using the `is_binary/1` and `byte_size/1` functions.
 
-# A bit string generator:
-iex> lc <<n>> inbits <<1,2,3,4>>, do: n * 2
-[2,4,6,8]
-```
+## 6.3 Char lists
 
-Bit string generators are quite useful when you need to organize streams:
+A char list is nothing more than a list of characters:
 
 ```iex
-iex> pixels = <<213,45,132,64,76,32,76,0,0,234,32,15>>
-iex> lc <<r :: size(8), g :: size(8), b :: size(8)>> inbits pixels, do: {r,g,b}
-[{213,45,132},{64,76,32},{76,0,0},{234,32,15}]
+iex> 'hełło'
+[104, 101, 322, 322, 111]
+iex> is_list 'hełło'
+true
+iex> 'hello'
+'hello'
 ```
 
-Remember, as strings are binaries and a binary is a bitstring, we can also use strings in comprehensions. For instance, the example below removes all white space characters from a string via bit comprehensions:
+You can see that, instead of containing bytes, a char list contains the codepoints of the characters in between single-quotes (note that iex will only output codepoints if any of the chars is outside the ASCII range). So while double-quotes represent a string (i.e. a binary), single-quotes represents a char list (i.e. a list).
+
+In practice, char lists are used mostly when interfacing with Erlang, in particular old libraries that do not accept binaries as arguments. You can convert a char list to a string and back by using the `to_string/1` and `to_char_list/1` functions:
 
 ```iex
-iex> bc <<c>> inbits " hello world ", c != ?\s, do: <<c>>
-"helloworld"
+iex> to_char_list "hełło"
+[104, 101, 322, 322, 111]
+iex> to_string 'hełło'
+"hełło"
+iex> to_string :hello
+"hello"
+iex> to_string 1
+"1"
 ```
 
-## 6.8 Pseudo variables
-
-Elixir provides a set of pseudo-variables. These variables can only be read and never assigned to. They are:
+Note that those functions are polymorphic. They not only convert char lists to strings, but also integers to strings, atoms to strings, and so on.
 
-* `__MODULE__` - Returns an atom representing the current module or nil;
-* `__FILE__` - Returns a string representing the current file;
-* `__DIR__` - Returns a string representing the current directory;
-* `__ENV__` - Returns a [Macro.Env](/docs/stable/Macro.Env.html) record with information about the compilation environment. Here we can access the current module, function, line, file and others;
-* `__CALLER__` - Also returns a [Macro.Env](/docs/stable/Macro.Env.html) record but with information of the calling site. `__CALLER__` is available only inside macros;
+With binaries, strings, and char lists out of the way, it is time to talk about key-value data structures.
diff --git a/getting_started/7.markdown b/getting_started/7.markdown
index 8e4ba83b1..3161e06e1 100644
--- a/getting_started/7.markdown
+++ b/getting_started/7.markdown
@@ -1,51 +1,184 @@
 ---
 layout: getting_started
-title: 7 Where To Go Next
+title: 7 Keywords, maps and dicts
 guide: 7
-total_guides: 7
 ---
 
 # {{ page.title }}
 
-## 7.1 Applications
+So far we haven't discussed any associative data structures, i.e. data structures that are able to associate a certain value (or multiple values) to a key. Different languages call these different names like dictionaries, hashes, associative arrays, maps, etc.
 
-In order to get your first project started, Elixir ships with a build tool called [`Mix`](/getting_started/mix/1.html). You can get your new project started by simply running:
+In Elixir, we have two main associative data structures: keyword lists and maps. It's time to learn more about them!
 
-    mix new path/to/new/project
+## 7.1 Keyword lists
 
-You can learn more about Elixir and other applications in the links below:
+In many functional programming languages, it is common to use a list of 2-item tuples as the representation of an associative data structure. In Elixir, when we have a list of tuples and the first item of the tuple (i.e. the key) is an atom, we call it a keyword list:
 
-* [Mix - a build tool for Elixir](/getting_started/mix/1.html)
-* [ExUnit - a unit test framework](/getting_started/ex_unit/1.html)
+```iex
+iex> list = [{:a, 1}, {:b, 2}]
+[a: 1, b: 2]
+iex> list == [a: 1, b: 2]
+true
+iex> list[:a]
+1
+```
 
-## 7.2 A Byte of Erlang
+As you can see above, Elixir supports a special syntax for defining such lists, and underneath they just map to a list of tuples. Since they are simply lists, all operations available to lists, including their performance characteristics, also apply to keyword lists.
 
-As the main page of this site puts it:
+For example, we can use `++` to add new values to a keyword list:
 
-> Elixir is a programming language built on top of the Erlang VM.
+```iex
+iex> list ++ [c: 3]
+[a: 1, b: 2, c: 3]
+iex> [a: 0] ++ list
+[a: 0, a: 1, b: 2]
+```
 
-Sooner than later, an Elixir developer will want to interface with existing Erlang libraries. Here's a list of online resources that cover Erlang's fundamentals and its more advanced features:
+Note that values added to the front are the ones fetched on lookup:
 
-* This [Erlang Syntax: A Crash Course][1] provides a concise intro to Erlang's syntax. Each code snippet is accompanied by equivalent code in Elixir. This is an opportunity for you to not only get some exposure to the Erlang's syntax but also review some of the things you have learned in the present guide.
+```iex
+iex> new_list = [a: 0] ++ list
+[a: 0, a: 1, b: 2]
+iex> new_list[:a]
+0
+```
 
-* Erlang's official website has a short [tutorial][2] with pictures that briefly describe Erlang's primitives for concurrent programming.
+Keyword lists are important because they have two special characteristics:
 
-* [Learn You Some Erlang for Great Good!][4] is an excellent introduction to Erlang, its design principles, standard library, best practices and much more. If you are serious about Elixir, you'll want to get a solid understanding of Erlang principles. Once you have read through the crash course mentioned above, you'll be able to safely skip the first couple of chapters in the book that mostly deal with the syntax. When you reach [The Hitchhiker's Guide to Concurrency][5] chapter, that's where the real fun starts.
+* They keep the keys ordered as given by the developer.
+* They allow a key to be given more than once.
 
-## 7.3 Reference Manual
+For example, [the Ecto library](https://github.com/elixir-lang/ecto) makes use of both features to provide an elegant DSL for writing database queries:
 
-[You can also check the source code of Elixir itself][3], which is mainly written in Elixir (mainly the `lib` directory), or [explore Elixir's documentation][7].
+```elixir
+query = from w in Weather,
+      where: w.prcp > 0,
+      where: w.temp < 20,
+     select: w
+```
 
-## 7.4 Join The Community
+Those features are what prompted keyword lists to be the default mechanism for passing options to functions in Elixir. In chapter 5, when we discussed the `if/2` macro, we mentioned the following syntax is supported:
 
-Remember that in case of any difficulties, you can always visit the **#elixir-lang** channel on **irc.freenode.net** or send a message to the [mailing list][6]. You can be sure that there will be someone willing to help. And to keep posted on the latest news and announcements, follow the [blog][9] and join [elixir-core mailing list][8].
+```iex
+iex> if false, do: :this, else: :that
+:that
+```
 
-  [1]: http://elixir-lang.org/crash-course.html
-  [2]: http://www.erlang.org/course/concurrent_programming.html
-  [3]: https://github.com/elixir-lang/elixir
-  [4]: http://learnyousomeerlang.com/
-  [5]: http://learnyousomeerlang.com/the-hitchhikers-guide-to-concurrency
-  [6]: http://groups.google.com/group/elixir-lang-talk
-  [7]: http://elixir-lang.org/docs.html
-  [8]: http://groups.google.com/group/elixir-lang-core
-  [9]: http://elixir-lang.org/blog/
+The `do:` and `else:` pairs are keyword lists! In fact, the call above is equivalent to:
+
+```iex
+iex> if(false, [do: :this, else: :that])
+:that
+```
+
+In general, when the keyword list is the last argument of a function, the square brackets are optional.
+
+In order to manipulate keyword lists, Elixir provides [the `Keyword` module](/docs/stable/Keyword.html). Remember though keyword lists are simply lists, and as such they provide the same linear performance characteristics as lists. The longer the list, the longer it will take to find a key, to count the number of items, and so on. For this reason, keyword lists are used in Elixir mainly as options. If you need to store many items or guarantee one-key associates with at maximum one-value, you should use maps instead.
+
+Note we can also pattern match on keyword lists:
+
+```iex
+iex> [a: a] = [a: 1]
+[a: 1]
+iex> a
+1
+iex> [a: a] = [a: 1, b: 2]
+** (MatchError) no match of right hand side value: [a: 1, b: 2]
+iex> [b: b, a: a] = [a: 1, b: 2]
+** (MatchError) no match of right hand side value: [a: 1, b: 2]
+```
+
+However this is rarely done in practice since pattern matching on lists require the number of items and their order to match.
+
+## 7.2 Maps
+
+Whenever you need a key-value store, maps are the "go to" data structure in Elixir. A map is created using the `%{}` syntax:
+
+```iex
+iex> map = %{:a => 1, 2 => :b}
+%{2 => :b, :a => 1}
+iex> map[:a]
+1
+iex> map[2]
+:b
+```
+
+Compared to keyword lists, we can already see two differences:
+
+* Maps allow any value as key.
+* Maps' keys do not follow any ordering.
+
+If you pass duplicate keys when creating a map, the last one wins:
+
+```iex
+iex> %{1 => 1, 1 => 2}
+%{1 => 2}
+```
+
+When all the keys in a map are atoms, you can use the keyword syntax for convenience:
+
+```iex
+iex> map = %{a: 1, b: 2}
+%{a: 1, b: 2}
+```
+
+In contrast to keyword lists, maps are very useful with pattern matching:
+
+```iex
+iex> %{} = %{:a => 1, 2 => :b}
+%{:a => 1, 2 => :b}
+iex> %{:a => a} = %{:a => 1, 2 => :b}
+%{:a => 1, 2 => :b}
+iex> a
+1
+iex> %{:c => c} = %{:a => 1, 2 => :b}
+** (MatchError) no match of right hand side value: %{2 => :b, :a => 1}
+```
+
+As shown above, a map matches as long as the given keys exist in the given map. Therefore, an empty map matches all maps.
+
+One interesting property about maps is that they provide a particular syntax for updating and accessing atom keys:
+
+```iex
+iex> map = %{:a => 1, 2 => :b}
+%{:a => 1, 2 => :b}
+iex> map.a
+1
+iex> %{map | :a => 2}
+%{:a => 2, 2 => :b}
+iex> %{map | :c => 3}
+** (ArgumentError) argument error
+```
+
+Both access and update syntaxes above require the given keys to exist. For example, the last line failed because there is no `:c` in the map. This is very useful when you are working with maps where you only expect certain keys to exist.
+
+In future chapters, we will also learn about structs, which provide compile-time guarantees and the foundation for polymorphism in Elixir. Structs are built on top of maps where the update guarantees above are proven to be quite useful.
+
+Manipulating maps is done via [the `Map` module](/docs/stable/Map.html), it provides a very similar API to the `Keyword` module. This is because both modules implement the `Dict` behaviour.
+
+> Note: Maps were recently introduced into the Erlang VM with [EEP 43](http://www.erlang.org/eeps/eep-0043.html). Erlang 17 provides a partial implementation of the EEP, where only "small maps" are supported. This means maps have good performance characteristics only when storing at maximum a couple of dozens keys. To fill in this gap, Elixir also provides [the `HashDict` module](/docs/stable/HashDict.html) which uses a hashing algorithm to provide a dictionary that supports hundreds of thousands keys with good performance.
+
+## 7.3 Dicts
+
+In Elixir, both keyword lists and maps are called dictionaries. In other words, a dictionary is like an interface (we call them behaviours in Elixir) and both keyword lists and maps modules implement this interface.
+
+This interface is defined in the [the `Dict` module](/docs/stable/Dict.html) module which also provides an API that delegates to the underlying implementations:
+
+```iex
+iex> keyword = []
+[]
+iex> map = %{}
+%{}
+iex> Dict.put(keyword, :a, 1)
+[a: 1]
+iex> Dict.put(map, :a, 1)
+%{a: 1}
+```
+
+The `Dict` module allows any developer to implement their own variation of `Dict`, with specific characteristics, and hook into existing Elixir code. The `Dict` module also provides functions that are meant to work across dictionaries. For example, `Dict.equal?/2` can compare two dictionaries of any kind.
+
+That said, you may be wondering, which of `Keyword`, `Map` or `Dict` modules should you use in your code? The answer is: it depends.
+
+If your code is expecting a keyword as an argument, explicitly use the `Keyword` module. If you want to manipulate a map, use the `Map` module. However, if your API is meant to work with any dictionary, use the `Dict` module (and make sure to write tests that pass different dict implementations as arguments).
+
+This concludes our introduction to associative data structures in Elixir. You will find out that given keyword lists and maps, you will always have the right tool to tackle problems that require associative data structures in Elixir.
diff --git a/getting_started/8.markdown b/getting_started/8.markdown
new file mode 100644
index 000000000..1de2a519d
--- /dev/null
+++ b/getting_started/8.markdown
@@ -0,0 +1,249 @@
+---
+layout: getting_started
+title: 8 Modules
+guide: 8
+---
+
+# {{ page.title }}
+
+In Elixir we group several functions into modules. We've already used many different modules in the previous chapters like [the `String` module](/docs/stable/String.html):
+
+```iex
+iex> String.length "hello"
+5
+```
+
+In order to create our own modules in Elixir, we use the `defmodule` macro. We use the `def` macro to define functions in that module:
+
+```iex
+iex> defmodule Math do
+...>   def sum(a, b) do
+...>     a + b
+...>   end
+...> end
+
+iex> Math.sum(1, 2)
+3
+```
+
+In the following sections, our examples are going to get a bit more complex, and it can be tricky to type them all in the shell. It's about time for us to learn how to compile Elixir code and also how to run Elixir scripts.
+
+## 8.1 Compilation
+
+Most of the time it is convenient to write modules into files so they can be compiled and reused. Let's assume we have a file named `math.ex` with the following contents:
+
+```elixir
+defmodule Math do
+  def sum(a, b) do
+    a + b
+  end
+end
+```
+
+This file can be compiled using `elixirc`:
+
+    elixirc math.ex
+
+This will generate a file named `Elixir.Math.beam` containing the bytecode for the defined module. If we start `iex` again, our module definition will be available (provided that `iex` is started in the same directory the bytecode file is in):
+
+```iex
+iex> Math.sum(1, 2)
+3
+```
+
+Elixir projects are usually organized into three directories:
+
+* ebin - contains the compiled bytecode
+* lib - contains elixir code (usually `.ex` files)
+* test - contains tests (usually `.exs` files)
+
+When working on actual projects, the build tool called `mix` will be responsible for compiling and setting up the proper paths for you. For learning purposes, Elixir also supports a scripted mode which is more flexible and does not generate any compiled artifacts.
+
+## 8.2 Scripted mode
+
+In addition to the Elixir file extension `.ex`, Elixir also supports `.exs` files for scripting. Elixir treats both files exactly the same way, the only difference is in intention. `.ex` files are meant to be compiled while `.exs` files are used for scripting, without the need for compilation. For instance, we can create a file called `math.exs`:
+
+```elixir
+defmodule Math do
+  def sum(a, b) do
+    a + b
+  end
+end
+
+IO.puts Math.sum(1, 2)
+```
+
+And execute it as:
+
+    elixir math.exs
+
+The file will be compiled in memory and executed, printing "3" as the result. No bytecode file will be created. In the following examples, we recommend you write your code into script files and execute them as shown above.
+
+## 8.3 Named functions
+
+Inside a module, we can define functions with `def/2` and private functions with `defp/2`. A function defined with `def/2` can be invoked from other modules while a private function can only be invoked locally.
+
+```elixir
+defmodule Math do
+  def sum(a, b) do
+    do_sum(a, b)
+  end
+
+  defp do_sum(a, b) do
+    a + b
+  end
+end
+
+Math.sum(1, 2)    #=> 3
+Math.do_sum(1, 2) #=> ** (UndefinedFunctionError)
+```
+
+Function declarations also support guards and multiple clauses. If a function has several clauses, Elixir will try each clause until it finds one that matches. Here is an implementation of a function that checks if the given number is zero or not:
+
+```elixir
+defmodule Math do
+  def zero?(0) do
+    true
+  end
+
+  def zero?(x) when is_number(x) do
+    false
+  end
+end
+
+Math.zero?(0)  #=> true
+Math.zero?(1)  #=> false
+
+Math.zero?([1,2,3])
+#=> ** (FunctionClauseError)
+```
+
+Giving an argument that does not match any of the clauses raises an error.
+
+## 8.4 Function capturing
+
+Throughout this tutorial, we have been using the notation `name/arity` to refer to functions. It happens that this notation can actually be used to retrieve a named function as a function type. Let's start `iex` and run the `math.exs` file defined above:
+
+    $ iex math.exs
+
+```iex
+iex> Math.zero?(0)
+true
+iex> fun = &Math.zero?/1
+&Math.zero?/1
+iex> is_function fun
+true
+iex> fun.(0)
+true
+````
+
+Local or imported functions, like `is_function/1`, can be captured without the module:
+
+```iex
+iex> &is_function/1
+&:erlang.is_function/1
+iex> (&is_function/1).(fun)
+true
+```
+
+Note the capture syntax can also be used as a shortcut for creating functions:
+
+```iex
+iex> fun = &(&1 + 1)
+#Function<6.71889879/1 in :erl_eval.expr/5>
+iex> fun.(1)
+2
+```
+
+The `&1` represents the first argument passed into the function. `&(&1+1)` above is exactly the same as `fn x -> x + 1 end`. The syntax above is useful for short function definitions. You can read more about the capture operator `&` in [the `Kernel.SpecialForms` documentation](/docs/stable/Kernel.SpecialForms.html).
+
+## 8.5 Default arguments
+
+Named functions in Elixir also support default arguments:
+
+```elixir
+defmodule Concat do
+  def join(a, b, sep \\ " ") do
+    a <> sep <> b
+  end
+end
+
+IO.puts Concat.join("Hello", "world")      #=> Hello world
+IO.puts Concat.join("Hello", "world", "_") #=> Hello_world
+```
+
+Any expression is allowed to serve as a default value, but it won't be evaluated during the function definition; it will simply be stored for later use. Every time the function is invoked and any of its default values have to be used, the expression for that default value will be evaluated:
+
+```elixir
+defmodule DefaultTest do
+  def dowork(x \\ IO.puts "hello") do
+    x
+  end
+end
+```
+
+```iex
+iex> DefaultTest.dowork 123
+123
+iex> DefaultTest.dowork
+hello
+:ok
+```
+
+If a function with default values has multiple clauses, it is recommended to create a function head (without an actual body), just for declaring defaults:
+
+```elixir
+defmodule Concat do
+  def join(a, b \\ nil, sep \\ " ")
+
+  def join(a, b, _sep) when nil?(b) do
+    a
+  end
+
+  def join(a, b, sep) do
+    a <> sep <> b
+  end
+end
+
+IO.puts Concat.join("Hello", "world")      #=> Hello world
+IO.puts Concat.join("Hello", "world", "_") #=> Hello_world
+IO.puts Concat.join("Hello")               #=> Hello
+```
+
+When using default values, one must be careful to avoid overlapping function definitions. Consider the following example:
+
+```elixir
+defmodule Concat do
+  def join(a, b) do
+    IO.puts "***First join"
+    a <> b
+  end
+
+  def join(a, b, sep \\ " ") do
+    IO.puts "***Second join"
+    a <> sep <> b
+  end
+end
+```
+
+If we save the code above in a file named "concat.ex" and compile it, Elixir will emit the following warning:
+
+    concat.exs:7: this clause cannot match because a previous clause at line 2 always matches
+
+The compiler is telling us that invoking the `join` function with two arguments will always choose the first definition of `join` whereas the second one will only be invoked when three arguments are passed:
+
+    $ iex concat.exs
+
+```iex
+iex> Concat.join "Hello", "world"
+***First join
+"Helloworld"
+```
+
+```iex
+iex> Concat.join "Hello", "world", "_"
+***Second join
+"Hello_world"
+```
+
+This finishes our short introduction to modules. In the next chapters, we will learn how to use named functions for recursion, explore Elixir lexical directives that can be used for importing functions from other modules and discuss module attributes.
diff --git a/getting_started/9.markdown b/getting_started/9.markdown
new file mode 100644
index 000000000..04c2e4647
--- /dev/null
+++ b/getting_started/9.markdown
@@ -0,0 +1,118 @@
+---
+layout: getting_started
+title: 9 Recursion
+guide: 9
+---
+
+# {{ page.title }}
+
+Due to immutability, loops in Elixir (and in functional programming languages) are written differently from conventional imperative languages. For example, in an imperative language, one would write:
+
+```c
+for(i = 0; i < array.length; i++) {
+  array[i] = array[i] * 2
+}
+```
+
+In the example above, we are mutating the array and the helper variable `i`. That's not possible in Elixir. Instead, functional languages rely on recursion: a function is called recursively until a condition is reached that stops the recursive action from continuing. Consider the example below that prints a string an arbitrary amount of times:
+
+```elixir
+defmodule Recursion do
+  def print_multiple_times(msg, n) when n <= 1 do
+    IO.puts msg
+  end
+
+  def print_multiple_times(msg, n) do
+    IO.puts msg
+    print_multiple_times(msg, n - 1)
+  end
+end
+
+Recursion.print_multiple_times("Hello!", 3)
+# Hello!
+# Hello!
+# Hello!
+```
+
+Similar to case, a function may have many clauses. A particular clause is executed when the arguments passed to the function match the clause's argument patterns and its guard evaluates to `true`.
+
+Above when `print_multiple_times/2` is initially called, the argument `n` is equal to `3`.
+
+The first clause has a guard which says use this definition if and only if `n` is less than or equal to `1`. Since this is not the case, Elixir proceeds to the next clause's definition.
+
+The second definition matches the pattern and has no guard so it will be executed. It first prints our `msg` and then calls itself passing `n - 1` (`2`) as the second argument. Our `msg` is printed and `print_multiple_times/2` is called again this time with the second argument set to `1`.
+
+Because `n` is now set to `1`, the guard to our first definition of `print_multiple_times/2` evaluates to true, and we execute this particular definition. The `msg` is printed, and there is nothing left to execute.
+
+We defined `print_multiple_times/2` so that no matter what number is passed as the second argument it either triggers our first definition (known as a "base case") or it triggers our second definition which will ensure that we get exactly 1 step closer to our base case.
+
+Let's now see how we can use the power of recursion to sum a list of numbers.
+
+```elixir
+defmodule Math do
+  def sum_list([head|tail], accumulator) do
+    sum_list(tail, head + accumulator)
+  end
+
+  def sum_list([], accumulator) do
+    accumulator
+  end
+end
+
+Math.sum_list([1, 2, 3], 0) #=> 6
+```
+
+We invoke `sum_list` with a list `[1,2,3]` and the initial value `0` as arguments. We will try each clause until we find one that matches according to the pattern matching rules. In this case, the list `[1,2,3]` matches against `[head|tail]` which assigns `head = 1` and `tail = [2,3]` while `accumulator` is set to `0`.
+
+Then, we add the head of the list to the accumulator `head + accumulator` and call `sum_list` again, recursively, passing the tail of the list as its first argument. The tail will once again match `[head|tail]` until the list is empty, as seen below:
+
+```elixir
+sum_list [1, 2, 3], 0
+sum_list [2, 3], 1
+sum_list [3], 3
+sum_list [], 6
+```
+
+When the list is empty, it will match the final clause which returns the final result of `6`.
+
+The process of taking a list and "reducing" it down to one value is known as a "reduce" algorithm and is central to functional programming.
+
+What if we instead want to double all of the values in our list?
+
+```elixir
+defmodule Math do
+  def double_each([head|tail]) do
+    [head * 2| double_each(tail)]
+  end
+
+  def double_each([]) do
+    []
+  end
+end
+
+Math.double_each([1, 2, 3]) #=> [2, 4, 6]
+```
+
+Here we have used recursion to traverse a list doubling each element and returning a new list. The process of taking a list and "mapping" over it is known as a "map" algorithm.
+
+Recursion and tail call optimization are an important part of Elixir and are commonly used to create loops. However, when programming Elixir you will rarely use recursion as above to manipulate lists.
+
+The [`Enum` module](/docs/stable/Enum.html), which we are going to study in the next chapter, already provides many conveniences for working with lists. For instance, the examples above could be written as:
+
+```iex
+iex> Enum.reduce([1, 2, 3], 0, fn(x, acc) -> x + acc end)
+6
+iex> Enum.map([1, 2, 3], fn(x) -> x * 2 end)
+[2, 4, 6]
+```
+
+Or, using the capture syntax:
+
+```iex
+iex> Enum.reduce([1, 2, 3], 0, &+/2)
+6
+iex> Enum.map([1, 2, 3], &(&1 * 2))
+[2, 4, 6]
+```
+
+So let's take a deeper look at Enumerables and Streams.
diff --git a/getting_started/ex_unit/1.markdown b/getting_started/ex_unit/1.markdown
index 4463ffc2c..133a1f12a 100644
--- a/getting_started/ex_unit/1.markdown
+++ b/getting_started/ex_unit/1.markdown
@@ -2,7 +2,7 @@
 layout: getting_started
 title: 1 Introduction to ExUnit
 guide: 1
-total_guides: 1
+last: true
 ---
 
 # {{ page.title }}
@@ -23,7 +23,11 @@ defmodule MyTest do
 end
 ```
 
-In general, we just need to invoke `ExUnit.start`, define a test case using `ExUnit.Case` and our batch of tests. Assuming we saved this file as `assertion_test.exs`, we can run it directly:
+In general, we just need to invoke `ExUnit.start`, define a test case using `ExUnit.Case` and our batch of tests. Most tests will be invoked as part of a [Mix](http://elixir-lang.org/getting_started/mix/1.html) project.
+
+    mix test
+
+Otherwise, assuming we saved this file as `assertion_test.exs`, we can run it directly:
 
     bin/elixir assertion_test.exs
 
diff --git a/getting_started/meta/1.markdown b/getting_started/meta/1.markdown
new file mode 100644
index 000000000..d5fc87d49
--- /dev/null
+++ b/getting_started/meta/1.markdown
@@ -0,0 +1,146 @@
+---
+layout: getting_started
+title: 1 Quote and unquote
+guide: 1
+---
+
+# {{ page.title }}
+
+An Elixir program can be represented by its own data structures. In this chapter, we will learn how those structures look like and how to compose them. The concepts learned in this chapter are the building blocks for macros, which we are going to take a deeper look at the next chapter.
+
+## 1.1 Quoting
+
+The building block of an Elixir program is a tuple with three elements. For example, the function call `sum(1,2,3)` is represented internally as:
+
+```elixir
+{:sum, [], [1, 2, 3]}
+```
+
+You can get the representation of any expression by using the `quote` macro:
+
+```iex
+iex> quote do: sum(1, 2, 3)
+{:sum, [], [1, 2, 3]}
+```
+
+The first element is the function name, the second is a keyword list containing metadata and the third is the arguments list.
+
+Operators are also represented as such tuples:
+
+```iex
+iex> quote do: 1 + 2
+{:+, [context: Elixir, import: Kernel], [1, 2]}
+```
+
+Even a map is represented as a call to `%{}`:
+
+```iex
+iex> quote do: %{1 => 2}
+{:%{}, [], [{1, 2}]}
+```
+
+Variables are also represented using such triplets, except the last element is an atom, instead of a list:
+
+```iex
+iex> quote do: x
+{ :x, [], Elixir }
+```
+
+When quoting more complex expressions, we can see the code is represented in such tuples, often nested inside each other resembling a tree. Many languages would call those representations the Abstract Syntax Tree (AST). Elixir calls them quoted expressions:
+
+```iex
+iex> quote do: sum(1, 2 + 3, 4)
+{:sum, [], [1, {:+, [context: Elixir, import: Kernel], [2, 3]}, 4]}
+```
+
+Sometimes when working with quoted expressions, it may be useful to get the textual code representation back. This can be done with `Macro.to_string/1`:
+
+```iex
+iex> Macro.to_string(quote do: sum(1, 2 + 3, 4))
+"sum(1, 2 + 3, 4)"
+```
+
+In general, the tuples above follow the following format:
+
+```elixir
+{ tuple | atom, list, list | atom }
+```
+
+* The first element is an atom or another tuple in the same representation;
+* The second element is a keyword list containing information like metadata like numbers and contexts;
+* The third element is either a list of arguments for the function call or an atom. When an atom, it means the tuple represents a variable.
+
+Besides the tuple defined above, there are five Elixir literals that when quoted return themselves (and not a tuple). They are:
+
+```elixir
+:sum         #=> Atoms
+1.0          #=> Numbers
+[1,2]        #=> Lists
+"strings"    #=> Strings
+{key, value} #=> Tuples with two elements
+```
+
+Most of Elixir code has straight-forward translation to its underlying quoted expression. We recommend you to try out different code samples and see what gets out of it. For example, what `String.upcase("foo")` expands to? We have also learned that `if(true, do: this, else: that)` is the same as `if true do this else that end`. How does this affirmation hold with quoted expressions?
+
+## 1.2 Unquoting
+
+Quote is about retrieving the inner representation of some particular chunk of code. However, sometimes it may be necessary to inject some other particular chunk of code inside the representation we want to retrieve.
+
+For example, imagine you have a variable `number` which contains the number you want to inject inside a quoted expression. The number can be injected into the quoted representation by using `unquote`:
+
+```iex
+iex> number = 13
+iex> Macro.to_string(quote do: 11 + unquote(number))
+"11 + 13"
+```
+
+`unquote` can even be used to inject function names:
+
+```iex
+iex> fun = :hello
+iex> Macro.to_string(quote do: unquote(fun)(:world))
+"hello(:world)"
+```
+
+In some cases, it may be necessary to inject many values inside a list. For example, imagine you have a list containing `[1, 2, 6]` and we want to inject `[3, 4, 5]` into it. Using `unquote` won't yield the desired result:
+
+```iex
+iex> inner = [3, 4, 5]
+iex> Macro.to_string(quote do: [1, 2, unquote(inner), 6])
+"[1, 2, [3, 4, 5], 6]"
+```
+
+That's when `unquote_splicing` becomes handy:
+
+```iex
+iex> inner = [3, 4, 5]
+iex> Macro.to_string(quote do: [1, 2, unquote_splicing(inner), 6])
+"[1, 2, 3, 4, 5, 6]"
+```
+
+Unquoting is very useful when working with macros. When writing macros, developers are able to receive code chunks and inject them inside other code chunks, being able to transform code or write code that generates code during compilation.
+
+## 1.3 Escaping
+
+As we have seen at the beginning of this chapter, only some values are valid quoted expressions. For example, a map is not a valid quoted expression. Nor a tuple with three elements. However, we have seen before those values *can* be expressed as a quoted expression:
+
+```iex
+iex> quote do: %{1 => 2}
+{:%{}, [], [{1, 2}]}
+```
+
+In some cases, you may need to inject such *values* into *quoted expressions*. To do that, we need to first escape those values into quoted expressions with the help of `Macro.escape/1`:
+
+```iex
+iex> map = %{hello: :world}
+iex> Macro.escape(map)
+{:%{}, [], [hello: :world]}
+```
+
+In other words, it is important to make a distinction in between a regular Elixir value (like a list, a map, a process, a reference, etc) and a quoted expression. Some values like integers, atoms and strings have a quoted expression equal to the value itself. Other values like maps needs to be explicitly converted. Finally, some values like functions and references cannot be converted to a quoted expression at all.
+
+Macros receive quoted expressions and must return quoted expressions. However, sometimes during the function of a macro, you may need to work with values and making a distinction in between them may be required.
+
+You can read more about `quote` and `unquote` in the [`Kernel.SpecialForms` module](/docs/stable/Kernel.SpecialForms.html). Documentation for `Macro.escape/1` and other quoted expressions related functions can be found in the [`Macro` module](/docs/stable/Macro.html).
+
+With this introduction we have laid the ground to finally write out first macro, so let's move to the next chapter.
diff --git a/getting_started/meta/2.markdown b/getting_started/meta/2.markdown
new file mode 100644
index 000000000..1c3b2aed4
--- /dev/null
+++ b/getting_started/meta/2.markdown
@@ -0,0 +1,215 @@
+---
+layout: getting_started
+title: 2 Macros
+guide: 2
+---
+
+# {{ page.title }}
+
+Macros can be defined in Elixir using `defmacro/2`.
+
+> For this chapter, we will be using files instead of running code samples in IEx. That's because the code samples will span multiple lines of code and typing them all in IEx can be counter-productive. You should be able to run the code samples by saving them into a `macros.exs` file and running it with `elixir macros.exs` or `iex macros.exs`.
+
+## 2.1 Our first macro
+
+In order to better understand how macros work, let's create a new module where we are going to implement `unless`, which does the opposite of `if`, as a macro and as a function:
+
+```elixir
+defmodule Unless do
+  def fun_unless(clause, expression) do
+    if(!clause, do: expression)
+  end
+
+  defmacro macro_unless(clause, expression) do
+    quote do
+      if(!unquote(clause), do: unquote(expression))
+    end
+  end
+end
+```
+
+The function receives the arguments and pass them to `if`. However, the macro will receive quoted expressions, as we have learned in the previous chapter, inject them into the quote, finally returning another quoted expression.
+
+Let's start `iex` with the module above:
+
+    $ iex macros.exs
+
+And play with those definitions:
+
+```iex
+iex> require Unless
+iex> Unless.macro_unless true, IO.puts "this should never be printed"
+nil
+iex> Unless.fun_unless true, IO.puts "this should never be printed"
+"this should never be printed"
+nil
+```
+
+Note that in our macro implementation, the sentence was not printed, although it was printed in our function implementation. That's because the arguments to a function call are evaluated before calling the function. However macros do not evaluate the arguments, instead they receive the arguments as quoted expressions which are then transformed into other quoted expressions. In this case, we have rewritten our `unless` macro to become an `if` behind the scenes.
+
+In other words, when invoked as:
+
+```elixir
+Unless.macro_unless true, IO.puts "this should never be printed"
+```
+
+Our `macro_unless` macro received the following:
+
+```elixir
+macro_unless(true, {{:., [], [IO, :puts], [], ["this should never be printed"]}})
+```
+
+And it then return a quoted expression as follows:
+
+```elixir
+{:if, [], [
+  {:!, [], [true]},
+  {{:., [], [IO, :puts], [], ["this should never be printed"]}}]}
+```
+
+We can actually verify this is the case by using `Macro.expand_once/2`:
+
+```iex
+iex> expr = quote do: Unless.macro_unless(true, IO.puts "this should never be printed")
+iex> res  = Macro.expand_once(expr, __ENV__)
+iex> IO.puts Macro.to_string(res)
+if(!true) do
+  IO.puts("this should never be printed")
+end
+:ok
+```
+
+`Macro.expand_once/2` receives a quoted expression and expands it according to the current environment. In this case, it expanded/invoked the `Unless.macro_unless/2` macro and returned its result. We then proceeded to convert the returned quoted expression to a string and print it (we will talk about `__ENV__` still in this chapter).
+
+That's what macros are all about. They are about receiving quoted expressions and transforming them into something else. In fact, `unless/2` in Elixir is implemented as a macro:
+
+```elixir
+defmacro unless(clause, options) do
+  quote do
+    if(!unquote(clause), do: unquote(options))
+  end
+end
+```
+
+Not only `unless/2`, `defmacro/2`, `def/2`, `defprotocol/2` and many constructs used throughout this getting started guide are implemented in pure Elixir, often as a macros. This means that the constructs being used to build the language, can be used by developers to extend the language to the domains they are working on.
+
+We can define any function and macro we want, including ones that override the built-in definitions provided by Elixir. The only exceptions are Elixir special forms which are not implemented in Elixir and therefore cannot be overridden, [the full list of special forms is available in `Kernel.SpecialForms`](/docs/stable/Kernel.SpecialForms.html).
+
+## 2.2 Macros hygiene
+
+Elixir macros have late resolution. This guarantees that a variable defined inside a quote won't conflict with a variable defined in the context where that macro is expanded. For example:
+
+```elixir
+defmodule Hygiene do
+  defmacro no_interference do
+    quote do: a = 1
+  end
+end
+
+defmodule HygieneTest do
+  def go do
+    require Hygiene
+    a = 13
+    Hygiene.no_interference
+    a
+  end
+end
+
+HygieneTest.go
+# => 13
+```
+
+In the example above, even if the macro injects `a = 1`, it does not affect the variable `a` defined by the `go` function. In case the macro wants to explicitly affect the context, it can use `var!`:
+
+```elixir
+defmodule Hygiene do
+  defmacro interference do
+    quote do: var!(a) = 1
+  end
+end
+
+defmodule HygieneTest do
+  def go do
+    require Hygiene
+    a = 13
+    Hygiene.interference
+    a
+  end
+end
+
+HygieneTest.go
+# => 1
+```
+
+Variables hygiene only works because Elixir annotates variables with their context. For example, a variable `x` defined at the line 3 of a module, would be represented as:
+
+    {:x, [line: 3], nil}
+
+However, a quoted variable is represented as:
+
+```elixir
+defmodule Sample do
+  def quoted do
+    quote do: x
+  end
+end
+
+Sample.quoted #=> {:x, [line: 3], Sample}
+```
+
+Notice that the third element in the quoted variable is the atom `Sample`, instead of `nil`, which marks the variable as coming from the `Sample` module. Therefore, Elixir considers those two variables come from different contexts and handle them accordingly.
+
+Elixir provides similar mechanisms for imports and aliases too. This guarantees macros will behave as specified by its source module rather than conflicting with the target module where the macro is expanded. Hygiene can be passed under specific situations by using macros like `var!/2` and `alias!/2`, although one must be careful when using those as they directly change the user environment.
+
+## 2.3 The environment
+
+When using `Macro.expand_once/2` earlier in this chapter, we have used the special form `__ENV__`.
+
+`__ENV__` returns an instance of `Macro.Env` which contains useful information about the compilation environment. It contains useful information like the current module, file and line, all variables defined in the current scope, as well as imports, requires and so on.
+
+Let's give it a try:
+
+```iex
+iex> __ENV__.module
+nil
+iex> __ENV__.file
+"iex"
+iex> __ENV__.requires
+[IEx.Helpers, Kernel, Kernel.Typespec]
+iex> require Integer
+nil
+iex> __ENV__.requires
+[IEx.Helpers, Integer, Kernel, Kernel.Typespec]
+```
+
+Many of the functions in the `Macro` module expect an environment. You can read more about them in [the docs for the `Macro` module](/docs/stable/Macro.html) and learn more about the compilation environment with [`Macro.Env`](/docs/stable/Macro.Env.html).
+
+## 2.4 Private macros
+
+Elixir also supports private macros via `defmacrop`. As private functions, these macros are only available inside the module that defines them, and only at compilation time.
+
+It is important that a macro is defined before its usage. Failing to define a macro before its invocation will raise an error at runtime, since the macro won't be expanded and will be translated to a function call:
+
+```elixir
+iex> defmodule Sample do
+...>  def four, do: two + two
+...>  defmacrop two, do: 2
+...> end
+** (CompileError) iex:2: function two/0 undefined
+```
+
+## 2.5 Write macros responsibly
+
+Macros are a powerful construct and Elixir provides many mechanisms to ensure they are used responsibly:
+
+* Macros are hygienic: by default, variables defined inside the macro are not going to affect the user code. Furthermore, functions calls and aliases available in the macro context are not going to leak into the user context;
+
+* Macros are lexical: it is impossible to inject code or macros globally. Before using a macro, you need to explicitly `require` or `import` the module that defines the macro;
+
+* Macros are explicit: it is impossible to run a macro without explicitly invoking it. For example, some languages allow developers to completely rewrite functions behind the scenes, often via parse transforms or via some reflection mechanisms. In Elixir, a macro must be explicitly invoked in the caller;
+
+* Macros' language is clear: many languages provide syntax shortcuts for `quote` and `unquote`. In Elixir, we preferred to have those explicitly spelled out, in order to clearly delimit the boundaries of a macro definition;
+
+Even if Elixir attempts its best to provide a safe environment, the major responsibility still falls on the developers. That's why the first rule of the macro club is **write macros responsibly**. Macros are harder to write than ordinary Elixir functions and it's considered to be bad style to use them when they're not necessary. Elixir already provides elegant mechanisms to write your every day code and macros should be saved as last resort.
+
+With those lessons, we finish our introduction to macros. The next chapter is a brief discussion on DSLs, showing how we can mix macros and module attributes to annotate and extend modules and functions.
diff --git a/getting_started/meta/3.markdown b/getting_started/meta/3.markdown
new file mode 100644
index 000000000..d1b200256
--- /dev/null
+++ b/getting_started/meta/3.markdown
@@ -0,0 +1,166 @@
+---
+layout: getting_started
+title: 3 Domain Specific Languages
+guide: 3
+last: true
+---
+
+# {{ page.title }}
+
+[Domain Specific Languages](https://en.wikipedia.org/wiki/Domain-specific_language) allows developers to specialize their application to a particular domain. There are many language features that come together to aid developers to write Domain Specific Languages and in this chapter we will focus on just one of them.
+
+In particular, we will focus on how macros and module attributes can be used together to create domain specific modules, that are focused on solving one particular example. To showcase our implementation, we will write a very simple test case implementation.
+
+The goal is to build a module named `TestCase` that allows us to write the following:
+
+```elixir
+defmodule MyTest do
+  use TestCase
+
+  test "arithmetic operations" do
+    4 = 2 + 2
+  end
+
+  test "list operations" do
+    [1, 2, 3] = [1, 2] ++ [3]
+  end
+end
+
+MyTest.run
+```
+
+In the example above, by using `TestCase`, we can define tests using the `test` macro and it automatically defines a function named `run` that will automatically run all tests for us. Our prototype will also simply rely on the match operator (`=`) as a mechanism to do assertions.
+
+## 3.1 The `test` macro
+
+Let's start by defining a module that simply defines and imports the `test` macro when used:
+
+```elixir
+defmodule TestCase do
+  # Callback invoked when by `use`.
+  #
+  # For now it simply returns a quoted expression that
+  # imports the module itself into the user code.
+  @doc false
+  defmacro __using__(_opts) do
+    quote do
+      import TestCase
+    end
+  end
+
+  @doc """
+  Defines a test case with the given description.
+
+  ## Examples
+
+      test "arithmetic operations" do
+        4 = 2 + 2
+      end
+
+  """
+  defmacro test(description, do: block) do
+    function_name = binary_to_atom("test " <> description)
+    quote do
+      def unquote(function_name)(), do: unquote(block)
+    end
+  end
+end
+```
+
+Asuming we defined `TestCase` in a file named `tests.exs`, we can open it up `iex tests.exs` and define our first tests:
+
+```iex
+iex> defmodule MyTest do
+...>   use TestCase
+...>
+...>   test "hello" do
+...>     "hello" = "world"
+...>   end
+...> end
+```
+
+For now we don't have a mechanism to run tests, but we know that a function named "test hello" was defined behind the scenes, so we can invoke it and it should fail:
+
+```iex
+iex> MyTest."test hello"()
+** (MatchError) no match of right hand side value: "world"
+```
+
+## 3.2 Storing information with attributes
+
+In order to finish our `TestCase` implementation, we need to be able to retrieve all defined test cases. One way of doing such is by retrieving the tests at runtime via `__MODULE__.__info__(:functions)` which returns a list of all functions in a given module. However, considering that we may want to store more information with each tests beyond the test name, are more flexible approach is required.
+
+When discussing module attributes in early chapters, we have discussed how they can be used as temporary storage and that's exactly what we will do in this section.
+
+In the `__using__/1` implementation, we will initialize a module attribute named `@tests` to an empty list, then store each defined test in this attribute until we compile into into a `run` function.
+
+Here is the updated code for the `TestCase` module:
+
+```elixir
+defmodule TestCase do
+  @doc false
+  defmacro __using__(_opts) do
+    quote do
+      import TestCase
+
+      # Initialize @tests to an empty list
+      @tests []
+
+      # Invoke TestCase.__before_compile__/1 before the module is compiled
+      @before_compile TestCase
+    end
+  end
+
+  @doc """
+  Defines a test case with the given description.
+
+  ## Examples
+
+      test "arithmetic operations" do
+        4 = 2 + 2
+      end
+
+  """
+  defmacro test(description, do: block) do
+    function_name = binary_to_atom("test " <> description)
+    quote do
+      # Prepend the newly defined test to the list of tests
+      @tests [unquote(function_name)|@tests]
+      def unquote(function_name)(), do: unquote(block)
+    end
+  end
+
+  # This will be invoked right before the target module is compiled
+  # giving us the perfect opportunity to inject the `run/0` function
+  @doc false
+  defmacro __before_compile__(env) do
+    quote do
+      def run do
+        Enum.each @tests, fn name ->
+          IO.puts "Running #{name}"
+          apply(__MODULE__, name, [])
+        end
+      end
+    end
+  end
+end
+```
+
+By starting a new IEx session, we can now define our tests and run them:
+
+```iex
+iex> defmodule MyTest do
+...>   use TestCase
+...>
+...>   test "hello" do
+...>     "hello" = "world"
+...>   end
+...> end
+iex> MyTest.run
+Running test hello
+** (MatchError) no match of right hand side value: "world"
+```
+
+Although we have glanced over some details, the bulk of how we can create domain specific modules in Elixir is here. Macros allows us to return quoted expressions that are executed in the caller, which in turn we use to transform code and to store relevant information in the target module via module attributes. Finally, with callbacks such as `@before_compile`, we have the perfect opportunity to inject code into the module when its definition is complete.
+
+Besides `@before_compile`, there are other useful module attributes, like `@on_definition` and `@after_compile` and you can more about read them in [the docs for the `Module` module](/docs/stable/Module.html). You can also find useful documentation about macros in the [`Macro` module](/docs/stable/Macro.html) and about the compilation environment in [`Macro.Env`](/docs/stable/Macro.Env.html).
diff --git a/getting_started/mix/1.markdown b/getting_started/mix/1.markdown
index dcf4fb6fd..9a9601d4e 100644
--- a/getting_started/mix/1.markdown
+++ b/getting_started/mix/1.markdown
@@ -2,7 +2,6 @@
 layout: getting_started
 title: 1 Introduction to Mix
 guide: 1
-total_guides: 3
 ---
 
 # {{ page.title }}
@@ -49,9 +48,9 @@ defmodule MyProject.Mixfile do
   use Mix.Project
 
   def project do
-    [ app: :my_project,
-      version: "0.0.1",
-      deps: deps ]
+    [app: :my_project,
+     version: "0.0.1",
+     deps: deps]
   end
 
   # Configuration for the OTP application
@@ -60,10 +59,10 @@ defmodule MyProject.Mixfile do
   end
 
   # Returns the list of dependencies in the format:
-  # { :foobar, git: "https://github.com/elixir-lang/foobar.git", tag: "0.1" }
+  # {:foobar, git: "https://github.com/elixir-lang/foobar.git", tag: "0.1"}
   #
   # To specify particular versions, regardless of the tag, do:
-  # { :barbat, "~> 0.1", github: "elixir-lang/barbat.git" }
+  # {:barbat, "~> 0.1", github: "elixir-lang/barbat"}
   defp deps do
     []
   end
@@ -143,20 +142,22 @@ Mix is also able to manage dependencies. Dependencies should be listed in the pr
 
 ```elixir
 def project do
-  [ app: :my_project,
-    version: "0.0.1",
-    deps: deps ]
+  [app: :my_project,
+   version: "0.0.1",
+   deps: deps]
 end
 
 defp deps do
-  [ { :some_project, github: "some_project/other", tag: "0.3.0" },
-    { :another_project, ">= 1.0.2", git: "https://example.com/another/repo.git" } ]
+  [{:some_project, ">= 0.3.0"},
+   {:another_project, git: "https://example.com/another/repo.git", tag: "v1.0.2"}]
 end
 ```
 
 **Note:** Although not required, it is common to split dependencies into their own function.
 
-The dependency is represented by an atom, followed by an optional the version requirement and some options detailed in the next section. Since most of the dependencies are git repositories, it is recommended to depend on a particular tag. However, if you want to depend on master or in a particular branch, you can define a version requirement to specify which versions of a given dependency you are willing to work against. It supports common operators like `>=`, `<=`, `>`, `==` as follows:
+The dependency is represented by an atom, followed by a requirement and some options. By default, Mix uses [hex.pm](https://hex.pm) to fetch dependencies but it can also fetch them from a git repository or directly from the filesystem.
+
+When using Hex, you must use requirements to specify which versions of a given dependency you accept. It supports common operators like `>=`, `<=`, `>`, `==` as follows:
 
     # Only version 2.0.0
     "== 2.0.0"
@@ -173,7 +174,7 @@ Since the example above is such a common requirement, it can be expressed as:
 
     "~> 2.0.0"
 
-Note that setting the version requirement does not affect the branch or tag that is checked out, so while a definition like the following is possible:
+Note that setting the version requirement for git repositories does not affect the branch or tag that is checked out, so while a definition like the following is possible:
 
     { :some_project, "~> 0.5.0", github: "some_project/other", tag: "0.3.0" }
 
@@ -181,7 +182,7 @@ It will lead to a dependency that will never be satisfied, because the tag being
 
 ### 1.4.1 Source Code Management (SCM)
 
-In the example above, we have used `git` to specify our dependencies. Mix is designed in a way it can support multiple SCM tools, shipping with `:git` and `:path` support by default. The most common options are:
+Mix is designed in a way it can support multiple SCM tools, Hex packages being the default, while `:git` and `:path` are supported as options. The most common options are:
 
 * `:git` - the dependency is a git repository that is retrieved and updated by Mix;
 * `:path` - the dependency is simply a path in the filesystem;
@@ -207,7 +208,7 @@ In order to compile a dependency, Mix looks into the repository for the best way
 If the dependency does not contain any of the above, you can specify a command directly with the `:compile` option:
 
 ```elixir
-    compile: "./configure && make"
+{:some_dep, git: "...", compile: "./configure && make"}
 ```
 
 If `:compile` is set to false, nothing is done.
@@ -235,7 +236,7 @@ Use `mix help` to get more information.
 
 ### 1.4.5 Dependencies of dependencies
 
-If your dependency is another Mix or rebar project, Mix does the right thing: it will automatically fetch and handle all dependencies of your dependencies. However, if your project have two dependencies that share the same dependency and the SCM information for the shared dependency doesn't match between the parent dependencies, Mix will mark that dependency as diverged and emit a warning. To solve this issue you can declare the shared dependency in your project and Mix will use that SCM information to fetch the dependency.
+If your dependency is another Mix or rebar project, Mix does the right thing: it will automatically fetch and handle all dependencies of your dependencies. However, if your project has two dependencies that share the same dependency and the SCM information for the shared dependency doesn't match between the parent dependencies, Mix will mark that dependency as diverged and emit a warning. To solve this issue you can declare the shared dependency in your project with the option `override: true` and Mix will use that SCM information to fetch the dependency.
 
 ## 1.5 Umbrella projects
 
@@ -250,7 +251,7 @@ defmodule Project.Mixfile do
   use Mix.Project
 
   def project do
-    [ apps_path: "apps" ]
+    [apps_path: "apps"]
   end
 end
 ```
@@ -264,14 +265,14 @@ defmodule A.Mixfile do
   use Mix.Project
 
   def project do
-    [ app: :a,
-      deps_path: "../../deps",
-      lockfile: "../../mix.lock",
-      deps: deps ]
+    [app: :a,
+     deps_path: "../../deps",
+     lockfile: "../../mix.lock",
+     deps: deps]
   end
 
   defp deps do
-    [ { :b, in_umbrella: true } ]
+    [{ :b, in_umbrella: true }]
   end
 end
 ```
@@ -286,13 +287,15 @@ Mix has the concept of environments that allows a developer to customize compila
 * `test` - used by `mix test`;
 * `prod` - the environment in which dependencies are loaded and compiled;
 
-By default, these environments behave the same and all configuration we have seen so far will affect all three environments. Customization per environment can be done using the `env:` option:
+By default, these environments behave the same and all configuration we have seen so far will affect all three environments. Customization per environment can be done by accessing `Mix.env`:
 
 ```elixir
 def project do
-  [ env: [
-    prod: [compile_path: "prod_ebin"] ] ]
+  [deps_path: deps_path(Mix.env)]
 end
+
+defp deps_path(:prod), do: "prod_deps"
+defp deps_path(_), do: "deps"
 ```
 
 Mix will default to the `dev` environment (except for tests). The environment can be changed via the `MIX_ENV` environment variable:
diff --git a/getting_started/mix/2.markdown b/getting_started/mix/2.markdown
index 0fbbce308..eb6834751 100644
--- a/getting_started/mix/2.markdown
+++ b/getting_started/mix/2.markdown
@@ -2,14 +2,13 @@
 layout: getting_started
 title: 2 Building OTP apps with Mix
 guide: 2
-total_guides: 3
 ---
 
 # {{ page.title }}
 
 Where do we keep state in Elixir?
 
-Our software needs to keep state, configuration values, data about the running system, etc. We have learned in previous sections how we can use processes/actors to keep state, receiving and responding to messages in a loop but this approach seems to be brittle. What happens if there is an error in our actor and it crashes? Even more, is it really required to create a new process when all we want to do is to keep simple configuration values?
+Our software needs to keep state, configuration values, data about the running system, etc. We have learned in [previous sections](../2.html#receive) how we can use processes/actors to keep state, receiving and responding to messages in a loop but this approach seems to be brittle. What happens if there is an error in our actor and it crashes? Even more, is it really required to create a new process when all we want to do is to keep simple configuration values?
 
 In this chapter, we will answer those questions by building an OTP application. In practice, we don't need Mix in order to build such applications, however Mix provides some conveniences that we are going to explore throughout this chapter.
 
@@ -122,11 +121,11 @@ iex> :gen_server.call(pid, :pop)
 
 You can see there are two error reports. The first one is generated by server, due to the crash. Since the server is linked to our process, it also sent an exit message which was printed by `IEx` as `** (exit) ...`.
 
-Since our servers may eventually crash, it is common to supervise them, and that's what we are going to next. There is a bit more to `GenServer` than what we have seen here. For more information, check [`GenServer.Behaviour`'s documentation](http://elixir-lang.org/docs/stable/GenServer.Behaviour.html).
+Since our servers may eventually crash, it is common to supervise them, and that's what we are going to next. There is a bit more to `GenServer` than what we have seen here. For more information, check [`GenServer.Behaviour`'s documentation](/docs/stable/GenServer.Behaviour.html).
 
 ## 2.2 Supervising our servers
 
-When building applications in Erlang/Elixir, a common philosophy is to "let it crash". Resources are going to become unavailable, timeout in between services are going to happen and other possible failures exist. That's why it is important to recover and react to such failures. With this in mind, we are going to write a supervisor for our server.
+When building applications in Erlang/Elixir, a common philosophy is to fail fast. Resources are going to become unavailable, timeout in between services are going to happen and other possible failures exist. That's why it is important to recover and react to such failures. With this in mind, we are going to write a supervisor for our server.
 
 Create a file at `lib/stacker/supervisor.ex` with the following:
 
@@ -218,7 +217,7 @@ iex> :gen_server.call(:stacker, :unknown)
     gen_server.erl:180: :gen_server.call/2
 ```
 
-The sixth message no longer generates an error report, since our server was no longer started automatically. Elixir returns `:noproc` (which stands for no process), meaning there isn't a process named `:stacker`. The number of restarts allowed and its time interval can be customized by passing options to the `supervise` function. Different restart strategies, besides the `:one_for_one` used above, can be chosen for the supervisor as well. For more information on the supported options, [check the documentation for `Supervisor.Behaviour`](http://elixir-lang.org/docs/stable/Supervisor.Behaviour.html).
+The sixth message no longer generates an error report, since our server was no longer started automatically. Elixir returns `:noproc` (which stands for no process), meaning there isn't a process named `:stacker`. The number of restarts allowed and its time interval can be customized by passing options to the `supervise` function. Different restart strategies, besides the `:one_for_one` used above, can be chosen for the supervisor as well. For more information on the supported options, [check the documentation for `Supervisor.Behaviour`](/docs/stable/Supervisor.Behaviour.html).
 
 ## 2.3 Who supervises the supervisor?
 
@@ -260,7 +259,7 @@ iex> :gen_server.call(:stacker, :pop)
 :hello
 ```
 
-Amazing, it works! As you may have noticed, the application `start/2` callback receives a type argument, which we have ignored. The type controls how the VM should behave when the supervisor, and consequently our application, crashes. You can learn more about it by [reading the documentation for `Application.Behaviour`](http://elixir-lang.org/docs/stable/Application.Behaviour.html).
+Amazing, it works! As you may have noticed, the application `start/2` callback receives a type argument, which we have ignored. The type controls how the VM should behave when the supervisor, and consequently our application, crashes. You can learn more about it by [reading the documentation for `Application.Behaviour`](/docs/stable/Application.Behaviour.html).
 
 Finally, notice that `mix new` supports a `--sup` option, which tells Mix to generate a supervisor with an application module callback, automating some of the work we have done here. Try it!
 
@@ -275,7 +274,7 @@ iex> :application.start(:stacker)
 
 In this case, since the application was previously started, it returns so as an error message.
 
-Mix does not only starts your application but all of your application dependencies. Notice there is a difference between your project dependencies (the ones defined under the `deps` key we have discussed in the previous chapter) and the application dependencies.
+Mix not only starts your application but all of your application dependencies. Notice there is a difference between your project dependencies (the ones defined under the `deps` key we have discussed in the previous chapter) and the application dependencies.
 
 The project dependencies may contain your test framework or a compile-time only dependency. The application dependency is everything you depend on at runtime. Any application dependency needs to be explicitly added to the `application` function too:
 
diff --git a/getting_started/mix/3.markdown b/getting_started/mix/3.markdown
index 61ab6aff9..0ab3f81b5 100644
--- a/getting_started/mix/3.markdown
+++ b/getting_started/mix/3.markdown
@@ -2,7 +2,7 @@
 layout: getting_started
 title: 3 Creating custom Mix tasks
 guide: 3
-total_guides: 3
+last: true
 ---
 
 # {{ page.title }}
@@ -44,9 +44,9 @@ Besides those two, there is also `@hidden` attribute that, when set to true, mar
 
 When writing tasks, there are some common mix functionality we would like to access. There is a gist:
 
-* `Mix.project` - Returns the project configuration under the function `project`; Notice this function returns an empty configuration if no `mix.exs` file exists in the current directory, allowing many Mix functions to work even if a `mix.exs` project is not defined;
+* `Mix.Project.config` - Returns the project configuration under the function `project`; Notice this function returns an empty configuration if no `mix.exs` file exists in the current directory, allowing many Mix functions to work even if a `mix.exs` project is not defined;
 
-* `Mix.Project.current` - Access the module for the current project, useful in case you want to access special functions in the project. It raises an exception if no project is defined;
+* `Mix.Project.get!` - Access the module for the current project, useful in case you want to access special functions in the project. It raises an exception if no project is defined;
 
 * `Mix.shell` - The shell is a simple abstraction for doing IO in Mix. Such abstractions make it easy to test existing mix tasks. In the future, the shell will provide conveniences for colored output and getting user input;
 
diff --git a/index.html b/index.html
index 40a89d256..e9343d85c 100644
--- a/index.html
+++ b/index.html
@@ -4,19 +4,18 @@
 ---
 
 <div class="hfeed">
-  <div class="hentry post">
+  <div class="hentry post no-border">
     <img src="/images/contents/home-code.png" alt="Elixir Sample" class="archive-thumbnail" />
 
     <div class="entry-summary">
-      <p>Elixir is a functional, meta-programming aware language built on top of the Erlang VM. It is a dynamic language with flexible syntax and macro support that leverages Erlang's abilities to build concurrent, distributed and fault-tolerant applications with hot code upgrades.</p>
-      <p>Elixir also provides first-class support for pattern matching, polymorphism via protocols (similar to Clojure's), aliases and associative data structures (usually known as dicts or hashes in other programming languages).</p>
-      <p>Finally, Elixir and Erlang share the same bytecode and data types. This means you can invoke Erlang code from Elixir (and vice-versa) without any conversion or performance hit. This allows a developer to mix the expressiveness of Elixir with the robustness and performance of Erlang.</p>
-      <p>To install Elixir or learn more about it, check our <a href="/getting_started/1.html">getting started guide</a>. We also have <a href="/docs.html">online documentation available</a> and a <a href="/crash-course.html">Crash Course for Erlang developers</a>.</p>
+      <p>Elixir is a functional, meta-programming aware language built on top of the Erlang VM. It is a dynamic language that focuses on tooling to leverage Erlang's abilities to build concurrent, distributed and fault-tolerant applications with hot code upgrades.</p>
+
+      <p>To install Elixir or learn more about it, check our <a href="/getting_started/1.html">getting started guide</a>. We also have <a href="/docs.html">online documentation available</a> and a <a href="/crash-course.html">Crash Course for Erlang developers</a>. Or you can just keep on reading for a few code samples!</p>
     </div>
   </div>
 
   <div class="hentry post">
-    <h3>Highlights</h3>
+    <h3>Language highlights</h3>
   </div>
 
   <div class="hentry post">
@@ -44,7 +43,7 @@ <h4>Everything is an expression</h4>
 Hello World
 </pre>
 
-      <p>This allows a module to be defined in terms of many expressions, programmable by the developer, being the basic foundation for meta-programming. This is similar to what Joe Armstrong (creator of Erlang) proposes in his <a href="https://github.com/joearms/erl2" target="_blank">erl2 project</a>.</p>
+      <p>This allows a module to be defined in terms of many expressions, programmable by the developer, being the basic foundation for meta-programming in Elixir.</p>
     </div>
   </div>
 
@@ -56,7 +55,7 @@ <h4>Meta-programming and DSLs</h4>
 
 {% highlight elixir %}
 defmodule MathTest do
-  use ExUnit.Case
+  use ExUnit.Case, async: true
 
   test "can add two numbers" do
     assert 1 + 1 == 2
@@ -68,26 +67,6 @@ <h4>Meta-programming and DSLs</h4>
     </div>
   </div>
 
-  <div class="hentry post">
-    <h4>Polymorphism via protocols</h4>
-
-    <div class="entry-summary">
-      <p>Protocols allow developers to provide type-specific functionality at chosen extension points. For example, the <code>Enum</code> module in Elixir is commonly used to iterate collections:</p>
-
-{% highlight elixir %}
-Enum.map([1,2,3], fn(x) -> x * 2 end) #=> [2,4,6]
-{% endhighlight %}
-
-      <p>Since the <code>Enum</code> module is built on top of protocols, it is not limited to the data types that ship with Elixir. A developer can use their own collections with <code>Enum</code> as long as they implement the <code>Enumerable</code> protocol. For example, a developer can use all the convenience of the <code>Enum</code> module to easily manipulate a file, line by line:</p>
-
-{% highlight elixir %}
-file  = File.stream!("README.md")
-lines = Enum.map(file, fn(line) -> Regex.replace(%r/"/, line, "'") end)
-File.write("README.md", lines)
-{% endhighlight %}
-    </div>
-  </div>
-
   <div class="hentry post">
     <h4>Documentation as first-class citizen</h4>
 
@@ -117,7 +96,27 @@ <h4>Documentation as first-class citizen</h4>
 
 {% endhighlight %}
 
-        <p>There is also a documentation generator for Elixir called <a href="https://github.com/elixir-lang/ex_doc">ExDoc</a> that can produce a static site using docstrings extracted from the source code.</p>
+      <p>Our test framework can also extract code samples from docstrings and guarantee the documentation is updated and correct! Finally, there is also a documentation generator for Elixir called <a href="https://github.com/elixir-lang/ex_doc">ExDoc</a> that can produce a static site using docstrings extracted from the source code.</p>
+    </div>
+  </div>
+
+  <div class="hentry post">
+    <h4>Tooling included</h4>
+
+    <div class="entry-summary">
+      <p>Elixir ships with a great set of tools to ease development. Mix allows you to easily create your new project, manage tasks, dependencies and more:</p>
+
+{% highlight text %}
+$ mix new my_app
+$ cd my_app
+$ mix test
+.
+
+Finished in 0.04 seconds (0.04s on load, 0.00s on tests)
+1 tests, 0 failures
+{% endhighlight %}
+
+      <p>In the example above, we have created a new project, compiled it and ran its initial test suite powered by the ExUnit test framework.</p>
     </div>
   </div>
 
@@ -131,7 +130,7 @@ <h4>Pattern matching</h4>
 { User, name, age } = User.get("John Doe")
 {% endhighlight %}
 
-      <p>When mixed with guards, pattern matching allows us to easily express our intent:</p>
+      <p>When mixed with guards, pattern matching allows us to elegantly match on the possible scenarios and express our intent accordingly:</p>
 
 {% highlight elixir %}
 def serve_drinks({ User, name, age }) when age < 21 do
@@ -148,11 +147,79 @@ <h4>Pattern matching</h4>
     </div>
   </div>
 
+  <div class="hentry post">
+    <h4>Lightweight concurrency</h4>
+    <div class="entry-summary">
+      <p>All Elixir code runs inside tiny processes that are isolated and exchange information via messages:</p>
+
+{% highlight elixir %}
+parent = self()
+
+# Spawn a child process
+spawn_link(fn ->
+  send parent, {:msg, "hello world"}
+end)
+
+# Block until the message is received
+receive do
+  {:msg, contents} -> IO.puts contents
+end
+{% endhighlight %}
+
+      <p>Since processes are lightweight and isolated, Elixir it is not uncommon to have dozens of thousands of processes running simultaneously. Proceses are provide the means for building distributed and fault-tolerant applications.</p>
+    </div>
+  </div>
+
+  <div class="hentry post">
+    <h4>Interactive (and remote) shells</h4>
+
+    <div class="entry-summary">
+      <p>Elixir also ships with an Interactive Shell, called IEx, which provides a great set of helpers for writing code, like easy access to documentation, code reloading, debugging and so on. It is also a great companion for production, as it allows for example connecting to remote nodes. Here is a quick example you can try locally. In one terminal, do:</p>
+
+{% highlight text %}
+$ iex --name hello
+iex(hello@machine)1> defmodule Hello do
+...(hello@machine)1>   def world, do: IO.puts "Distributed hello world"
+...(hello@machine)1> end
+{% endhighlight %}
+
+      <p>See the name in between parenthesis starting with hello? Copy that, open up another terminal and pass it to <code>--remsh</code> (short for remote shell):</p>
+
+{% highlight text %}
+$ iex --name world --remsh "hello@machine"
+iex(hello@machine)1> Hello.world
+"Distributed hello world"
+{% endhighlight %}
+
+      <p>Notice we were able to connect and invoke a function from a module defined in the other terminal! This will work in between machines in the same network as long as they have the same value in the <code>~/.erlang.cookie</code> file!</p>
+    </div>
+  </div>
+
+  <div class="hentry post">
+    <h4>Polymorphism via protocols</h4>
+
+    <div class="entry-summary">
+      <p>Protocols allow developers to provide type-specific functionality at chosen extension points. For example, the <code>Enum</code> module in Elixir is commonly used to enumerate collections:</p>
+
+{% highlight elixir %}
+Enum.map([1,2,3], fn(x) -> x * 2 end) #=> [2,4,6]
+{% endhighlight %}
+
+      <p>Since the <code>Enum</code> module is built on top of protocols, it is not limited to the data types that ship with Elixir. A developer can use their own collections with <code>Enum</code> as long as they implement the <code>Enumerable</code> protocol. For example, a developer can use all the convenience of the <code>Enum</code> module to easily manipulate a file, line by line:</p>
+
+{% highlight elixir %}
+file  = File.stream!("README.md")
+lines = Enum.map(file, fn(line) -> Regex.replace(~r/"/, line, "'") end)
+File.write("README.md", lines)
+{% endhighlight %}
+    </div>
+  </div>
+
   <div class="hentry post">
     <h4>Erlang all the way down</h4>
 
     <div class="entry-summary">
-      <p>After all, Elixir is still Erlang. An Elixir programmer can invoke any Erlang function with no runtime cost:</p>
+      <p>After all, Elixir runs in the Erlang VM. An Elixir programmer can invoke any Erlang function with no runtime cost:</p>
 
 {% highlight elixir %}
 :application.start(:crypto)
diff --git a/rebar b/rebar
new file mode 100755
index 000000000..f28a1d353
Binary files /dev/null and b/rebar differ
