Use "fenced blocks" on code

Instead of {% highlight erlang %} use ```erlang ```

And use iex to command line stuff

Author: edgurgel

_posts/2012-12-04-elixir-v0-7-2-released.markdown

@@ -14,7 +14,7 @@ the type specification syntax.
 
 Here's the gist:
 
-{% highlight elixir %}
+```elixir
 @spec myfun(integer), do: integer
 # becomes
 @spec myfun(integer) :: integer
@@ -34,7 +34,7 @@ Here's the gist:
 @type a :: fun(integer, integer, do: integer)
 # becomes
 @type a :: (integer, integer -> integer) or ((integer, integer) -> integer) or (fun(integer, integer) -> integer)
-{% endhighlight %}
+```
 
 Another change is that Mix now echoes the output of external tools
 such as git and rebar, and handles exit status correctly. This have previously
@@ -50,4 +50,4 @@ under some circunstances when using records.
 
 Lastly, but not least importantly, I'd like to mention that we're very excited about how the community around Elixir is building up. Thank you all for being around and supporting us!
 
-[Learn more about Elixir](/getting_started/1.html)!
+[Learn more about Elixir](/getting_started/1.html)!

_posts/2013-01-27-elixir-v0-8-0-released.markdown

@@ -24,9 +24,9 @@ We have written a whole [guide chapter about creating OTP applications, supervis
 
 Elixir favors the use of utf-8 binaries since its first release. In the latest releases, we took it up a notch by adding Unicode support, built upon the Unicode Standard 6.2.0. Elixir v0.8 takes this even further, adding more convenience functions and better support to named sequences:
 
-{% highlight elixir %}
+```elixir
 String.capitalize("fiN") #=> "Fin"
-{% endhighlight %}
+```
 
 The example above contains a string with only two codepoints, [the codepoint fi](http://www.fileformat.info/info/unicode/char/FB01/index.htm) and [the codepoint n](http://www.fileformat.info/info/unicode/char/006E/index.htm). Look how Elixir properly capitalizes the string, returning a new string made of three codepoints (all ascii letters).
 
@@ -36,35 +36,35 @@ Learn more about [Unicode support with the String module](http://elixir-lang.org
 
 As per this release, Elixir AST nodes can contain metadata. This metadata is compilation time only but may allow macros to annotate important information in AST nodes, like line numbers, file and other library specific information. If you quote an Elixir expression, we can see the metadata slot:
 
-{% highlight elixir %}
+```elixir
 quote do: hello("world")
 { :hello, [], ["world"] }
-{% endhighlight %}
+```
 
 In the example above, we can see the AST representation of the expression `hello("world")`. It is made of a tuple of three elements, the first one is the function name represented by the atom `:hello`, the second one is a keyword list containing metadata (in this case, no metadata is available) and the third is a list of arguments, containing the string "world".
 
 By default, `quote` does not annotate line numbers, but we can pass it as an option:
 
-{% highlight elixir %}
+```elixir
 quote line: __ENV__.line, do: hello("world")
 { :hello, [line: 9], ["world"] }
-{% endhighlight %}
+```
 
 Now, we can see the metadata spot being used to annotate the line number. This change allowed us to take our macros one step further...
 
 ## Macros expansion
 
-Prior to this release, Elixir had limited expansion of imports and aliases. We decided this would be an important issue to tackle in this release, as people are building more and more projects on top of Elixir. 
+Prior to this release, Elixir had limited expansion of imports and aliases. We decided this would be an important issue to tackle in this release, as people are building more and more projects on top of Elixir.
 
 Imagine you manually implemented `unless` as a macro, that does the opposite of `if`:
 
-{% highlight elixir %}
+```elixir
 defmacro unless(expr, opts) do
   quote do
     if(!unquote(expr), unquote(opts))
   end
 end
-{% endhighlight %}
+```
 
 When some code call the `unless` macro above, in previous Elixir versions, it would expect the `if` macro to be available at the caller. This may not be necessarily true and, even worse, another implementation of the `if` macro, not compatible to the one above, could be available.
 
@@ -93,11 +93,11 @@ For each number of keys, we have measured and normalized those values against `H
 `orddict` is still the faster representation for small ranges since it is a simple list. However, `HashDict` is able to be relatively fast compared to `orddict` for those small ranges and the fastest solution once you have dozens of keys. [Those results can be verified when using other types as keys as well](https://gist.github.com/436a9d2bca5051a6dfab).
 
 Finally, given `HashDict` starts with a compact representation, it also takes less memory. Compared to the `dict` implementation, an empty `HashDict` takes only 5 words, while `dict` takes 47.
- 
+
 ## Wrapping up
 
 We continue actively working on Elixir and this release is the [result of our efforts on different areas](https://github.com/elixir-lang/elixir/blob/v0.8.0/CHANGELOG.md)! We have exciting plans and newer possibilities to explore, as a new release of Erlang OTP also comes out in a couple weeks.
 
 Also, we previously announced Elixir is going to be released frequently, every 2 to 4 weeks. We have made a small detour to get v0.8.0 out of the door, but we are back to our regular schedule as of today!
 
-[Celebrate with us and give Elixir a try](/getting_started/1.html)!
+[Celebrate with us and give Elixir a try](/getting_started/1.html)!

_posts/2013-04-29-elixir-v0-8-2-released.markdown

@@ -16,7 +16,7 @@ We have also added colored output to Interactive Elixir (IEx) but it requires Er
 
 Finally, Elixir has always given special attention to documentation. You can easily document functions with the `@doc` attribute:
 
-{% highlight elixir %}
+```elixir
 defmodule Math do
   @doc """
   Add two numbers together.
@@ -31,18 +31,18 @@ defmodule Math do
     a + b
   end
 end
-{% endhighlight %}
+```
 
 The documentation above is embedded into the module and can be easily retrieved at runtime. For example, by typing `h Math.add/2` into Interactive Elixir, we can access the documentation for that module.
 
 Elixir v0.8.2 takes this to the next level by adding support to doctests. Given the example above, you can configure Elixir to automatically run the code samples in your documentation by including a call to the `doctest` macro in your test suite:
 
-{% highlight elixir %}
+```elixir
 defmodule MathTest do
   use ExUnit.Case, async: true
   doctest Math
 end
-{% endhighlight %}
+```
 
 You can learn more about [doctests on our documentation page](http://elixir-lang.org/docs/stable/ExUnit.DocTest.html) and get more information about our latest release [on the CHANGELOG](https://github.com/elixir-lang/elixir/blob/ed27611f48ba150404c95fe15f1d6058a4287330/CHANGELOG.md).
 

_posts/2013-05-23-elixir-v0-9-0-released.markdown

@@ -18,9 +18,9 @@ Let's talk about the goodies!
 
 We have spent some time improving compilation time. The particular scenario we have worked on was the definition of records:
 
-{% highlight elixir %}
+```elixir
 defrecord User, name: nil, age: nil
-{% endhighlight %}
+```
 
 Records are a good scenario because they are implemented in Elixir, using Elixir macros, and they also define a module underneath, which exercises the Erlang VM compilation stack.
 
@@ -52,10 +52,10 @@ A special thanks to [Eric Meadows-Jonsson](https://github.com/ericmj) for implem
 
 Elixir v0.9.0 changes its main abstraction for enumeration from iterators to reducers. Before Elixir v0.9.0, when you invoked:
 
-{% highlight elixir %}
+```elixir
 Enum.map([1,2,3], fn(x) -> x * x end)
 #=> [1, 4, 9]
-{% endhighlight %}
+```
 
 It asked the `Enum.Iterator` protocol for instructions on how to iterate the list `[1,2,3]`. This iteration happened by retrieving each item in the list, one by one, until there were no items left.
 
@@ -69,7 +69,7 @@ Reducers solve all of those problems by using a more functional approach. Instea
 
 Here is how we implement the `Enumerable` protocol for lists:
 
-{% highlight elixir %}
+```elixir
 defimpl Enumerable, for: List do
   def reduce(list, acc, fun) do
     do_reduce(list, acc, fun)
@@ -83,27 +83,27 @@ defimpl Enumerable, for: List do
     acc
   end
 end
-{% endhighlight %}
+```
 
 The implementation above works as a simple `reduce` function (also called `fold`, `inject` or `foldl` in other languages). Here is how it works:
 
-{% highlight elixir %}
+```elixir
 # Sum all elements in a list
 Enumerable.reduce([1,2,3], 0, fn(x, acc) -> x + acc end)
 #=> 6
-{% endhighlight %}
+```
 
 The `Enum.map/2` we have used above is now implemented in terms of this reducing function:
 
-{% highlight elixir %}
+```elixir
 defmodule Enum do
   def map(collection, fun) do
     Enumerable.reduce(collection, [], fn(x, acc) ->
       [fun.(x, acc)|acc]
     end) |> reverse
   end
 end
-{% endhighlight %}
+```
 
 This approach solves all the problems above:
 

_posts/2013-07-13-elixir-v0-10-0-released.markdown

@@ -12,47 +12,47 @@ Elixir v0.10.0 is released with support for streams, sets and many improvements
 
 The default mechanism for working with collections in Elixir is the `Enum` module. With it, you can map over ranges, lists, sets, dictionaries and any other structure as long as it implements the `Enumerable` protocol:
 
-{% highlight elixir %}
+```elixir
 Enum.map([1,2,3], fn(x) -> x * 2 end)
 #=> [2,4,6]
-{% endhighlight %}
+```
 
 The `Enum` module performs eager evaluation. Consider the following example:
 
-{% highlight elixir %}
+```elixir
 [1,2,3]
   |> Enum.take_while(fn(x) -> x < 3 end)
   |> Enum.map(fn(x) -> x * 2 end)
 #=> [2,4]
-{% endhighlight %}
+```
 
 In the example above, we enumerate the items in list once, taking all elements that are less than 3, and then we enumerate the remaining elements again, multiplying them by two. In order to retrieve the final result, we have created one intermediate list. As we add more operations, more intermediate lists will be generated.
 
 This approach is simple and efficient for the majority of the cases but, when working with large collections, we can generate many, possibly large, intermediate lists affecting performance. That's one of the problems Streams solve. Let's rewrite the example above using Streams:
 
-{% highlight elixir %}
+```elixir
 [1,2,3]
   |> Stream.take_while(fn(x) -> x < 3 end)
   |> Stream.map(fn(x) -> x * 2 end)
 #=> #Stream.Lazy<...>
-{% endhighlight %}
+```
 
 Now, instead of getting the result back, we got a Stream. The list elements are yet to be enumerated! We can realize the stream  by calling any of the Enum functions, like `Enum.to_list/1`. By doing so the list will be iterated just once avoiding the intermediary representations.
 
 In a nutshell, Streams are composable, lazy enumerables. Streams are also useful when doing IO or expressing infinite computations. We can retrieve a file as a stream:
 
-{% highlight elixir %}
+```elixir
 File.stream!("README.md")
-{% endhighlight %}
+```
 
 In the example above, we got a stream that will enumerate the lines in the file one by one when enumerated. We could further extend the stream above, for example, by rejecting blank lines, and the file will be opened just when its results are actually needed.
 
 Do you need a random number generator? We got your back:
 
-{% highlight elixir %}
+```elixir
 Stream.repeatedly(fn -> :random.uniform end) |> Enum.take(3)
 #=> [0.4435846174457203, 0.7230402056221108, 0.94581636451987]
-{% endhighlight %}
+```
 
 `Stream.repeatedly/1` returns an infinite stream but that's ok we just need its first three elements. You can learn more about [stream and related functions in `Stream` module documentation](http://elixir-lang.org/docs/stable/Stream.html).