diff --git a/Doc/glossary.rst b/Doc/glossary.rst
index 87a77d0..f7689af 100644
--- a/Doc/glossary.rst
+++ b/Doc/glossary.rst
@@ -28,11 +28,11 @@
 
    abstract base class
       Abstract Base Classes (abbreviated ABCs) complement :term:`duck-typing` by
-      providing a way to define interfaces when other techniques like :func:`hasattr`
-      would be clumsy. Python comes with many builtin ABCs for data structures
-      (in the :mod:`collections` module), numbers (in the :mod:`numbers`
-      module), and streams (in the :mod:`io` module). You can create your own
-      ABC with the :mod:`abc` module.
+      providing a way to define interfaces when other techniques like
+      :func:`hasattr` would be clumsy. Python comes with many built-in ABCs for
+      data structures (in the :mod:`collections` module), numbers (in the
+      :mod:`numbers` module), and streams (in the :mod:`io` module). You can
+      create your own ABC with the :mod:`abc` module.
 
    argument
       A value passed to a function or method, assigned to a named local
@@ -79,7 +79,7 @@
       in ``3+4.5``, each argument is of a different type (one int, one float),
       and both must be converted to the same type before they can be added or it
       will raise a ``TypeError``.  Coercion between two operands can be
-      performed with the ``coerce`` builtin function; thus, ``3+4.5`` is
+      performed with the ``coerce`` built-in function; thus, ``3+4.5`` is
       equivalent to calling ``operator.add(*coerce(3, 4.5))`` and results in
       ``operator.add(3.0, 4.5)``.  Without coercion, all arguments of even
       compatible types would have to be normalized to the same value by the
@@ -90,7 +90,7 @@
       expressed as a sum of a real part and an imaginary part.  Imaginary
       numbers are real multiples of the imaginary unit (the square root of
       ``-1``), often written ``i`` in mathematics or ``j`` in
-      engineering. Python has builtin support for complex numbers, which are
+      engineering.  Python has built-in support for complex numbers, which are
       written with this latter notation; the imaginary part is written with a
       ``j`` suffix, e.g., ``3+1j``.  To get access to complex equivalents of the
       :mod:`math` module, use :mod:`cmath`.  Use of complex numbers is a fairly
@@ -322,7 +322,7 @@
       define with an :meth:`__iter__` or :meth:`__getitem__` method.  Iterables
       can be used in a :keyword:`for` loop and in many other places where a
       sequence is needed (:func:`zip`, :func:`map`, ...).  When an iterable
-      object is passed as an argument to the builtin function :func:`iter`, it
+      object is passed as an argument to the built-in function :func:`iter`, it
       returns an iterator for the object.  This iterator is good for one pass
       over the set of values.  When using iterables, it is usually not necessary
       to call :func:`iter` or deal with iterator objects yourself.  The ``for``
@@ -424,7 +424,7 @@
 
    namespace
       The place where a variable is stored.  Namespaces are implemented as
-      dictionaries.  There are the local, global and builtin namespaces as well
+      dictionaries.  There are the local, global and built-in namespaces as well
       as nested namespaces in objects (in methods).  Namespaces support
       modularity by preventing naming conflicts.  For instance, the functions
       :func:`__builtin__.open` and :func:`os.open` are distinguished by their