diff --git a/es/overviews/core/actors.md b/es/overviews/core/actors.md
index 26aa06952a..35fe834caa 100644
--- a/es/overviews/core/actors.md
+++ b/es/overviews/core/actors.md
@@ -113,7 +113,7 @@ El trait `ReplyReactor` extiende `Reactor[Any]` y sobrescribe y/o añade los sig
   vez se encuentre disponible; asimismo puede ser utilizada para comprobar si la respuesta
   está disponible sin la necesidad de bloquear el emisor. Existen dos versiones sobrecargadas.
   La versión que acepta dos parámetros recibe un argumento adicional de tipo
-  `PartialFuntion[Any, A]`. Esta función parcial es utilizada para realizar el post-procesado de
+  `PartialFunction[Any, A]`. Esta función parcial es utilizada para realizar el post-procesado de
   la respuesta del receptor. Básicamente, `!!` retorna un "future" que aplicará la anterior
   función parcial a la repuesta (una vez recibida). El resultado del "future" es el resultado
   de este post-procesado.
diff --git a/es/overviews/parallel-collections/custom-parallel-collections.md b/es/overviews/parallel-collections/custom-parallel-collections.md
index 1cec548eee..917280f9a2 100644
--- a/es/overviews/parallel-collections/custom-parallel-collections.md
+++ b/es/overviews/parallel-collections/custom-parallel-collections.md
@@ -151,7 +151,7 @@ string by appending all the string builders together. This way, elements are
 copied only once at the end instead of being copied every time `combine` is
 called. Ideally, we would like to parallelize this process and copy them in
 parallel (this is being done for parallel arrays), but without tapping into
