Fix typos (#1589)

Author: kianmeng

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

@@ -44,7 +44,7 @@ We've also added a more compact and visual form of the `function` helper. Now,
 instead of `function(Enum, :all?, 2)` you can use `function(Enum.all?/2)`.
 
 We've also figured out how to achieve an up to 6x [performance increase](https://github.com/elixir-lang/elixir/blob/v0.7.2/lib/elixir/lib/kernel.ex#L1386-L1417)
-under some circunstances when using records.
+under some circumstances when using records.
 
 ...and [many other fixes & improvements](https://github.com/elixir-lang/elixir/blob/v0.7.2/CHANGELOG.md).
 

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

@@ -74,7 +74,7 @@ You can read more about [macros in the getting started guide](/getting-started/c
 
 ## A new way to manipulate pathnames
 
-Elixir v0.8 contains a bit of house cleaning too. We have created [the Path module](https://hexdocs.pm/elixir/Path.html) to accommodate functions used to manipulate filesystem paths and have also added functions like [`System.tmp_dir` and `System.user_home`](https://hexdocs.pm/elixir/System.html) which are meant to work accross different operating systems and are very handy when scripting.
+Elixir v0.8 contains a bit of house cleaning too. We have created [the Path module](https://hexdocs.pm/elixir/Path.html) to accommodate functions used to manipulate filesystem paths and have also added functions like [`System.tmp_dir` and `System.user_home`](https://hexdocs.pm/elixir/System.html) which are meant to work across different operating systems and are very handy when scripting.
 
 ## The new HashDict
 

_posts/2013-05-02-elixir-on-xen.markdown

@@ -12,7 +12,7 @@ Elixir uses Erlang underneath, all the way down. Thanks to this, an Elixir proje
 
 [Xen](https://en.wikipedia.org/wiki/Xen) is an open-source baremetal hypervisor that allows many operating systems to run on the same hardware. Xen is frequently used for server virtualization, Infrastructure as a Service (IaaS) and security applications.
 
-Elixir on Xen runs on top of the Xen Hypervisor (via the LING VM) but with no traditional OS underneath it, taking away numerous administrative, scalability, and performance issues. This  limits options of a malicious attacker, making it an excellent choice for high-security applications, and reduces startup latency, allowing developers to spawn new VMs in less than 100 miliseconds.
+Elixir on Xen runs on top of the Xen Hypervisor (via the LING VM) but with no traditional OS underneath it, taking away numerous administrative, scalability, and performance issues. This  limits options of a malicious attacker, making it an excellent choice for high-security applications, and reduces startup latency, allowing developers to spawn new VMs in less than 100 milliseconds.
 
 You can learn more about Xen and the LING VM on the [Erlang on Xen website](http://erlangonxen.org).
 

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

@@ -123,7 +123,7 @@ A special thanks to [Eric Meadows-Jonsson](https://github.com/ericmj) for implem
 We have also many other smaller improvements:
 
 * Our CLI now supports `--hidden` and `--cookie` flags which are useful for distributed modes;
-* Our test framework, ExUnit, is now able to capture all the communication that happens with a registed IO device, like `:stdio` and `:stderr`, via [`ExUnit.CaptureIO`](https://hexdocs.pm/ex_unit/ExUnit.CaptureIO.html). This is very useful for testing how your software reacts to some inputs and what it prints to the terminal;
+* Our test framework, ExUnit, is now able to capture all the communication that happens with a registered IO device, like `:stdio` and `:stderr`, via [`ExUnit.CaptureIO`](https://hexdocs.pm/ex_unit/ExUnit.CaptureIO.html). This is very useful for testing how your software reacts to some inputs and what it prints to the terminal;
 * `IEx` now allows files to be imported into the shell with `import_file` and also loads `~/.iex` on startup for custom configuration;
 * The `String`, `Enum` and `Dict` modules got more convenience functions that goes from checking unicode character validity to taking values out of a dictionary;
 * And many, many more!

_posts/2013-08-08-elixir-design-goals.markdown

@@ -208,7 +208,7 @@ There are many other protocols exposed by the language, like [the `Inspect` prot
 
 ## Summing up
 
-The goal of this post was to sumarize the language goals: compatibility, productivity and extensibility. By being compatibile with the Erlang VM, we are providing developers another toolset for building concurrent, distributed and fault-tolerant systems.
+The goal of this post was to sumarize the language goals: compatibility, productivity and extensibility. By being compatible with the Erlang VM, we are providing developers another toolset for building concurrent, distributed and fault-tolerant systems.
 
 We also hope to have clarified what Elixir brings to the Erlang VM, in particular, meta-programming through macros, polymorphic constructs for extensibility and a data-focused standard library with extensible and consistent APIs for diverse types, including strict and lazy enumeration, unicode handling, a test framework and more.
 

_posts/2014-04-21-elixir-v0-13-0-released.markdown

@@ -3,7 +3,7 @@ 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!"
+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 announcement of ElixirConf!"
 ---
 
 Hello folks!
@@ -187,7 +187,7 @@ With the introduction of maps and structs, some deprecations will arrive on upco
 
 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](https://hexdocs.pm/elixir/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).
+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 available](https://gist.github.com/josevalim/b30c881df36801611d13).
 
 ## Comprehensions
 
@@ -248,7 +248,7 @@ $ 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:
+In Elixir v0.13, `mix deps.get` only fetches dependencies and it does so across all environments (unless an `--only` flag is specified). To support this new behaviour, dependencies now support the `:only` option:
 
 ```elixir
 def deps do

_posts/2016-07-14-announcing-genstage.markdown

@@ -350,7 +350,7 @@ File.stream!("path/to/some/file", read_ahead: 100_000) # NEW!
 |> Enum.to_list()
 ```
 
-Flow will look at the computations we want to perform and start a series of stages to execute our code while keeping the amount of data being transfered between processes to a minimum. If you are interested in `GenStage.Flow` and how the computations above are spread across multiple stages, [we have written some documentation based on the prototypes we have built so far](https://hexdocs.pm/gen_stage/Experimental.Flow.html). The code itself is coming in future GenStage releases. We will also have to consider how the `GenStage.Flow` API mirrors the functions in `Enum` and `Stream` to make the path from eager to concurrent clearer.
+Flow will look at the computations we want to perform and start a series of stages to execute our code while keeping the amount of data being transferred between processes to a minimum. If you are interested in `GenStage.Flow` and how the computations above are spread across multiple stages, [we have written some documentation based on the prototypes we have built so far](https://hexdocs.pm/gen_stage/Experimental.Flow.html). The code itself is coming in future GenStage releases. We will also have to consider how the `GenStage.Flow` API mirrors the functions in `Enum` and `Stream` to make the path from eager to concurrent clearer.
 
 For the word counting problem with a fixed data, early experiments show a linear increase in performance with a fixed overhead of 20%. In other words, a dataset that takes 60s with a single core, takes 36s on a machine with 2 cores and 18s in one with 4 cores. All of those gains by simply moving your computations from streams to Flow. We plan to benchmark on machines with over 40 cores soon.
 

_posts/2017-10-31-stream-data-property-based-testing-and-data-generation-for-elixir.markdown

@@ -27,7 +27,7 @@ Enum.take(generator, 5)
 #=> [0, 1, 3, 3, 2]
 ```
 
-`StreamData.map/2` is encouraged over `Stream.map/2` because generators return values that can shrink, which is something property-based testing takes advantage of as we'll see later on. When treated as enumerables, generators return normal values that cannot be shrinked.
+`StreamData.map/2` is encouraged over `Stream.map/2` because generators return values that can shrink, which is something property-based testing takes advantage of as we'll see later on. When treated as enumerables, generators return normal values that cannot be shrunk.
 
 We decided to separate data-generation from property-based testing because it's something that developers can take advantage of in situations outside of property-based testing. For example, data streams can be used to seed a database or to have randomly generated data available during regular tests.
 

_posts/2018-07-25-elixir-v1-7-0-released.markdown

@@ -113,7 +113,7 @@ The `assert` macro is able to look at the code, extract the current file, the li
 
 However, sometimes we need to write assertions such as `assert some_function(expr1, var2)`. When such assertion fails, we usually have to re-run the tests, now debugging or printing the values of `expr1` and `var2`. In Elixir v1.7, when a "bare" assertion fails, we will print the value of each argument individually. For a simple example such as `assert some_vars(1 + 2, 3 + 4)`, we get this report:
 
-![ExUnit Bare Asssertion Diff](/images/contents/exunit-bare-assertion-diff.png)
+![ExUnit Bare Assertion Diff](/images/contents/exunit-bare-assertion-diff.png)
 
 We have also [added coloring and diffing to doctests](https://hexdocs.pm/ex_unit/ExUnit.DocTest.html#content).
 

_posts/2019-02-25-mint-a-new-http-library-for-elixir.markdown

@@ -60,7 +60,7 @@ Of course, none of this stops you from building a connection pool on top of Mint
 
 ## HTTP/1 and HTTP/2
 
-The `Mint.HTTP` module has a single interface for both HTTP/1 and HTTP/2 connections and performs version negotation on HTTPS connections, HTTP connections default to HTTP/1. You can specify which HTTP version you want to use or use the `Mint.HTTP1` or `Mint.HTTP2` modules directly if you want to use version-specific features.
+The `Mint.HTTP` module has a single interface for both HTTP/1 and HTTP/2 connections and performs version negotiation on HTTPS connections, HTTP connections default to HTTP/1. You can specify which HTTP version you want to use or use the `Mint.HTTP1` or `Mint.HTTP2` modules directly if you want to use version-specific features.
 
 ## Safe-by-default HTTPS
 

_posts/2020-01-27-elixir-v1-10-0-released.markdown

@@ -118,7 +118,7 @@ While this is the preferred approach, there are still two scenarios we need to a
 
   1. Not everyone may be aware of this pitfall, so they will mistakenly read the application environment at compile-time, until they are bitten by this behaviour
 
-  2. In rare occasions, you trully need to read the application environment at compile-time, and you want to be warned when you try to configure at runtime something that is valid only at compilation time
+  2. In rare occasions, you truly need to read the application environment at compile-time, and you want to be warned when you try to configure at runtime something that is valid only at compilation time
 
 Elixir v1.10 aims to solve these two scenarios by introducing a `Application.compile_env/3` function. For example, to read the value at compile time, you can now do:
 

_posts/2021-12-03-elixir-v1-13-0-released.markdown

@@ -39,7 +39,7 @@ In a nutshell, Elixir went from triggering full recompilations whenever any of `
 
 To give a more practical example, take a regular [Phoenix project](https://phoenixframework.org/). It is most likely divided in two main directories: `my_app` and `my_app_web`. Most of your usage of Phoenix' APIs will happen within the files in the `my_app_web` directory. However, if you bumped your Phoenix version or changed its configuration in previous Elixir versions, it would cause all files, in both directories, to be recompiled. With these changes, the recompilation should affect mostly the files in `my_app_web`.
 
-> To futher clarify, the Elixir compiler is not tracking directories. It is just a consequence of how Phoenix projects are organized that most dependencies to Phoenix are within `my_app_web`.
+> To further clarify, the Elixir compiler is not tracking directories. It is just a consequence of how Phoenix projects are organized that most dependencies to Phoenix are within `my_app_web`.
 
 ## Code fragments
 

downloads/cheatsheets/gen-server.tex

@@ -15,7 +15,7 @@
 \tikzset{normal border/.style={orange!30!black!10}}
 
 % Macro to draw the shape behind the text, when it fits
-% completly in the page
+% completely in the page
 \def\parchmentframe#1{
 \tikz{
   \node[inner sep=2em] (A) {#1};  % Draw the text of the node

getting-started/basic-types.markdown

@@ -261,7 +261,7 @@ iex> is_function(add, 1)
 false
 ```
 
-Finally, anonymous functions can also access variables that are in scope when the function is defined. This is typically refered to as closures, as they close over their scope. Let's define a new anonymous function that uses the `add` anonymous function we have previously defined:
+Finally, anonymous functions can also access variables that are in scope when the function is defined. This is typically referred to as closures, as they close over their scope. Let's define a new anonymous function that uses the `add` anonymous function we have previously defined:
 
 ```elixir
 iex> double = fn a -> add.(a, a) end

getting-started/mix-otp/distributed-tasks.markdown

@@ -296,7 +296,7 @@ defp lookup(bucket, callback) do
 end
 ```
 
-Good! Now `GET`, `PUT` and `DELETE` requests are all routed to the approriate node. Let's also make sure that when a new bucket is created it ends up on the correct node. Replace the `run/1` function in `KVServer.Command`, the one that matches the `:create` command, with the following:
+Good! Now `GET`, `PUT` and `DELETE` requests are all routed to the appropriate node. Let's also make sure that when a new bucket is created it ends up on the correct node. Replace the `run/1` function in `KVServer.Command`, the one that matches the `:create` command, with the following:
 
 ```elixir
 def run({:create, bucket}) do