- {{ page.category | default: "Getting Started" }}
-
-
- {% include toc.html %}
-
- {{ content }}
-
- {% unless forloop.first %}
- ← Previous
- {% endunless %}
- Top
- {% unless forloop.last %}
- {% assign next = guide.pages[forloop.index] %}
- Next →
- {% endunless %}
-
- {% endif %}
- {% assign prev = node %}
- {% endfor %}
- {% endif %}
- {% endfor %}
-
-
- Is something wrong?
-
- Edit this page on GitHub.
-
-
-
-
-## Observer
-
-For debugging complex systems, jumping at the code is not enough. It is necessary to have an understanding of the whole virtual machine, processes, applications, as well as set up tracing mechanisms. Luckily this can be achieved in Erlang with `:observer`. In your application:
-
-```elixir
-$ iex
-iex> :observer.start()
-```
-
-> Similar to the `debugger` note above, your package manager may require a separate installation in order to run Observer.
-
-The above will open another Graphical User Interface that provides many panes to fully understand and navigate the runtime and your project:
-
-
-
-We explore the Observer in the context of an actual project [in the Dynamic Supervisor chapter of the Mix & OTP guide](/getting-started/mix-otp/dynamic-supervisor.html). This is one of the debugging techniques [the Phoenix framework used to achieve 2 million connections on a single machine](https://phoenixframework.org/blog/the-road-to-2-million-websocket-connections).
-
-If you are using the Phoenix web framework, it ships with the [Phoenix LiveDashboard](https://github.com/phoenixframework/phoenix_live_dashboard), a web dashboard for production nodes which provides similar features to Observer.
-
-Finally, remember you can also get a mini-overview of the runtime info by calling `runtime_info/0` directly in IEx.
-
-## Other tools and community
-
-We have just scratched the surface of what the Erlang VM has to offer, for example:
-
- * Alongside the observer application, Erlang also includes a `:crashdump_viewer` to view crash dumps
-
- * Integration with OS level tracers, such as [Linux Trace Toolkit,](http://www.erlang.org/doc/apps/runtime_tools/LTTng.html) [DTRACE,](http://www.erlang.org/doc/apps/runtime_tools/DTRACE.html) and [SystemTap](http://www.erlang.org/doc/apps/runtime_tools/SYSTEMTAP.html)
-
- * [Microstate accounting](http://www.erlang.org/doc/man/msacc.html) measures how much time the runtime spends in several low-level tasks in a short time interval
-
- * Mix ships with many tasks under the `profile` namespace, such as `cprof` and `fprof`
-
- * For more advanced use cases, we recommend the excellent [Erlang in Anger](https://www.erlang-in-anger.com/), which is available as a free ebook
-
-Happy debugging!
diff --git a/getting-started/enumerables-and-streams.markdown b/getting-started/enumerables-and-streams.markdown
index 7e1b18d19..b6abedae7 100644
--- a/getting-started/enumerables-and-streams.markdown
+++ b/getting-started/enumerables-and-streams.markdown
@@ -1,126 +1,5 @@
---
-section: getting-started
-layout: getting-started
-title: Enumerables and Streams
+layout: redirect
+sitemap: false
+redirect_to: enumerable-and-streams
---
-
-## Enumerables
-
-Elixir provides the concept of enumerables and [the `Enum` module](https://hexdocs.pm/elixir/Enum.html) to work with them. We have already learned two enumerables: lists and maps.
-
-```elixir
-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:
-
-```elixir
-iex> Enum.map(1..3, fn x -> x * 2 end)
-[2, 4, 6]
-iex> Enum.reduce(1..3, 0, &+/2)
-6
-```
-
-The functions in the Enum module are limited to, as the name says, enumerating values in data structures. For specific operations, like inserting and updating particular elements, you may need to reach for modules specific to the data type. 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](https://hexdocs.pm/elixir/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](https://hexdocs.pm/elixir/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 a stream.
-
-## Eager vs Lazy
-
-All the functions in the `Enum` module are eager. Many functions expect an enumerable and return a list back:
-
-```elixir
-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:
-
-```elixir
-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.
-
-## The pipe operator
-
-The `|>` symbol used in the snippet above is the **pipe operator**: it takes the output from the expression on its left side and passes it as the first argument to the function call on its right side. It's similar to the Unix `|` operator. Its purpose is to highlight the data being transformed by a series of functions. To see how it can make the code cleaner, have a look at the example above rewritten without using the `|>` operator:
-
-```elixir
-iex> Enum.sum(Enum.filter(Enum.map(1..100_000, &(&1 * 3)), odd?))
-7500000000
-```
-
-Find more about the pipe operator [by reading its documentation](https://hexdocs.pm/elixir/Kernel.html#%7C%3E/2).
-
-## Streams
-
-As an alternative to `Enum`, Elixir provides [the `Stream` module](https://hexdocs.pm/elixir/Stream.html) which supports lazy operations:
-
-```elixir
-iex> 1..100_000 |> Stream.map(&(&1 * 3)) |> Stream.filter(odd?) |> Enum.sum
-7500000000
-```
-
-Streams are lazy, composable enumerables.
-
-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`:
-
-```elixir
-iex> 1..100_000 |> Stream.map(&(&1 * 3))
-#Stream<[enum: 1..100000, funs: [#Function<34.16982430/1 in Stream.map/2>]]>
-```
-
-Furthermore, they are composable because we can pipe many stream operations:
-
-```elixir
-iex> 1..100_000 |> Stream.map(&(&1 * 3)) |> Stream.filter(odd?)
-#Stream<[enum: 1..100000, funs: [...]]>
-```
-
-Instead of generating intermediate lists, streams build a series of computations that are invoked only when we pass the underlying stream to the `Enum` module. Streams are useful when working with large, *possibly infinite*, collections.
-
-Many functions in the `Stream` module accept any enumerable as an argument and return a stream as a result. It also provides functions for creating streams. 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:
-
-```elixir
-iex> stream = Stream.cycle([1, 2, 3])
-#Function<15.16982430/2 in Stream.unfold/2>
-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:
-
-```elixir
-iex> stream = Stream.unfold("hełło", &String.next_codepoint/1)
-#Function<39.75994740/2 in Stream.unfold/2>
-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 the case of failures. For example, `File.stream!/1` builds on top of `Stream.resource/3` to stream files:
-
-```elixir
-iex> stream = File.stream!("path/to/file")
-%File.Stream{
- line_or_bytes: :line,
- modes: [:raw, :read_ahead, :binary],
- path: "path/to/file",
- raw: true
-}
-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 functionality in the [`Enum`](https://hexdocs.pm/elixir/Enum.html) and [`Stream`](https://hexdocs.pm/elixir/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/erlang-libraries.markdown b/getting-started/erlang-libraries.markdown
index 5719d9175..8af923cc7 100644
--- a/getting-started/erlang-libraries.markdown
+++ b/getting-started/erlang-libraries.markdown
@@ -1,208 +1,5 @@
---
-section: getting-started
-layout: getting-started
-title: Erlang libraries
+layout: redirect
+sitemap: false
+redirect_to: erlang-libraries
---
-
-Elixir provides excellent interoperability with Erlang libraries. In fact,
-Elixir discourages simply wrapping Erlang libraries in favor of directly
-interfacing with Erlang code. In this section, we will present some of the
-most common and useful Erlang functionality that is not found in Elixir.
-
-As you grow more proficient in Elixir, you may want to explore the Erlang
-[STDLIB Reference Manual](http://www.erlang.org/doc/apps/stdlib/index.html) in more
-detail.
-
-## The binary module
-
-The built-in Elixir String module handles binaries that are UTF-8 encoded.
-[The binary module](http://www.erlang.org/doc/man/binary.html) is useful when
-you are dealing with binary data that is not necessarily UTF-8 encoded.
-
-```elixir
-iex> String.to_charlist "Ø"
-[216]
-iex> :binary.bin_to_list "Ø"
-[195, 152]
-```
-
-The above example shows the difference; the `String` module returns Unicode
-codepoints, while `:binary` deals with raw data bytes.
-
-## Formatted text output
-
-Elixir does not contain a function similar to `printf` found in C and other
-languages. Luckily, the Erlang standard library functions `:io.format/2` and
-`:io_lib.format/2` may be used. The first formats to terminal output, while
-the second formats to an iolist. The format specifiers differ from `printf`,
-[refer to the Erlang documentation for details](http://www.erlang.org/doc/man/io.html#format-1).
-
-```elixir
-iex> :io.format("Pi is approximately given by:~10.3f~n", [:math.pi])
-Pi is approximately given by: 3.142
-:ok
-iex> to_string :io_lib.format("Pi is approximately given by:~10.3f~n", [:math.pi])
-"Pi is approximately given by: 3.142\n"
-```
-
-Also note that Erlang's formatting functions require special attention to
-Unicode handling.
-
-## The crypto module
-
-[The crypto module](http://www.erlang.org/doc/man/crypto.html) contains hashing
-functions, digital signatures, encryption and more:
-
-```elixir
-iex> Base.encode16(:crypto.hash(:sha256, "Elixir"))
-"3315715A7A3AD57428298676C5AE465DADA38D951BDFAC9348A8A31E9C7401CB"
-```
-
-The `:crypto` module is part of the `:crypto` application that ships with
-Erlang. This means you must list the `:crypto` application as an additional
-application in your project configuration. To do this, edit your `mix.exs`
-file to include:
-
-```elixir
-def application do
- [extra_applications: [:crypto]]
-end
-```
-
-Any module that is not part of the `:kernel` or `:stdlib` Erlang applications
-must have their application explicitly listed in your `mix.exs`. You can find
-the application name of any Erlang module in the Erlang documentation, immediately
-below the Erlang logo in the sidebar.
-
-## The digraph module
-
-[The digraph module](http://www.erlang.org/doc/man/digraph.html) (as well as
-[digraph_utils](http://www.erlang.org/doc/man/digraph_utils.html)) contains
-functions for dealing with directed graphs built of vertices and edges.
-After constructing the graph, the algorithms in there will help find,
-for instance, the shortest path between two vertices, or loops in the graph.
-
-Given three vertices, find the shortest path from the first to the last.
-
-```elixir
-iex> digraph = :digraph.new()
-iex> coords = [{0.0, 0.0}, {1.0, 0.0}, {1.0, 1.0}]
-iex> [v0, v1, v2] = (for c <- coords, do: :digraph.add_vertex(digraph, c))
-iex> :digraph.add_edge(digraph, v0, v1)
-iex> :digraph.add_edge(digraph, v1, v2)
-iex> :digraph.get_short_path(digraph, v0, v2)
-[{0.0, 0.0}, {1.0, 0.0}, {1.0, 1.0}]
-```
-
-Note that the functions in `:digraph` alter the graph structure in-place, this
-is possible because they are implemented as ETS tables, explained next.
-
-## Erlang Term Storage
-
-The modules [`ets`](http://www.erlang.org/doc/man/ets.html) and
-[`dets`](http://www.erlang.org/doc/man/dets.html) handle storage of large
-data structures in memory or on disk respectively.
-
-ETS lets you create a table containing tuples. By default, ETS tables
-are protected, which means only the owner process may write to the table
-but any other process can read. ETS has some functionality to allow a
-table to be used as a simple database, a key-value store or as a cache
-mechanism.
-
-The functions in the `ets` module will modify the state of the table as a
-side-effect.
-
-```elixir
-iex> table = :ets.new(:ets_test, [])
-# Store as tuples with {name, population}
-iex> :ets.insert(table, {"China", 1_374_000_000})
-iex> :ets.insert(table, {"India", 1_284_000_000})
-iex> :ets.insert(table, {"USA", 322_000_000})
-iex> :ets.i(table)
-<1 > {<<"India">>,1284000000}
-<2 > {<<"USA">>,322000000}
-<3 > {<<"China">>,1374000000}
-```
-
-## The math module
-
-[The `math` module](http://www.erlang.org/doc/man/math.html) contains common
-mathematical operations covering trigonometry, exponential, and logarithmic
-functions.
-
-```elixir
-iex> angle_45_deg = :math.pi() * 45.0 / 180.0
-iex> :math.sin(angle_45_deg)
-0.7071067811865475
-iex> :math.exp(55.0)
-7.694785265142018e23
-iex> :math.log(7.694785265142018e23)
-55.0
-```
-
-## The queue module
-
-The [`queue` is a data structure](http://www.erlang.org/doc/man/queue.html)
-that implements (double-ended) FIFO (first-in first-out) queues efficiently:
-
-```elixir
-iex> q = :queue.new
-iex> q = :queue.in("A", q)
-iex> q = :queue.in("B", q)
-iex> {value, q} = :queue.out(q)
-iex> value
-{:value, "A"}
-iex> {value, q} = :queue.out(q)
-iex> value
-{:value, "B"}
-iex> {value, q} = :queue.out(q)
-iex> value
-:empty
-```
-
-## The rand module
-
-[`rand` has functions](http://www.erlang.org/doc/man/rand.html) for returning
-random values and setting the random seed.
-
-```elixir
-iex> :rand.uniform()
-0.8175669086010815
-iex> _ = :rand.seed(:exs1024, {123, 123534, 345345})
-iex> :rand.uniform()
-0.5820506340260994
-iex> :rand.uniform(6)
-6
-```
-
-## The zip and zlib modules
-
-[The `zip` module](http://www.erlang.org/doc/man/zip.html) lets you read and write
-ZIP files to and from disk or memory, as well as extracting file information.
-
-This code counts the number of files in a ZIP file:
-
-```elixir
-iex> :zip.foldl(fn _, _, _, acc -> acc + 1 end, 0, :binary.bin_to_list("file.zip"))
-{:ok, 633}
-```
-
-[The `zlib` module](http://www.erlang.org/doc/man/zlib.html) deals with data compression in zlib format, as found in the
-`gzip` command.
-
-```elixir
-iex> song = "
-...> Mary had a little lamb,
-...> His fleece was white as snow,
-...> And everywhere that Mary went,
-...> The lamb was sure to go."
-iex> compressed = :zlib.compress(song)
-iex> byte_size song
-110
-iex> byte_size compressed
-99
-iex> :zlib.uncompress(compressed)
-"\nMary had a little lamb,\nHis fleece was white as snow,\nAnd everywhere that Mary went,\nThe lamb was sure to go."
-```
-
-Now let's take a look at existing Elixir (and Erlang) libraries you might use while debugging.
\ No newline at end of file
diff --git a/getting-started/index.html b/getting-started/index.html
index a5a74f690..c50365d75 100644
--- a/getting-started/index.html
+++ b/getting-started/index.html
@@ -1,7 +1,5 @@
-
-
-
- 
+
+
