--- a/docs/obs-terms.rst	Sat Apr 27 14:42:48 2019 -0400
+++ b/docs/obs-terms.rst	Sat Apr 27 19:32:03 2019 -0400
@@ -12,39 +12,39 @@
 marker registers a relation between an old obsoleted changeset and its newer
 version.
 
-Old changesets are called **precursors** while their new versions are called
-**successors**. A marker always registers a single *precursor* and:
+Old changesets are called **predecessors** while their new versions are called
+**successors**. A marker always registers a single *predecessor* and:
 
-- no *successor*: the *precursor* is just discarded.
-- one *successor*: the *precursor* has been rewritten
-- multiple *successors*: the *precursor* were splits in multiple
+- no *successor*: the *predecessor* is just discarded.
+- one *successor*: the *predecessor* has been rewritten
+- multiple *successors*: the *predecessor* were splits in multiple
   changesets.
 
-.. The *precursors* and *successors* terms can be used on changeset directly:
+.. The *predecessors* and *successors* terms can be used on changeset directly:
 
-.. :precursors: of a changeset `A` are changesets used as *precursors* by
+.. :predecessors: of a changeset `A` are changesets used as *predecessors* by
 ..              obsolete marker using changeset `A` as *successors*
 
 .. :successors: of a changeset `B` are changesets used as *successors* by
-..              obsolete marker using changeset `B` as *precursors*
+..              obsolete marker using changeset `B` as *predecessors*
 
 Chaining obsolete markers is allowed to rewrite a changeset that is already a
 *successor*. This is a kind of *second order version control*.
-To clarify ambiguous situations one can use **direct precursors** or
+To clarify ambiguous situations one can use **direct predecessors** or
 **direct successors** to name changesets that are directly related.
 
 The set of all *obsolete markers* forms a direct acyclic graph the same way
 standard *parents*/*children* relation does. In this graph we have:
 
-:any precursors: are transitive precursors of a changeset: *direct precursors*
-                 and *precursors* of *precursors*.
+:any predecessors: are transitive predecessors of a changeset: *direct predecessors*
+                 and *predecessors* of *predecessors*.
 
 :any successors: are transitive successors of a changeset: *direct successors*
                  and *successors*  of *successors*)
 
 Obsolete markers may refer changesets that are not known locally.
-So, *direct precursors* of a changeset may be unknown locally.
-This is why we usually focus on the **first known precursors**  of the rewritten
+So, *direct predecessors* of a changeset may be unknown locally.
+This is why we usually focus on the **first known predecessors**  of the rewritten
 changeset. The same apply for *successors*.
 
 Changeset in *any successors* which are not **obsolete** are called
@@ -66,13 +66,13 @@
 |                     |                          |                             |
 | Changeset in either | Obsolete changeset is    | *extinct* changeset is      |
 | *draft* or *secret* | *mutable* used as a      | *obsolete* which has only   |
-| phase.              | *precursor*.             | *obsolete* descendants.     |
+| phase.              | *predecessor*.           | *obsolete* descendants.     |
 |                     |                          |                             |
 |                     | A changeset is used as   | They can safely be:         |
-|                     | a *precursor* when at    |                             |
+|                     | a *predecessor* when at  |                             |
 |                     | least one obsolete       | - hidden in the UI,         |
 |                     | marker refers to it      | - silently excluded from    |
-|                     | as precursors.           |   pull and push operations  |
+|                     | as predecessors.         |   pull and push operations  |
 |                     |                          | - mostly ignored            |
 |                     |                          | - garbage collected         |
 |                     |                          |                             |
@@ -130,7 +130,7 @@
 |                     |                          | *divergent*   is changeset  |
 |                     |                          | that appears when multiple  |
 |                     |                          | changesets are successors   |
-|                     |                          | of the same precursor.      |
+|                     |                          | of the same predecessor.    |
 |                     |                          |                             |
 |                     |                          | *divergent*   are solved    |
 |                     |                          | through a three ways merge  |
@@ -168,8 +168,8 @@
 |                                                                              |
 | Rewriting operation refuse to work on immutable changeset.                   |
 |                                                                              |
-| Obsolete markers that refer an immutable changeset as precursors have        |
-| no effect on the precursors but may have effect on the successors.           |
+| Obsolete markers that refer an immutable changeset as predecessors have      |
+| no effect on the predecessors but may have effect on the successors.         |
 |                                                                              |
 | When a *mutable* changeset becomes *immutable* (changing its phase from draft|
 | to public) it is just *immutable* and loose any property of it's former      |