-the internal represenation of strings this is the best we can do-- we have to
+the internal representation of strings this is the best we can do-- we have to
 live with this sequential bottleneck.
 
     private class ParStringCombiner extends Combiner[Char, ParString] {
@@ -206,7 +206,7 @@ ropes and various heaps are particularly suitable for such an approach.
 parallel hash tables, it assumes the elements can be efficiently
 partially sorted into concatenable buckets from which the final
 data-structure can be constructed in parallel. In the first phase
-different procesors populate these buckets independently and
+different processors populate these buckets independently and
 concatenate the buckets together. In the second phase, the data
 structure is allocated and different processors populate different
 parts of the datastructure in parallel using elements from disjoint
diff --git a/ko/tutorials/scala-for-java-programmers.md b/ko/tutorials/scala-for-java-programmers.md
index c4675d2514..37577d5258 100644
--- a/ko/tutorials/scala-for-java-programmers.md
+++ b/ko/tutorials/scala-for-java-programmers.md
@@ -677,6 +677,6 @@ Scala는 이 문제를 해결하기 위한 제네릭 클래스와 제네릭 함
 
 우리는 지금까지 Scala 언어의 간략한 소개와 몇가지의 예제를 살펴
 보았다. 흥미가 생겼다면 *Scala By Example*도 함께 읽어보자. 더 수준
-높고 다양한 예제를 만날 수 있다. 필요 할 때마다 *Scala Langauge
+높고 다양한 예제를 만날 수 있다. 필요 할 때마다 *Scala Language
 Specification*을 참고하는 것도 좋다.
 
diff --git a/overviews/core/_posts/2010-11-30-actors.md b/overviews/core/_posts/2010-11-30-actors.md
index 98df5726f8..0913d7f057 100644
--- a/overviews/core/_posts/2010-11-30-actors.md
+++ b/overviews/core/_posts/2010-11-30-actors.md
@@ -227,7 +227,7 @@ return, we can use `andThen` to register the code which prints the
 greeting as the actor's continuation.
 
 Note that there is a *type ascription* that follows the `react`
-invocation (`: Unit`). Basically, it let's you treat the result of
+invocation (`: Unit`). Basically, it lets you treat the result of
 `react` as having type `Unit`, which is legal, since the result of an
 expression can always be dropped. This is necessary to do here, since
 `andThen` cannot be a member of type `Nothing` which is the result
diff --git a/overviews/core/_posts/2012-09-20-futures.md b/overviews/core/_posts/2012-09-20-futures.md
index a0313df542..c9c76a8328 100644
--- a/overviews/core/_posts/2012-09-20-futures.md
+++ b/overviews/core/_posts/2012-09-20-futures.md
@@ -80,7 +80,7 @@ and no computation can proceed.
 
 By default the `ExecutionContext.global` sets the parallelism level of its underlying fork-join pool to the amount of available processors 
 ([Runtime.availableProcessors](http://docs.oracle.com/javase/7/docs/api/java/lang/Runtime.html#availableProcessors%28%29)).
-This configuration can be overriden by setting one (or more) of the following VM attributes:
+This configuration can be overridden by setting one (or more) of the following VM attributes:
 
   * scala.concurrent.context.minThreads - defaults to `Runtime.availableProcessors`
   * scala.concurrent.context.numThreads - can be a number or a multiplier (N) in the form 'xN' ;  defaults to `Runtime.availableProcessors`
diff --git a/overviews/core/_posts/2012-11-08-actors-migration-guide.md b/overviews/core/_posts/2012-11-08-actors-migration-guide.md
index 482ca60648..c3f1ca7094 100644
--- a/overviews/core/_posts/2012-11-08-actors-migration-guide.md
+++ b/overviews/core/_posts/2012-11-08-actors-migration-guide.md
@@ -249,7 +249,7 @@ add the type parameter to all `receive` calls in your system. For example:
       receive[String] { case x: Int => "Number" }
 
 Additionally, to make the code compile, users must add the `override` keyword before the `act` method, and to create
-the empty `receive` method in the code. Method `act` needs to be overriden since its implementation in `ActWithStash`
+the empty `receive` method in the code. Method `act` needs to be overridden since its implementation in `ActWithStash`
 mimics the message processing loop of Akka. The changes are shown in the following example:
 
     class MyActor extends ActWithStash {
diff --git a/overviews/macros/roadmap.md b/overviews/macros/roadmap.md
index cdaf35565b..fa779c9f13 100644
--- a/overviews/macros/roadmap.md
+++ b/overviews/macros/roadmap.md
@@ -18,7 +18,7 @@ At the moment, we don't plan to introduce new reflection- or macro-related featu
 so the functionality of Scala 2.12 and Paradise 2.12 is going to be the same as Scala 2.11 and Paradise 2.11
 modulo bugfixes and stability improvements.
 
-Feature-wise, our main effort is currently targetted at [scala.meta](http://scalameta.org),
+Feature-wise, our main effort is currently targeted at [scala.meta](http://scalameta.org),
 the new foundation for metaprogramming Scala, which is simpler, more robust and much more suitable for portability
 than the current system based on scala.reflect. We hope that one day scala.meta will supersede scala.reflect
 and become the new standard way of doing metaprogramming in Scala.
diff --git a/overviews/parallel-collections/custom-parallel-collections.md b/overviews/parallel-collections/custom-parallel-collections.md
index c6c586f933..528b5a8c3f 100644
--- a/overviews/parallel-collections/custom-parallel-collections.md
+++ b/overviews/parallel-collections/custom-parallel-collections.md
@@ -151,7 +151,7 @@ string by appending all the string builders together. This way, elements are
 copied only once at the end instead of being copied every time `combine` is
 called. Ideally, we would like to parallelize this process and copy them in
 parallel (this is being done for parallel arrays), but without tapping into
-the internal represenation of strings this is the best we can do-- we have to
+the internal representation of strings this is the best we can do-- we have to
 live with this sequential bottleneck.
 
     private class ParStringCombiner extends Combiner[Char, ParString] {
diff --git a/overviews/quasiquotes/expression-details.md b/overviews/quasiquotes/expression-details.md
index 2317ea9c4d..5a09200745 100644
--- a/overviews/quasiquotes/expression-details.md
+++ b/overviews/quasiquotes/expression-details.md
@@ -189,7 +189,7 @@ Similarly to type arguments, implicit value arguments are automatically inferred
 
 ## Assign and Update
 
-Assign and update are two related ways to explictly mutate a variable or collection:
+Assign and update are two related ways to explicitly mutate a variable or collection:
 
     scala> val assign = q"x = 2"
     assign: universe.Tree = x = 2
diff --git a/overviews/quasiquotes/intro.md b/overviews/quasiquotes/intro.md
index 3bbe8b7b91..0d131c753f 100644
--- a/overviews/quasiquotes/intro.md
+++ b/overviews/quasiquotes/intro.md
@@ -70,7 +70,7 @@ Each of this contexts is covered by separate interpolator:
  tq | [types](/overviews/quasiquotes/syntax-summary.html#types)
  pq | [patterns](/overviews/quasiquotes/syntax-summary.html#patterns)
 
-Syntactical similiarity between different contexts doesn\'t imply similarity between underlying trees:
+Syntactical similarity between different contexts doesn\'t imply similarity between underlying trees:
 
     scala> println(q"List[Int]" equalsStructure tq"List[Int]")
     false
@@ -90,7 +90,7 @@ Similarly patterns and expressions are not equivalent either:
 
 So it's extremely important to use the right interpolator for the job to construct a valid syntax tree.
 
-Additionally there are two auxilary interpolators that let you work with minor areas of scala syntax:
+Additionally there are two auxiliary interpolators that let you work with minor areas of scala syntax:
 
     | Used for
 ----|-------------------------------------
diff --git a/overviews/quasiquotes/type-details.md b/overviews/quasiquotes/type-details.md
index 42d49669f8..2c06f13059 100644
--- a/overviews/quasiquotes/type-details.md
+++ b/overviews/quasiquotes/type-details.md
@@ -164,7 +164,7 @@ Alternatively there is also an underscrore notation:
     scala> val tq"(..$tpts)" = tup2
     tpts: List[universe.Tree] = List(A, B)
 
-Analagously `Unit` type is considered to be nullary tuple:
+Analogously `Unit` type is considered to be nullary tuple:
 
     scala> val tq"(..$tpts)" = tq"_root_.scala.Unit"
     tpts: List[universe.Tree] = List()
diff --git a/sips/completed/_posts/2010-01-22-named-and-default-arguments.md b/sips/completed/_posts/2010-01-22-named-and-default-arguments.md
index 9852c6ab0f..c2a118060d 100644
--- a/sips/completed/_posts/2010-01-22-named-and-default-arguments.md
+++ b/sips/completed/_posts/2010-01-22-named-and-default-arguments.md
@@ -32,7 +32,7 @@ If an argument expression has the form `"x = expr"` and `x` is not a parameter n
     var x = 1
     twice(x = x + 1)
 
-It is an error if the expression `”x = expr”` can be interpreted as both a named argument (parameter name `x`) and an assignment (variable `x` in scope). If the expression is surrounded by an additonal set of parenthesis or braces, it is never treated as a named argument. Also, if the application argument is a block expression (as in `f{ arg }`), `arg` is never treated as a named argument.
+It is an error if the expression `”x = expr”` can be interpreted as both a named argument (parameter name `x`) and an assignment (variable `x` in scope). If the expression is surrounded by an additional set of parenthesis or braces, it is never treated as a named argument. Also, if the application argument is a block expression (as in `f{ arg }`), `arg` is never treated as a named argument.
 
     def twice(op: => Unit) = { op; op }
     var op = 1
diff --git a/sips/completed/_posts/2011-10-12-implicit-classes.md b/sips/completed/_posts/2011-10-12-implicit-classes.md
index e7d96fbc7a..dd48e09924 100644
--- a/sips/completed/_posts/2011-10-12-implicit-classes.md
+++ b/sips/completed/_posts/2011-10-12-implicit-classes.md
@@ -21,7 +21,7 @@ classes which provide _extension methods_ to another type.
 ## Description ##
 
 The `implicit` keyword will now be allowed as an annotation on
-classes.  Classes annotated with the `implicit` keyword are refered to
+classes.  Classes annotated with the `implicit` keyword are referred to
 as _implicit classes_.
 
 An implicit class must have a primary constructor with *exactly* one
diff --git a/sips/completed/_posts/2012-01-21-futures-promises.md b/sips/completed/_posts/2012-01-21-futures-promises.md
index bbe61d0a7e..b500dc2a73 100644
--- a/sips/completed/_posts/2012-01-21-futures-promises.md
+++ b/sips/completed/_posts/2012-01-21-futures-promises.md
@@ -714,7 +714,7 @@ Examples:
 
 
 ## References
-1. [The Task-Based Asychronous Pattern, Stephen Toub, Microsoft, April 2011][1]
+1. [The Task-Based Asynchronous Pattern, Stephen Toub, Microsoft, April 2011][1]
 2. [Finagle Documentation][2]
 3. [Akka Documentation: Futures][3]
 4. [Scala Actors Futures][4]
diff --git a/sips/completed/_posts/2012-01-30-value-classes.md b/sips/completed/_posts/2012-01-30-value-classes.md
index 1f4ef3fd3f..b8a4121ed7 100644
--- a/sips/completed/_posts/2012-01-30-value-classes.md
+++ b/sips/completed/_posts/2012-01-30-value-classes.md
@@ -87,7 +87,7 @@ The following implicit assumptions apply to value classes.
 Scala's rule for inheritance do not permit value classes to extend traits that
 extend from `AnyRef`. To permit value classes to extend traits, we introduce
 *universal traits*, which extend from `Any`. A universal trait `T` needs to
-explictly extend class `Any`. In the example below, `Equals` is a universal
+explicitly extend class `Any`. In the example below, `Equals` is a universal
 trait with superclass `Any`, but `Ordered`'s superclass is still assumed to be
 `AnyRef`.
 
diff --git a/sips/minutes/_posts/2016-07-15-sip-minutes.md b/sips/minutes/_posts/2016-07-15-sip-minutes.md
index c821e8dfe0..e1d24c13b2 100644
--- a/sips/minutes/_posts/2016-07-15-sip-minutes.md
+++ b/sips/minutes/_posts/2016-07-15-sip-minutes.md
@@ -117,7 +117,7 @@ make it interact correctly with Scala.js (the value classes formalization is not
 suitable for what he wants to address).
 
 Dmitry, Martin and Sébastien start to discuss about the performance of other
-alternatives that would need to change the the representation of scala number.
+alternatives that would need to change the representation of scala number.
 Adriaan and Josh agree that the proposal would be better as a library.
 
 **Outcome**: The board voted; all were in favor of giving it a number. Jorge asks
@@ -147,7 +147,7 @@ be resolved before resuming its evaluation.
 
 **Outcome**: The Process Lead postpones it until the authors want to decide to
 revisit the support of async/await in try/catch blocks. When that's considered,
-this SIP should be reopened and and it should see another round of discussion.
+this SIP should be reopened and it should see another round of discussion.
 
 #### Proposal SIP-20: Improved lazy val initialization presented
 Sébastien reviews the SIP and asks Dmitry, present in the meeting, to correct
diff --git a/sips/pending/_posts/2014-06-27-42.type.md b/sips/pending/_posts/2014-06-27-42.type.md
index e05da4a082..654f6976cb 100644
--- a/sips/pending/_posts/2014-06-27-42.type.md
+++ b/sips/pending/_posts/2014-06-27-42.type.md
@@ -17,7 +17,7 @@ title: SIP-23 - Literal-based singleton types
 
 Singleton types bridge the gap between the value level and the type level and hence allow the exploration in Scala of techniques which would typically only be available in languages with support for full-spectrum dependent types.
 
-Scala's type system can model constants (e.g. `42`, `"foo"`, `classOf[String]`). These are inferred in cases like `object O { final val x = 42 }`. They are used to denote and propagate compile time constants (See [6.24 Constant Expressions](http://www.scala-lang.org/files/archive/spec/2.11/06-expressions.html) and discussion of "constant value defintion" in [4.1 Value Declarations and Definitions](http://www.scala-lang.org/files/archive/spec/2.11/04-basic-declarations-and-definitions.html)). However, there is no surface syntax to express such types. This makes people who need them, create macros that would provide workarounds to do just that (e.g. [shapeless](https://github.com/milessabin/shapeless/blob/master/core/src/main/scala/shapeless/singletons.scala)). This can be changed in a relatively simple way, as the whole machinery to enable this is already present in the scala compiler.
+Scala's type system can model constants (e.g. `42`, `"foo"`, `classOf[String]`). These are inferred in cases like `object O { final val x = 42 }`. They are used to denote and propagate compile time constants (See [6.24 Constant Expressions](http://www.scala-lang.org/files/archive/spec/2.11/06-expressions.html) and discussion of "constant value definition" in [4.1 Value Declarations and Definitions](http://www.scala-lang.org/files/archive/spec/2.11/04-basic-declarations-and-definitions.html)). However, there is no surface syntax to express such types. This makes people who need them, create macros that would provide workarounds to do just that (e.g. [shapeless](https://github.com/milessabin/shapeless/blob/master/core/src/main/scala/shapeless/singletons.scala)). This can be changed in a relatively simple way, as the whole machinery to enable this is already present in the scala compiler.
 
 Another motivation for adding this functionality is the fact that it is already partially available in scala, but the way it is available makes interaction with this feature a bit inconsistent. Here’s what is possible in the current version of scala:
 
diff --git a/zh-cn/overviews/collections/creating-collections-from-scratch.md b/zh-cn/overviews/collections/creating-collections-from-scratch.md
index 19905c787d..f2e8e13f0f 100644
--- a/zh-cn/overviews/collections/creating-collections-from-scratch.md
+++ b/zh-cn/overviews/collections/creating-collections-from-scratch.md
@@ -46,7 +46,7 @@ range，用于生成步长为step的整型序列，并且iterate，将某个函
 
 | WHAT IT IS | WHAT IT DOES |
 |-------------------|---------------------|
-| S.emtpy | 空序列 |
+| S.empty | 空序列 |
 | S(x, y, z) | 一个包含x、y、z的序列 |
 | S.concat(xs, ys, zs) | 将xs、ys、zs串街起来形成一个新序列。 |
 | S.fill(n) {e}  | 以表达式e的结果为初值生成一个长度为n的序列。 |