diff --git a/source/core/sharded-clusters.txt b/source/core/sharded-clusters.txt
index ddbe22ffefa..2a0b9e93b29 100644
--- a/source/core/sharded-clusters.txt
+++ b/source/core/sharded-clusters.txt
@@ -125,7 +125,8 @@ balancing process from impacting production traffic.
 
 To disable the balancer, see :ref:`sharding-balancing-disable-temporarily`.
 
-.. seealso:: :doc:`/tutorial/manage-sharded-cluster-balancer`.
+.. seealso:: :doc:`/tutorial/manage-sharded-cluster-balancer` and
+   :ref:`sharding-internals-balancing`.
 
 .. note::
 
diff --git a/source/reference/glossary.txt b/source/reference/glossary.txt
index 03927b9a59a..eff75415112 100644
--- a/source/reference/glossary.txt
+++ b/source/reference/glossary.txt
@@ -2,184 +2,81 @@
 Glossary
 ========
 
+.. NOTE: Several TODO's in this document.
+
 .. default-domain:: mongodb
 
 .. glossary::
    :sorted:
 
-   BSON
-      A serialization format used to store documents and make remote
-      procedure calls in MongoDB. "BSON" is a portmanteau of the words
-      "binary" and "JSON". Think of BSON as a binary representation
-      of JSON (JavaScript Object Notation) documents. For a detailed spec,
-      see `bsonspec.org <http://bsonspec.org/>`_.
-
-      .. seealso:: The :ref:`bson-json-type-conversion-fidelity`
-         section.
-
-   database command
-      Any MongoDB operation other than an insert, update, remove,
-      or query. MongoDB exposes commands as queries
-      against the special :term:`$cmd` collection. For
-      example, the implementation of :dbcommand:`count` for MongoDB is
-      a command.
-
-      .. seealso:: :doc:`/reference/command` for a full list of
-         database commands in MongoDB
-
-   operator
-      A keyword beginning with a ``$`` used to express a complex
-      query, update, or data transformation. For example, ``$gt``
-      is the query language's "greater than" operator.
-      See the :doc:`/reference/operator` for more
-      information about the available operators.
-
-   MongoDB
-      The document-based database server described in this manual.
-
-   document
-      A record in a MongoDB collection, and the basic unit of data
-      in MongoDB. Documents are analogous to JSON objects, but exist in
-      the database in a more type-rich format known as :term:`BSON`.
-
-   field
-      A name-value pair in a :term:`document <document>`. Documents have zero
-      or more fields. Fields are analogous to columns in relational
-      databases.
-
-   database
-      A physical container for :term:`collections <collection>`.
-      Each database gets its own set of files on the file
-      system. A single MongoDB server typically servers multiple
-      databases.
-
-   collection
-      Collections are groupings of :term:`BSON` :term:`documents
-      <document>`. Collections do not enforce a schema, but they are
-      otherwise mostly analogous to :term:`RDBMS` tables.
-
-      The documents within a collection may not need the exact same
-      set of fields, but typically all documents in a collection have
-      a similar or related purpose for an application.
-
-      All collections exist within a single :term:`database`. The
-      namespace within a database for collections are flat.
-
-      See :ref:`faq-dev-namespace` and :doc:`/core/document` for more
-      information.
-
    $cmd
-      A virtual :term:`collection` that exposes :term:`MongoDB`'s
-      :term:`database commands <database command>`.
-
-   JSON
-      JavaScript Object Notation. A human-readable, plain text format
-      for expressing structured data with support in many programming
-      languages.
-
-   JSON document
-      A :term:`JSON` document is a collection of fields and values in a
-      structured format. The following is a sample :term:`JSON
-      document` with two fields:
+      A special virtual :term:`collection` that exposes MongoDB's
+      :term:`database commands <database command>`. Commands in MongoDB
+      are implemented as queries performed on the ``$cmd`` collection.
+      To use database commands, see :ref:`issue-commands`.
 
-      .. code-block:: javascript
+   _id
+      A field required in every MongoDB :term:`document`. The ``_id``
+      field must have a unique value for a given document. You can think
+      of the ``_id`` field as the document's :term:`primary key`. The
+      value of ``_id`` can be any :term:`BSON` data type. If you create
+      a new document without an ``_id`` field, MongoDB automatically
+      creates the field and assigns it the value of a BSON
+      :term:`ObjectId`.
+
+      .. TODO When the CRUD docs are migrated, add to the above entry a link
+         to the "The _id Field" section in /source/core/document.txt.
+         Also, add the link anchor to "The _id Field."
 
-         { name: "MongoDB",
-           type: "database" }
+   accumulator
+      An :term:`expression` in the :term:`aggregation framework` that
+      maintains state between documents in the aggregation
+      :term:`pipeline`. For a list of accumulator operations, see
+      :pipeline:`$group`.
 
    admin database
-      A privileged database named ``admin``. Users must have access
-      to this database to run certain administrative commands.
-      See :ref:`administrative commands <admin-command>`
-      for more information
-      and :ref:`admin-commands` for a list of these commands.
-
-   replica set
-      A cluster of MongoDB servers that implements master-slave
-      replication and automated failover. MongoDB's recommended
-      replication strategy.
-
-      .. seealso:: :doc:`/replication`.
-
-   replication
-      A feature allowing multiple database servers to share the same
-      data, thereby ensuring redundancy and facilitating load balancing.
-      MongoDB supports two flavors of replication: master-slave replication
-      and replica sets.
-
-      .. seealso:: :term:`replica set`, :term:`sharding`,
-         :doc:`/replication`.
-
-   shard
-      A single :program:`mongod` instance or a :term:`replica set`
-      that stores some portion of a sharded cluster's
-      total data set. In production, all shards should be replica sets.
-      See :term:`sharding`.
-
-      .. seealso:: The documents in the :doc:`/sharding` section of this manual.
-
-   sharding
-      A database architecture that enable horizontal scaling by splitting
-      data into key ranges among two or more replica sets. This architecture
-      is also known as "range-based partitioning." See :term:`shard`.
-
-      .. seealso:: The documents in the :doc:`/sharding` section of this manual.
-
-   sharded cluster
-      The set of nodes comprising a :term:`sharded <sharding>` MongoDB deployment. A sharded cluster
-      consists of three config processes, one or more replica sets, and one or more
-      :program:`mongos` routing processes.
-
-      .. seealso:: The documents in the :doc:`/sharding` section of this manual.
-
-   partition
-      A distributed system architecture that splits data into ranges.
-      :term:`Sharding` is a kind of partitioning.
-
-   split
-      The division between :term:`chunks <chunk>` in a :term:`sharded
-      cluster`.
-
-   mongod
-      The program implementing the MongoDB database server. This server
-      typically runs as a :term:`daemon`.
-
-      .. seealso:: :doc:`/reference/program/mongod`.
-
-   mongos
-      The routing and load balancing process that
-      acts an interface between an application and
-      a MongoDB :term:`sharded cluster`.
+      A privileged database that gives access to certain commands. Users
+      must have access to the ``admin`` database to run certain
+      administrative commands. For a list of administrative commands,
+      see :ref:`admin-commands`.
 
-      .. seealso:: :doc:`/reference/program/mongos`.
+   aggregation
+      A function that reduces and summarizes large sets of data. SQL's
+      ``GROUP`` and MongoDB's map-reduce are two examples of aggregation
+      functions. For more information, see :doc:`/core/aggregation`.
 
-   mongo
-      The MongoDB Shell. ``mongo`` connects to :program:`mongod`
-      and :program:`mongos` instances, allowing administration,
-      management, and testing. :program:`mongo` has a JavaScript
-      interface.
+   aggregation framework
+      The set of MongoDB operators that let you calculate aggregate
+      values without having to use :term:`map-reduce`. For a list of
+      operators, see :doc:`/reference/aggregation`.
 
-      .. seealso:: :doc:`/reference/program/mongo` and :doc:`/reference/method`.
+   arbiter
+      A member of a :term:`replica set` that exists solely to vote in
+      :term:`elections <election>`. Arbiters do not replicate data. See
+      :ref:`replica-set-arbiter-configuration`
 
-   cluster
-      A set of :program:`mongod` instances running in
-      conjunction to increase database availability and
-      performance. See :term:`sharding` and :term:`replication` for
-      more information on the two different approaches to clustering with
-      MongoDB.
+   balancer
+      An internal MongoDB process that runs in the context of a
+      :term:`sharded cluster` and manages the migration of :term:`chunks
+      <chunk>`. Administrators must disable the balancer for all
+      maintenance operations on a sharded cluster. See
+      :ref:`sharding-balancing`.
 
-   capped collection
-      A fixed-sized :term:`collection <collection>`. Once they reach
-      their fixed size, capped collections automatically overwrite
-      their oldest entries. MongoDB's :term:`oplog` replication mechanism depends on
-      capped collections.  Developers may also use capped collections in their
-      applications.
+   BSON
+      A serialization format used to store documents and make remote
+      procedure calls in MongoDB. "BSON" is a portmanteau of the words
+      "binary" and "JSON". Think of BSON as a binary representation
+      of JSON (JavaScript Object Notation) documents.
 
-      .. seealso:: The :doc:`/core/capped-collections` page.
+      For a detailed spec, see `bsonspec.org <http://bsonspec.org/>`_.
+      See also :ref:`bson-json-type-conversion-fidelity`.
 
    BSON types
       The set of types supported by the :term:`BSON` serialization
-      format. The following types are available:
+      format.
+
+      .. TODO When the CRUD docs are migrated, remove the table below and
+         provide a link to /reference/bson-types.
 
       =======================  ==========
       **Type**                 **Number**
@@ -204,239 +101,381 @@ Glossary
       Max key                    127
       =======================  ==========
 
-   master
-      In conventional master/:term:`slave` replication, the master
-      database receives all writes. The :term:`slave` instances
-      replicate from the master instance in real time.
+   B-tree
+      A data structure commonly used by database management systems to
+      store indexes. MongoDB uses B-trees for its indexes.
 
-   slave
-      In conventional :term:`master`/slave replication, slaves
-      are read-only instances that replicate operations from the
-      :term:`master` database. Data read from slave instances may
-      not be completely consistent with the master. Therefore,
-      applications requiring consistent reads must read from the
-      master database instance.
+   capped collection
+      A fixed-sized :term:`collection <collection>` that automatically
+      overwrites its oldest entries when it reaches its maximum size.
+      The MongoDB :term:`oplog` that is used in :term:`replication` is a
+      capped collection. See :doc:`/core/capped-collections`.
 
-   primary
-      In a :term:`replica set`, the primary member is the current
-      :term:`master` instance, which receives all write operations.
+   checksum
+      A calculated value used to ensure data integrity.
+      The :term:`md5` algorithm is sometimes used as a checksum.
 
-   secondary
-      In a :term:`replica set`, the ``secondary`` members are the current
-      :term:`slave` instances that replicate the contents of the
-      master database. Secondary members may handle read requests, but only the
-      :term:`primary` members can handle write operations.
+   chunk
+      A partition within a :term:`shard`. A chunk is defined by a
+      contiguous range of :term:`shard key` values that are a subset of
+      the shard's range. Chunk ranges are inclusive of the lower
+      boundary and exclusive of the upper boundary. MongoDB splits
+      chunks when they grow beyond the configured chunk size, which by
+      default is 64 megabytes. MongoDB migrates chunks when a shard
+      contains too many chunks relative to other shards. See
+      :doc:`/core/sharding-chunk-splitting` and
+      :ref:`sharding-chunk-migration`.
 
-   GridFS
-      A convention for storing large files in a MongoDB database. All
-      of the official MongoDB drivers support this convention, as
-      does the ``mongofiles`` program.
+   client
+      The application layer that uses a database for data persistence
+      and storage. :term:`Drivers <driver>` provide the interface
+      level between the application layer and the database server.
 
-      .. seealso:: :doc:`/reference/program/mongofiles` and :doc:`/core/gridfs`.
+   cluster
+      See :term:`sharded cluster`.
 
-   md5
-      ``md5`` is a hashing algorithm used to efficiently provide
-      reproducible unique strings to identify and :term:`checksum`
-      data. MongoDB uses md5 to identify chunks of data for
-      :term:`GridFS`.
+   collection
+      A grouping of MongoDB :term:`documents <document>`. A collection
+      is the equivalent of an :term:`RDBMS` table. Collections do not
+      enforce a schema. Documents within a collection can have different
+      fields. Typically, all documents in a collection have a similar or
+      related purpose.
 
-   shell helper
-      A number of :doc:`database commands <command>` have "helper"
-      methods in the ``mongo`` shell that provide a more concise
-      syntax and improve the general interactive experience.
+      A collection exists within a single :term:`database`. The
+      namespace for a collection is flat. See :ref:`faq-dev-namespace`.
 
-      .. seealso:: :doc:`/reference/program/mongo` and
-         :doc:`/reference/method`.
+   compound index
+      An :term:`index` consisting of two or more keys. See
+      :ref:`index-type-compound`.
 
-   write-lock
-      A lock on the database for a given writer. When a process
-      writes to the database, it takes an exclusive write-lock to
-      prevent other processes from writing or reading.
+   config database
+      A :program:`mongod` instance that stores all the metadata
+      associated with a :term:`sharded cluster`. A production sharded
+      cluster requires three config servers, each on a separate machine.
+      See :ref:`sharding-config-server`.
 
-   index
-      A data structure that optimizes queries. See
-      :doc:`/core/indexes` for more information.
+   control script
+      A simple shell script, typically located in the ``/etc/rc.d`` or
+      ``/etc/init.d`` directory, and used by the system's initialization
+      process to start, restart or stop a :term:`daemon` process.
 
-   secondary index
-      A database :term:`index` that improves query performance by
-      minimizing the amount of work that the query engine must perform
-      to fulfill a query.
+   CRUD
+      An acronym for the fundamental operations of a database: Create,
+      Read, Update, and Delete. To perform these operations, see
+      :doc:`/crud`.
 
-   compound index
-      An :term:`index` consisting of two or more keys. See
-      :doc:`/core/indexes` for more information.
+   CSV
+      A text-based data format consisting of comma-separated values.
+      This format is commonly used to exchange data between relational
+      databases as the format is well-suited to tabular data. You can
+      import CSV files using :program:`mongoimport`.
 
-   btree
-      A data structure used by most database management systems
-      to store indexes. MongoDB uses b-trees for its indexes.
+   cursor
+      A pointer to the result set of a :term:`query`. Clients can
+      iterate through a cursor to retrieve results. By default, cursors
+      timeout after 10 minutes of inactivity. See
+      :ref:`read-operations-cursors`.
 
-   ISODate
-     The international date format used by :program:`mongo`
-     to display dates. E.g. ``YYYY-MM-DD HH:MM.SS.milis``.
+   daemon
+      The conventional name for a background, non-interactive
+      process.
 
-   journal
-      A sequential, binary transaction log used to bring the database into
-      a consistent state in the event of a hard shutdown. MongoDB
-      enables journaling by default for 64-bit builds of MongoDB
-      version 2.0 and newer. Journal files are pre-allocated and will
-      exist as three 1GB files in the data directory. To make journal
-      files smaller, use :setting:`smallfiles`.
+   data-center awareness
+      A property that allows clients to address members in a system
+      based on their locations. :term:`Replica sets <replica set>`
+      implement data-center awareness using :term:`tagging <tag>`. See
+      :doc:`/data-center-awareness`.
 
-      When enabled, MongoDB writes data first to the journal and then
-      to the core data files. MongoDB commits to the journal within
-      100ms, which is configurable using the
-      :setting:`journalCommitInterval` runtime option.
+   database
+      A physical container for :term:`collections <collection>`.
+      Each database gets its own set of files on the file
+      system. A single MongoDB server typically servers multiple
+      databases.
 
-      .. include:: /includes/fact-journal-commit-interval-with-gle.rst
+   database command
+      A MongoDB operation, other than an insert, update, remove, or
+      query. MongoDB exposes commands as queries against the special
+      :term:`$cmd` collection. For a list of database commands, see
+      :doc:`/reference/command`.
 
-      .. seealso:: The :doc:`/core/journaling/` page.
+   database profiler
+      A tool that, when enabled, keeps a record on all long-running
+      operations in a database's ``system.profile`` collection. The
+      profiler is most often used to diagnose slow queries. See
+      :ref:`database-profiling`.
 
-   pcap
-      A packet capture format used by :program:`mongosniff` to record
-      packets captured from network interfaces and display them as
-      human-readable MongoDB operations.
+   datum
+      A set of values used to define measurements on the earth. MongoDB
+      uses the :term:`WGS84` datum in certain :term:`geospatial`
+      calculations. See :doc:`/applications/geospatial-indexes`.
 
-   upsert
-      A kind of update that either updates the first document matched
-      in the provided query selector or, if no document matches,
-      inserts a new document having the fields implied by the
-      query selector and the update operation.
+   dbpath
+      The location of MongoDB's data file storage. The
+      default :setting:`dbpath` is ``/data/db``. Other common data
+      paths include ``/srv/mongodb`` and ``/var/lib/mongodb``.
+      See :setting:`dbpath`.
 
-   CSV
-      A text-based data format consisting of comma-separated values.
-      This format is commonly used to exchange database between relational
-      databases, since the format is well-suited to tabular data. You can
-      import CSV files using :program:`mongoimport`.
+   delayed member
+      A :term:`replica set` member that cannot become primary and
+      applies operations at a specified delay. The delay is useful for
+      protecting data from human error (i.e. unintentionally deleted
+      databases) or updates that have unforeseen effects on the
+      production database. See :ref:`replica-set-delayed-members`.
 
-   TSV
-      A text-based data format consisting of tab-separated values.
-      This format is commonly used to exchange database between relational
-      databases, since the format is well-suited to tabular data. You can
-      import TSV files using :program:`mongoimport`.
+   diagnostic log
+      A verbose log of operations stored in the :term:`dbpath` and named
+      :file:`diaglog.<time in hex>`, where ``<time-in-hex>`` is
+      the initiation time of logging, as a hexadecimal string.
+      See :setting:`diaglog`.
 
-   MIME
-      "Multipurpose Internet Mail Extensions." A standard set of type
-      and encoding definitions used to declare the encoding and type
-      of data in multiple data storage, transmission, and email
-      contexts.
+   document
+      A record in a MongoDB :term:`collection` and the basic unit of
+      data in MongoDB. Documents are analogous to :term:`JSON` objects
+      but exist in the database in a more type-rich format known as
+      :term:`BSON`. See :doc:`/core/document`.
 
-   padding factor
-      An automatically-calibrated constant used to determine how much
-      extra space MongoDB should allocate per document container on disk.
-      A padding factor of 1 means that MongoDB will allocate only the
-      amount of space needed for the document. A padding factor of 2
-      means that MongoDB will allocate twice the amount of space
-      required by the document.
+   dot notation
+      A notation that accesses embedded fields. See
+      document-dot-notation.
 
-   padding
-      The extra space allocated to document on the disk to prevent
-      moving a document when it grows as the result of
-      :method:`update() <db.collection.update()>`
-      operations.
+   draining
+      The process of removing or "shedding" :term:`chunks <chunk>` from
+      one :term:`shard` to another. Administrators must drain shards
+      before removing them from the cluster. See
+      :doc:`/tutorial/remove-shards-from-cluster`.
 
-   record size
-      The space allocated for a document including the padding.
+   driver
+      A client library for interacting with MongoDB in a particular
+      language. See :doc:`/applications/drivers`.
 
-   read-lock
-      In the context of a reader-writer lock, a lock that while
-      held allows concurrent readers, but no writers.
+   election
+      The process by which members of a :term:`replica set` select a
+      :term:`primary` on startup and in the event of a failure. See
+      :ref:`replica-set-elections`.
 
-   config database
-      One of three :program:`mongod` instances that store all of the
-      metadata associated with a :term:`sharded cluster`.
+   eventual consistency
+      A property of a distributed system that allows changes to the
+      system to propagate gradually. In a database system, this means
+      that readable members are not required to reflect the latest
+      writes at all times. In MongoDB, reads to a primary have
+      :term:`strict consistency`; reads to secondaries have *eventual
+      consistency*.
 
-   balancer
-      An internal MongoDB process that runs in the context of a
-      :term:`sharded cluster` and manages the
-      migration of :term:`chunks <chunk>`. Administrators must disable
-      the balancer for all maintenance operations on a sharded cluster.
+   expression
+      Stateless transformations that operate on the data that passes
+      through a :term:`pipeline`. See :doc:`/core/aggregation`.
 
-   chunk
-      In the context of a :term:`sharded cluster`, a chunk is a contiguous
-      range of :term:`shard key` values assigned to a particular
-      :term:`shard`. Chunk ranges are inclusive of the lower boundary
-      and exclusive of the upper boundary. By default, chunks are 64
-      megabytes or less. When they grow beyond the configured chunk
-      size, a :program:`mongos` splits the chunk into two chunks.
+   failover
+      The process that allows a :term:`secondary` member of a
+      :term:`replica set` to become :term:`primary` in the event of a
+      failure. See :ref:`replica-set-failover`.
 
-   geospatial
-      Data that relates to geographical location. In MongoDB, you may
-      index or store geospatial data according to geographical
-      parameters and reference specific coordinates in queries.
-      See :doc:`/applications/geospatial-indexes`.
+   field
 
-   checksum
-      A calculated value used to ensure data integrity.
-      The :term:`md5` algorithm is sometimes used as a checksum.
+      A name-value pair in a :term:`document <document>`. A document has
+      zero or more fields. Fields are analogous to columns in relational
+      databases.
 
-   haystack index
-      In the context of :term:`geospatial` queries, haystack indexes
-      enhance searches by creating "buckets" of objects grouped by a second
-      criterion. For example, you might want all geospatial searches
-      to first select along a non-geospatial dimension and then match
-      on location. See :doc:`/core/geohaystack` for more
-      information.
+      .. TODO When the CRUD docs are migrated, add to the above entry a link
+         to the "Document Structure" section in /source/core/document.txt.
+         Also, add the link anchor to "Document Structure."
 
-   oplog
-      A :term:`capped collection` that stores an ordered history of
-      logical writes to a MongoDB database. The oplog is the
-      basic mechanism enabling :term:`replication` in MongoDB.
+   firewall
+      A system level networking filter that restricts access based on,
+      among other things, IP address. Firewalls form part of effective
+      network security strategy. See :ref:`security-firewalls`.
 
-      .. seealso:: :ref:`Oplog Sizes <replica-set-oplog-sizing>` and
-         :doc:`/tutorial/change-oplog-size`.
+   fsync
+      A system call that flushes all dirty, in-memory pages to
+      disk. MongoDB calls ``fsync()`` on its database files at least
+      every 60 seconds. See :dbcommand:`fsync`.
 
-   control script
-      A simple shell script, typically located in the ``/etc/rc.d`` or
-      ``/etc/init.d`` directory and used by the system's initialization
-      process to start, restart and stop a :term:`daemon` process.
+   geohash
+      A value is a binary representation of the location on a coordinate
+      grid. See :ref:`geospatial-indexes-geohash`.
 
-   daemon
-      The conventional name for a background, non-interactive
-      process.
+   GeoJSON
+      A :term:`geospatial` data interchange format based on JavaScript
+      Object Notation (:term:`JSON`). GeoJSON is used in
+      :doc:`geospatial queries </applications/geospatial-indexes>`. For
+      supported GeoJSON objects, see :ref:`geo-overview-location-data`.
+      For the GeoJSON format specification, see
+      <http://geojson.org/geojson-spec.html>.
 
-   PID
-      A process identifier. On UNIX-like systems, a unique integer PID is assigned to
-      each running process. You can use a PID to inspect
-      a running process and send signals to it.
+   geospatial
+      Data that relates to geographical location. In MongoDB, you may
+      store, index, and query data according to geographical parameters.
+      See :doc:`/applications/geospatial-indexes`.
 
-   JSONP
-      :term:`JSON` with Padding. Refers to a method of injecting JSON
-      into applications. Presents potential security concerns.
+   GridFS
+      A convention for storing large files in a MongoDB database. All of
+      the official MongoDB drivers support this convention, as does the
+      :program:`mongofiles` program. See :doc:`/core/gridfs`.
 
-   REST
-     An API design pattern centered around the idea of
-     resources and the :term:`CRUD` operations that apply to them. Typically
-     implemented over HTTP. MongoDB provides a simple HTTP REST interface
-     that allows HTTP clients to run commands against the server.
+      .. TODO When the CRUD docs are migrated, update the above link to:
+         See :doc:`/reference/gridfs`.
 
-   dbpath
-      Refers to the location of MongoDB's data file storage. The
-      default :setting:`dbpath` is ``/data/db``. Other common data
-      paths include ``/srv/mongodb`` and ``/var/lib/mongodb``.
+   hashed shard key
+      A special type of :term:`shard key` that uses a hash of the value
+      in the shard key field to distribute documents among members of
+      the :term:`sharded cluster`. See :ref:`index-type-hashed`.
 
-      .. seealso:: :setting:`dbpath` or :option:`--dbpath
-         <mongod --dbpath>`.
+   haystack index
+      A :term:`geospatial` index that enhances searches by creating
+      "buckets" of objects grouped by a second criterion. See
+      :doc:`/core/geohaystack`.
 
-   set name
-      In the context of a :term:`replica set`, the ``set name`` refers to
-      an arbitrary name given to a replica set when it's first configured.
-      All members of a replica set must have the same name specified
-      with the :setting:`replSet` setting (or :option:`--replSet
-      <mongod --replSet>` option for :program:`mongod`.)
+   hidden member
+      A :term:`replica set` member that cannot become :term:`primary`
+      and that cannot receive read-only queries, depending on
+      :term:`read preference`. See :ref:`replica-set-hidden-members`.
 
-      .. seealso:: :term:`replication`, :doc:`/replication`.
+   idempotent
+      The quality of an operation to produce the same result given the
+      same input, whether run once or run multiple times.
 
-   _id
-      A field containing a unique ID, typically a BSON :term:`ObjectId`.
-      If not specified, this value is automatically assigned
-      upon the creation of a new document. You can think of the
-      ``_id`` as the document's :term:`primary key`.
+   index
+      A data structure that optimizes queries. See :doc:`/core/indexes`.
+
+   initial sync
+      The :term:`replica set` operation that replicates data from an
+      existing replica set member to a new or restored replica set
+      member. See :ref:`replica-set-initial-sync`.
+
+   IPv6
+      A revision to the IP (Internet Protocol) standard that
+      provides a significantly larger address space to more effectively
+      support the number of hosts on the contemporary Internet.
+
+   ISODate
+     The international date format used by :program:`mongo`
+     to display dates. E.g. ``YYYY-MM-DD HH:MM.SS.milis``.
+
+   JavaScript
+      A popular scripting language original designed for web browsers.
+      The MongoDB shell and certain server-side functions use a
+      JavaScript interpreter. See :doc:`/mongo` and
+      :doc:`/core/server-side-javascript`.
+
+   journal
+      A sequential, binary transaction log used to bring the database
+      into a consistent state in the event of a hard shutdown. MongoDB
+      enables journaling by default for 64-bit builds of MongoDB version
+      2.0 and newer. Journal files are pre-allocated.
+
+      Journaling writes data first to the journal and then to the core
+      data files. MongoDB commits to the journal within 100ms, which is
+      configurable using the :setting:`journalCommitInterval` runtime
+      option.
+
+      See :doc:`/core/journaling/`.
+
+   JSON
+      JavaScript Object Notation. A human-readable, plain text format
+      for expressing structured data with support in many programming
+      languages. For more information, see `json.org
+      <http://www.json.org/>`_.
+
+   JSON document
+      A :term:`JSON` document is a collection of fields and values in a
+      structured format. The following is a sample JSON document with
+      two fields:
+
+      .. code-block:: javascript
+
+         { name: "MongoDB",
+           type: "database" }
+
+      Certain MongoDB tools render an approximation of MongoDB
+      :term:`BSON` documents in JSON format. See
+      :doc:`/reference/mongodb-extended-json`.
+
+   JSONP
+      :term:`JSON` with Padding. Refers to a method of injecting JSON
+      into applications. **Presents potential security concerns**.
+
+   legacy coordinate pairs
+      The format used for :term:`geospatial` data prior to MongoDB
+      version 2.4. This format stores geospatial data as points on a
+      planar coordinate system. See
+      :doc:`/applications/geospatial-indexes`.
+
+   LineString
+      A LineString is defined by an array of two or more positions. A
+      closed LineString with four or more positions is called a
+      LinearRing, as described in the `GeoJSON LineString specification
+      <http://geojson.org/geojson-spec.html#linestring>`_. To use a
+      LineString in MongoDB, see
+      :ref:`geospatial-indexes-store-geojson`.
 
    LVM
       Logical volume manager. LVM is a program that abstracts disk
-      images from physical devices, and provides a number of raw disk
+      images from physical devices and provides a number of raw disk
       manipulation and snapshot capabilities useful for system
-      management.
+      management. For information on LVM and MongoDB, see
+      :ref:`lvm-backup-and-restore`.
+
+   map-reduce
+      A data processing and aggregation paradigm consisting of a "map"
+      phase that selects data and a "reduce" phase that transforms the
+      data. In MongoDB, you can run arbitrary aggregations over data
+      using map-reduce. For map-reduce implementation, see
+      :doc:`/core/map-reduce`. For another approach to data aggregation,
+      see :doc:`/core/aggregation`.
+
+   master
+      The database that receives all writes in a conventional
+      master/:term:`slave` replication. The slave instances replicate
+      from the master instance in real time. In MongoDB :term:`replica
+      sets <replica set>` replace master/slave replication for most use
+      cases. However, for information on master/slave replication, see
+      :doc:`/core/master-slave`.
+
+   md5
+      A hashing algorithm used to efficiently provide
+      reproducible unique strings to identify and :term:`checksum`
+      data. MongoDB uses md5 to identify chunks of data for
+      :term:`GridFS`. See :doc:`/reference/command/filemd5`.
+
+   MIME
+      Multipurpose Internet Mail Extensions. A standard set of type and
+      encoding definitions used to declare the encoding and type of data
+      in multiple data storage, transmission, and email contexts. The
+      :program:`mongofiles` tool provides an option to specify a MIME
+      type to describe a file inserted into :term:`GridFS` storage.
+
+   mongo
+      The MongoDB Shell. ``mongo`` connects to :program:`mongod` and
+      :program:`mongos` instances, allowing administration, management,
+      and testing. :program:`mongo` has a JavaScript interface. See
+      :doc:`/reference/program/mongo` and :doc:`/reference/method`.
+
+   MongoDB
+      The document-based database server described in this manual.
+
+   mongod
+      The program implementing the MongoDB database server. This server
+      typically runs as a :term:`daemon`. See
+      :doc:`/reference/program/mongod`.
+
+   mongos
+      The routing and load balancing process that acts an interface
+      between an application and a MongoDB :term:`sharded cluster`. See
+      :doc:`/reference/program/mongos`.
+
+   multi-master replication
+      A :term:`replication` method where multiple database instances
+      can accept write operations to the same data set at any
+      time. Multi-master replication exchanges increased concurrency and
+      availability for a relaxed consistency semantic. MongoDB ensures
+      consistency and, therefore, does not provide multi-master replication.
+
+   namespace
+      The canonical name for a collection or index in MongoDB.
+      The namespace is a combination of the database name and
+      the name of the collection or index, like so:
+      ``[database-name].[collection-or-index-name]``. All documents
+      belong to a namespace.
 
    natural order
       The order in which a database stores documents on
@@ -453,76 +492,74 @@ Glossary
       ``$natural:-1``, the database returns documents in reverse natural
       order.
 
-   primary key
-      A record's unique, immutable identifier. In an :term:`RDBMS`, the primary
-      key is typically an integer stored in each row's ``id`` field.
-      In MongoDB, the :term:`_id` field holds a document's primary
-      key which is usually a BSON :term:`ObjectId`.
+   ObjectId
+      A special 12-byte :term:`BSON` type that guarantees uniqueness
+      within the collection. The ObjectID is generated based on
+      timestamp, machine ID, process ID, and a process-local incremental
+      counter. MongoDB uses ObjectId values as the default values for
+      :term:`_id` fields.
 
-   unique index
-      An index that enforces uniqueness for a particular field across
-      a single collection.
+   operator
+      A keyword beginning with a ``$`` used to express a complex
+      query, update, or data transformation. For example, ``$gt``
+      is the query language's "greater than" operator.
 
-   firewall
-      A system level networking filter that restricts access based on,
-      among other things, IP address. Firewalls form part of effective
-      network security strategy.
+      For more information about the available operators, see
+      :doc:`/reference/operator`.
 
-   database profiler
-      A tool that, when enabled, keeps a record on all long-running
-      operations in a database's ``system.profile`` collection. The
-      profiler is most often used to diagnose slow queries.
+   oplog
+      A :term:`capped collection` that stores an ordered history of
+      logical writes to a MongoDB database. The oplog is the
+      basic mechanism enabling :term:`replication` in MongoDB.
 
-      .. seealso:: :ref:`Monitoring Database Systems <database-profiling>`.
+      See :ref:`Oplog Sizes <replica-set-oplog-sizing>` and
+      :doc:`/tutorial/change-oplog-size`.
 
-   shard key
-      In a sharded collection, a shard key is the field that MongoDB
-      uses to distribute documents among members of the
-      :term:`sharded cluster`.
+   ordered query plan
+      Query plan that returns results in the order consistent with the
+      :method:`~cursor.sort()` order.
 
-   hashed shard key
-      A :ref:`hashed shard key <index-type-hashed>` is a special type
-      of :term:`shard key` that uses a hash of the value in the shard
-      key field to distribute documents among members of the
-      :term:`sharded cluster`.
+      See :ref:`read-operations-query-optimization`.
 
-   query
-      A read request. MongoDB queries use a :term:`JSON`-like query
-      language that includes a variety of :term:`query operators <operator>`
-      with names that begin with a ``$`` character. In the
-      :program:`mongo` shell, you can issue queries using the
-      :method:`db.collection.find()` and
-      :method:`db.collection.findOne()` methods.
+   padding
+      The extra space allocated to document on the disk to prevent
+      moving a document when it grows as the result of
+      :method:`update() <db.collection.update()>`
+      operations.
 
-   projection
-      A document given to a :term:`query` that specifies which fields
-      MongoDB will return from the documents in the result set.
-      See :doc:`/reference/operator/projection` for a list of
-      special projection operators.
+   padding factor
+      An automatically-calibrated constant used to determine how much
+      extra space MongoDB should allocate per document container on disk.
+      A padding factor of 1 means that MongoDB will allocate only the
+      amount of space needed for the document. A padding factor of 2
+      means that MongoDB will allocate twice the amount of space
+      required by the document.
 
-   pre-splitting
-      An operation, performed before inserting data that divides the
-      range of possible shard key values into chunks to facilitate
-      easy insertion and high write throughput.  When deploying a
-      :term:`sharded cluster`, in some cases pre-splitting will expedite
-      the initial distribution of documents among shards by manually
-      dividing the collection into chunks rather than waiting for the
-      MongoDB :term:`balancer` to create chunks during the course of
-      normal operation.
+   page fault
+      The event that occurs when a process requests stored data
+      (i.e. a page) from memory that the operating system has moved to
+      disk.
 
-   SSD
-      Solid State Disk. A high-performance disk drive that uses solid
-      state electronics for persistence, as opposed to the rotating platters
-      and movable read/write heads used by traditional mechanical hard drives.
+      See :ref:`Storage FAQ: What are page faults?
+      <faq-storage-page-faults>`.
 
-   resident memory
-      The subset of an application's memory currently stored in
-      physical RAM. Resident memory is a subset of :term:`virtual memory`,
-      which includes memory mapped to physical RAM and to disk.
+   partition
+      A distributed system architecture that splits data into ranges.
+      :term:`Sharding` is a kind of partitioning.
 
-   virtual memory
-      An application's working memory, typically residing on both
-      disk an in physical RAM.
+   passive member
+      A member of a :term:`replica set` that cannot become primary
+      because its :data:`~local.system.replset.members[n].priority` is ``0``.
+
+   pcap
+      A packet capture format used by :program:`mongosniff` to record
+      packets captured from network interfaces and display them as
+      human-readable MongoDB operations.
+
+   PID
+      A process identifier. On UNIX-like systems, a unique integer PID is assigned to
+      each running process. You can use a PID to inspect
+      a running process and send signals to it.
 
    pipe
       A communication channel in UNIX-like systems allowing independent processes
@@ -530,106 +567,94 @@ Glossary
       allow users to direct the output of one command into the input
       of another.
 
-   IPv6
-      A revision to the IP (Internet Protocol) standard that
-      provides a significantly larger address space to more effectively
-      support the number of hosts on the contemporary Internet.
+   pipeline
+      The series of operations in the :term:`aggregation` process.
 
-   draining
-      The process of removing or "shedding" :term:`chunks <chunk>`
-      from one :term:`shard` to another. Administrators must drain
-      shards before removing them from the cluster.
+      See :doc:`/core/aggregation`.
 
-      .. seealso:: :dbcommand:`removeShard`, :term:`sharding`.
+   Point
+      A point is a single coordinate pair, or "position," as described
+      in `the GeoJSON Point specification
+      <http://geojson.org/geojson-spec.html#point>`_. To use a Point in
+      MongoDB, see :ref:`geospatial-indexes-store-geojson`.
 
-   single-master replication
-      A :term:`replication` topology where only a single database
-      instance accepts writes. Single-master replication ensures consistency
-      and is the replication topology employed by MongoDB.
+   Polygon
+      A Polygon is defined by an array of :term:`LinearRing
+      <LineString>` coordinate arrays, as described in `the GeoJSON
+      Polygon specification
+      <http://geojson.org/geojson-spec.html#polygon>`_. For Polygons
+      with multiple rings, the first **must** be the exterior ring and
+      any others must be interior rings or holes.
 
-   multi-master replication
-      A :term:`replication` method where multiple database instances
-      can accept write operations to the same data set at any
-      time. Multi-master replication exchanges increased concurrency and
-      availability for a relaxed consistency semantic. MongoDB ensures
-      consistency and, therefore, does not provide multi-master replication.
+      MongoDB does not permit the exterior ring to self-intersect, and
+      interior rings must be fully contained within the outer loop and
+      cannot intersect or overlap with each other. See
+      :ref:`geospatial-indexes-store-geojson`.
 
-   rollback
-      A process that, in certain replica set situations, reverts
-      writes operations to ensure the consistency of all replica set
-      members.
+   powerOf2Sizes
+      A per-:term:`collection` setting that changes and normalizes the
+      way that MongoDB allocates space for each :term:`document` in an
+      effort to maximize storage reuse reduce fragmentation. This is
+      the default for :doc:`TTL Collections </tutorial/expire-data>`.
 
-   eventual consistency
-      A property of a distributed system allowing changes to the
-      system to propagate gradually. In a database system, this means
-      that readable members are not required to reflect the latest
-      writes at all times. In MongoDB, reads to a primary have
-      :term:`strict consistency`; reads to secondaries have
-      :term:`eventual consistency`.
+      See :dbcommand:`collMod` and :collflag:`usePowerOf2Sizes`.
 
-   strict consistency
-      A property of a distributed system requiring that all members
-      always reflect the latest changes to the system. In a database
-      system, this means that any system that can provide data must
-      reflect the latest writes at all times. In MongoDB, reads from a
-      primary have :term:`strict consistency`; reads from secondary
-      members have :term:`eventual consistency`.
+      .. versionadded:: 2.2
 
-   write concern
-      Specifies whether a write operation has succeeded. Write concern
-      allows your application to detect insertion errors or unavailable
-      :program:`mongod` instances. For :term:`replica sets <replica
-      set>`, you can configure write concern to confirm replication to a
-      specified number of members.
+   pre-splitting
+      An operation, performed before inserting data that divides the
+      range of possible shard key values into chunks to facilitate
+      easy insertion and high write throughput.  When deploying a
+      :term:`sharded cluster`, in some cases pre-splitting will expedite
+      the initial distribution of documents among shards by manually
+      dividing the collection into chunks rather than waiting for the
+      MongoDB :term:`balancer` to create chunks during the course of
+      normal operation.
 
-      .. seealso:: :ref:`Write Concern <write-concern>`,
-         :doc:`/core/write-operations`, and :doc:`Write Concern for
-         Replica Sets </core/write-concern>`.
+   primary
+      In a :term:`replica set`, the primary member is the current
+      :term:`master` instance, which receives all write operations.
+
+   primary key
+      A record's unique, immutable identifier. In an :term:`RDBMS`, the primary
+      key is typically an integer stored in each row's ``id`` field.
+      In MongoDB, the :term:`_id` field holds a document's primary
+      key which is usually a BSON :term:`ObjectId`.
+
+   primary shard
+      For a database where :term:`sharding` is enabled, the primary
+      shard holds all un-sharded collections.
 
    priority
       In the context of :term:`replica sets <replica set>`, priority
       is a configurable value that helps determine which members in
       a replica set are most likely to become :term:`primary`.
 
-      .. seealso:: :data:`~local.system.replset.members[n].priority`
-
-   election
-      In the context of :term:`replica sets <replica set>`, an election
-      is the process by which members of a replica set select
-      primaries on startup and in the event of failures.
-
-      .. seealso:: :ref:`Replica Set Elections
-         <replica-set-elections>` and :term:`priority`.
-
-   hidden member
-      A member of a :term:`replica set` that cannot become primary and
-      is not advertised as part of the set in the :term:`database
-      command` :dbcommand:`isMaster`, which prevents it from
-      receiving read-only queries depending on :term:`read
-      preference`.
-
-      .. seealso:: :ref:`Hidden Member <replica-set-hidden-members>`,
-         :dbcommand:`isMaster`, :method:`db.isMaster`, and
-         :data:`local.system.replset.members[n].hidden`.
+      See :data:`~local.system.replset.members[n].priority`.
 
-   passive member
-      A member of a :term:`replica set` that cannot become primary
-      because its :data:`~local.system.replset.members[n].priority` is ``0``.
+   projection
+      A document given to a :term:`query` that specifies which fields
+      MongoDB will return from the documents in the result set.
 
-   delayed member
-      A member of a :term:`replica set` that cannot become primary and
-      applies operations at a specified delay. This delay is useful
-      for protecting data from human error (i.e. unintentionally
-      deleted databases) or updates that have unforeseen effects on
-      the production database.
+      For a list of special projection operators, see
+      :doc:`/reference/operator/projection`.
 
-      .. seealso:: :ref:`Delayed Members <replica-set-delayed-members>`
+   query
+      A read request. MongoDB queries use a :term:`JSON`-like query
+      language that includes a variety of :term:`query operators <operator>`
+      with names that begin with a ``$`` character. In the
+      :program:`mongo` shell, you can issue queries using the
+      :method:`db.collection.find()` and
+      :method:`db.collection.findOne()` methods.
 
-   arbiter
-      A member of a :term:`replica set` that exists solely to vote
-      in :term:`elections <election>`. Arbiters do not replicate data.
+   query optimizer
+      For each query, the MongoDB query optimizer generates a query plan
+      that matches the query to the index that produces the fastest
+      results. The optimizer then uses the query plan each time the
+      :program:`mongod` receives the query. If a collection changes
+      significantly, the optimizer creates a new query plan.
 
-      .. seealso:: :ref:`Delayed Members <replica-set-delayed-members>`
+      See :ref:`read-operations-query-optimization`.
 
    read preference
       A setting on the MongoDB :doc:`drivers </applications/drivers>`
@@ -640,73 +665,140 @@ Glossary
       direct reads to secondaries for :term:`eventually consistent
       <eventual consistency>` reads.
 
-      .. seealso:: :doc:`Read Preference </core/read-preference>`
+      See :doc:`Read Preference </core/read-preference>`.
+
+   read-lock
+      In the context of a reader-writer lock, a lock that while
+      held allows concurrent readers, but no writers.
+
+   RDBMS
+      Relational Database Management System. A database management
+      system based on the relational model, typically using
+      :term:`SQL` as the query language.
+
+   record size
+      The space allocated for a document including the padding.
+
+   recovering
+      A :term:`replica set` member status indicating that a member
+      is not ready to begin normal activities of a secondary or primary.
+      Recovering members are unavailable for reads.
+
+   replica pairs
+      The precursor to the MongoDB :term:`replica sets <replica set>`.
+
+      .. deprecated:: 1.6
+
+   replica set
+      A cluster of MongoDB servers that implements master-slave
+      replication and automated failover. MongoDB's recommended
+      replication strategy.
+
+      See :doc:`/replication`.
+
+   replication
+      A feature allowing multiple database servers to share the same
+      data, thereby ensuring redundancy and facilitating load balancing.
+      MongoDB supports two flavors of replication: master-slave replication
+      and replica sets.
+
+      See :term:`replica set`, :term:`sharding`, :doc:`/replication`.
+
+   replication lag
+      The length of time between the last operation in the primary's
+      :term:`oplog` last operation applied to a particular
+      :term:`secondary` or :term:`slave`. In general, you want
+      to keep replication lag as small as possible.
+
+      See :ref:`Replication Lag <replica-set-replication-lag>`.
+
+   resident memory
+      The subset of an application's memory currently stored in
+      physical RAM. Resident memory is a subset of :term:`virtual memory`,
+      which includes memory mapped to physical RAM and to disk.
+
+   REST
+     An API design pattern centered around the idea of
+     resources and the :term:`CRUD` operations that apply to them. Typically
+     implemented over HTTP. MongoDB provides a simple HTTP REST interface
+     that allows HTTP clients to run commands against the server.
+
+   rollback
+      A process that, in certain replica set situations, reverts
+      writes operations to ensure the consistency of all replica set
+      members.
 
-   replication lag
-      The length of time between the last operation in the primary's
-      :term:`oplog` last operation applied to a particular
-      :term:`secondary` or :term:`slave`. In general, you want
-      to keep replication lag as small as possible.
+   secondary
+      In a :term:`replica set`, the ``secondary`` members are the current
+      :term:`slave` instances that replicate the contents of the
+      master database. Secondary members may handle read requests, but only the
+      :term:`primary` members can handle write operations.
 
-      .. seealso:: :ref:`Replication Lag <replica-set-replication-lag>`
+   secondary index
+      A database :term:`index` that improves query performance by
+      minimizing the amount of work that the query engine must perform
+      to fulfill a query.
 
-   driver
-      A client implementing the communication protocol required for talking
-      to a server. The MongoDB drivers provide language-idiomatic
-      methods for interfacing with MongoDB.
+   set name
+      In the context of a :term:`replica set`, the ``set name`` refers to
+      an arbitrary name given to a replica set when it's first configured.
+      All members of a replica set must have the same name specified
+      with the :setting:`replSet` setting (or :option:`--replSet
+      <mongod --replSet>` option for :program:`mongod`.)
 
-      .. seealso:: :doc:`/applications/drivers`
+      See :term:`replication`, :doc:`/replication`.
 
-   client
-      The application layer that uses a database for data persistence
-      and storage. :term:`Drivers <driver>` provide the interface
-      level between the application layer and the database server.
+   shard
+      A single :program:`mongod` instance or a :term:`replica set`
+      that stores some portion of a sharded cluster's
+      total data set. In production, all shards should be replica sets.
 
-   failover
-      The process that allows one of the :term:`secondary` members in a
-      :term:`replica set` to become :term:`primary` in the event of
-      a failure.
+      See :doc:`/sharding`.
 
-      .. seealso:: :ref:`Replica Set Failover <replica-set-failover>`.
+   shard key
+      In a sharded collection, a shard key is the field that MongoDB
+      uses to distribute documents among members of the
+      :term:`sharded cluster`. See :ref:`shard-key`.
 
-   data-center awareness
-      A property that allows clients to address members in a system
-      based upon their location.
+   sharded cluster
+      The set of nodes comprising a :term:`sharded <sharding>` MongoDB deployment. A sharded cluster
+      consists of three config processes, one or more replica sets, and one or more
+      :program:`mongos` routing processes.
 
-      :term:`Replica sets <replica set>` implement data-center
-      awareness using :term:`tagging <tag>`. See
-      :doc:`/data-center-awareness` for more information.
+      See :doc:`/sharding`.
 
-   tag
-     One or more labels applied to a given replica set member that
-     clients may use to issue data-center aware operations.
+   sharding
+      A database architecture that enable horizontal scaling by splitting
+      data into key ranges among two or more replica sets. This architecture
+      is also known as "range-based partitioning." See :term:`shard`.
 
-   recovering
-      A :term:`replica set` member status indicating that a member
-      is not ready to begin normal activities of a secondary or primary.
-      Recovering members are unavailable for reads.
+      See :doc:`/sharding`.
 
-   control script
-      A script used by a UNIX-like operating system to start, stop,
-      or restart a :term:`daemon` process. On most systems,
-      you can find these scripts in the ``/etc/init.d/`` or
-      ``/etc/rc.d/`` directories.
+   shell helper
+      A number of :doc:`database commands <command>` have "helper"
+      methods in the ``mongo`` shell that provide a more concise
+      syntax and improve the general interactive experience.
 
-   map-reduce
-      A data processing and aggregation paradigm consisting of a
-      "map" phase that selects data, and a "reduce" phase that
-      transforms the data. In MongoDB, you can run arbitrary aggregations
-      over data using map-reduce.
+      See :doc:`/reference/program/mongo` and :doc:`/reference/method`.
 
-      .. seealso:: The :doc:`/core/map-reduce` page for
-         more information regarding MongoDB's map-reduce
-         implementation, and :doc:`/core/aggregation` for
-         another approach to data aggregation in MongoDB.
+   single-master replication
+      A :term:`replication` topology where only a single database
+      instance accepts writes. Single-master replication ensures consistency
+      and is the replication topology employed by MongoDB.
 
-   RDBMS
-      Relational Database Management System. A database management
-      system based on the relational model, typically using
-      :term:`SQL` as the query language.
+   slave
+      A read-only database that replicates operations from a
+      :term:`master` database in conventional master/slave replication.
+      Data read from a slave instance may not be completely consistent
+      with the master. Applications requiring consistent reads must read
+      from the master database instance. In MongoDB :term:`replica sets
+      <replica set>` replace master/slave replication for most use
+      cases. However, for information on master/slave replication, see
+      :doc:`/core/master-slave`.
+
+   split
+      The division between :term:`chunks <chunk>` in a :term:`sharded
+      cluster`.
 
    SQL
       Structured Query Language (SQL) is a common special-purpose
@@ -720,81 +812,49 @@ Glossary
       :term:`RDBMS` products. ``SQL`` is often used as
       metonym for relational databases.
 
-   aggregation
-      Any of a variety of operations that reduce and summarize large
-      sets of data. SQL's ``GROUP`` and MongoDB's map-reduce are two
-      examples of aggregation functions.
-
-   aggregation framework
-      The MongoDB aggregation framework provides a means to calculate
-      aggregate values without having to use :term:`map-reduce`.
-
-      .. seealso:: :doc:`/core/aggregation`.
-
-   pipeline
-      The series of operations in the :term:`aggregation` process.
-
-      .. seealso:: :doc:`/core/aggregation`.
-
-   expression
-      In the context of the :term:`aggregation framework`, expressions
-      are the stateless transformations that operate on the data that
-      passes through the :term:`pipeline`.
+   SSD
+      Solid State Disk. A high-performance disk drive that uses solid
+      state electronics for persistence, as opposed to the rotating platters
+      and movable read/write heads used by traditional mechanical hard drives.
 
-      .. seealso:: :doc:`/core/aggregation`.
+   standalone
+      In MongoDB, a standalone is an instance of :program:`mongod` that
+      is running as a single server and not as part of a :term:`replica set`.
 
-   accumulator
-      An :term:`expression` in the :term:`aggregation framework` that
-      maintains state between documents in the :term:`aggregation`
-      :term:`pipeline`. See: :pipeline:`$group` for a list of
-      accumulator operations.
+   strict consistency
+      A property of a distributed system requiring that all members
+      always reflect the latest changes to the system. In a database
+      system, this means that any system that can provide data must
+      reflect the latest writes at all times. In MongoDB, reads from a
+      primary have :term:`strict consistency`; reads from secondary
+      members have :term:`eventual consistency`.
 
-   CRUD
-      Create, read, update, and delete. The fundamental operations
-      of any database.
+   sync
+      The :term:`replica set` operation where members replicate data
+      from the :term:`primary`.  Replica sets synchronize data at two
+      different points:
 
-   JavaScript
-      A popular scripting language original designed for web browsers.
-      The MongoDB shell and certain server-side functions use
-      a JavaScript interpreter.
+      - :term:`Initial sync` occurs when MongoDB creates new databases on a
+        new or restored :term:`replica set` member, populating the
+        member with the replica set's data.
 
-   idempotent
-      The quality of an operation to produce the same result whether
-      run once or multiple times given the same input.
+      - "Replication" occurs continually after initial sync and keeps
+        the member updated with changes to the replica set's data.
 
    syslog
       On UNIX-like systems, a logging process that provides a uniform
       standard for servers and processes to submit logging
       information.
 
-   namespace
-      The canonical name for a collection or index in MongoDB.
-      The namespace is a combination of the database name and
-      the name of the collection or index, like so:
-      ``[database-name].[collection-or-index-name]``. All documents
-      belong to a namespace.
-
-   replica pairs
-      The precursor to the MongoDB :term:`replica sets <replica set>`.
-
-      .. deprecated:: 1.6
-
-   writeBacks
-      The process within the sharding system that ensures that writes
-      issued to a :term:`shard` that isn't responsible for the
-      relevant chunk, get applied to the proper shard.
-
-   page fault
-      The event that occurs when a process requests stored data
-      (i.e. a page) from memory that the operating system has moved to
-      disk.
-
-      .. seealso:: :ref:`Storage FAQ: What are page faults?
-         <faq-storage-page-faults>`
+   tag
+     One or more labels applied to a given replica set member that
+     clients may use to issue data-center aware operations.
 
-   working set
-      The collection of data that MongoDB uses regularly. This data
-      is typically (or preferably) held in RAM.
+   TSV
+      A text-based data format consisting of tab-separated values.
+      This format is commonly used to exchange database between relational
+      databases, since the format is well-suited to tabular data. You can
+      import TSV files using :program:`mongoimport`.
 
    TTL
       Stands for "time to live," and represents an expiration time or
@@ -802,147 +862,53 @@ Glossary
       other temporary storage system before the system deletes it or
       ages it out.
 
-   ObjectId
-      A special 12-byte :term:`BSON` type that guarantees uniqueness
-      within the collection. The ObjectID is generated based on
-      timestamp, machine ID, process ID, and a process-local incremental
-      counter. MongoDB uses ObjectId values as the default values for
-      :term:`_id` fields.
-
-   geohash
-      A value is a binary representation of the location on a
-      coordinate grid.
-
-   powerOf2Sizes
-      A per-:term:`collection` setting that changes and normalizes the
-      way that MongoDB allocates space for each :term:`document` in an
-      effort to maximize storage reuse reduce fragmentation. This is
-      the default for :doc:`TTL Collections </tutorial/expire-data>`.
-      See :dbcommand:`collMod` and :collflag:`usePowerOf2Sizes` for
-      more information.
-
-      .. versionadded:: 2.2
-
-   CAP Theorem
-      Given three properties of computing systems, consistency,
-      availability, and partition tolerance, a distributed computing
-      system can provide any two of these features, but never all
-      three.
-
-   cursor
-      In MongoDB, a cursor is a pointer to the result set of a
-      :term:`query`, that clients can iterate through to retrieve
-      results. By default, cursors will timeout after 10 minutes of
-      inactivity.
-
-   standalone
-      In MongoDB, a standalone is an instance of :program:`mongod` that
-      is running as a single server and not as part of a :term:`replica set`.
-
-   query optimizer
-      For each query, the MongoDB query optimizer generates a query plan
-      that matches the query to the index that produces the fastest
-      results. The optimizer then uses the query plan each time the
-      :program:`mongod` receives the query. If a collection changes
-      significantly, the optimizer creates a new query plan.
-
-      .. seealso:: :ref:`read-operations-query-optimization`
-
-   diagnostic log
-      :program:`mongod` can create a verbose log of operations with
-      the :option:`mongod --diaglog` option or through the
-      :dbcommand:`diagLogging` command.  The :program:`mongod` creates
-      this log in
-      the directory specified to :option:`mongod --dbpath`.  The name
-      of the is :file:`diaglog.<time in hex>`, where
-      "``<time-in-hex>``" reflects the initiation time of logging as a hexadecimal string.
-
-      .. include:: /includes/warning-diaglogging-off.rst
-
-      .. seealso:: :option:`mongod --diaglog`,
-         :setting:`diaglog`, and :dbcommand:`diagLogging`.
-
-   primary shard
-      For a database where :term:`sharding` is enabled, the primary
-      shard holds all un-sharded collections.
-
-   fsync
-      A system call that flushes all dirty, in-memory pages to
-      disk. MongoDB calls ``fsync()`` on its database files at least
-      every 60 seconds.
-
-   dot notation
-      .. include:: /includes/fact-dot-notation.rst
-
-   ordered query plan
-      Query plan that returns results in the order consistent with the
-      :method:`~cursor.sort()` order.
-
-      .. seealso:: :ref:`read-operations-query-optimization`
+   unique index
+      An index that enforces uniqueness for a particular field across
+      a single collection.
 
    unordered query plan
       Query plan that returns results in an order inconsistent with the
       :method:`~cursor.sort()` order.
 
-      .. seealso:: :ref:`read-operations-query-optimization`
-
-   sync
-
-      The :term:`replica set` operation where members replicate data
-      from the :term:`primary`.  Replica sets synchronize data at two
-      different points:
-
-      - :term:`Initial sync` occurs when MongoDB creates new databases on a
-        new or restored :term:`replica set` member, populating the
-        member with the replica set's data.
-
-      - "Replication" occurs continually after initial sync and keeps
-        the member updated with changes to the replica set's data.
-
-   initial sync
-      The :term:`replica set` operation that replicates data from an
-      existing replica set member to a new or restored replica set member.
-
-   GeoJSON
-      GeoJSON is a geospatial data interchange format based on
-      JavaScript Object Notation (JSON) and is used in geospatial
-      queries.  For supported GeoJSON objects, see
-      :ref:`geo-overview-location-data`.  For the GeoJSON format
-      specification, see <http://geojson.org/geojson-spec.html>.
+      See :ref:`read-operations-query-optimization`.
 
-   legacy coordinate pairs
-      The format used for geospatial data prior to MongoDB version 2.4.
-      This format stores geospatial data as points on a planar
-      coordinate system.
+   upsert
+      A kind of update that either updates the first document matched
+      in the provided query selector or, if no document matches,
+      inserts a new document having the fields implied by the
+      query selector and the update operation.
 
-   datum
-      A datum is a set of values used to define measurements on the
-      earth. MongoDB uses the :term:`WGS84` datum.
+   virtual memory
+      An application's working memory, typically residing on both
+      disk an in physical RAM.
 
    WGS84
       The default :term:`datum` MongoDB uses to calculate geometry over
-      an Earth-like sphere. MongoDB uses the WGS84 datum for geospatial
-      queries on :term:`GeoJSON` objects. See
+      an Earth-like sphere. MongoDB uses the WGS84 datum for
+      :term:`geospatial` queries on :term:`GeoJSON` objects. See
       <http://spatialreference.org/ref/epsg/4326/>.
 
-   Point
-      A point is a single coordinate pair, or "position," as described in `the
-      GeoJSON Point specification
-      <http://geojson.org/geojson-spec.html#point>`_.
-      
-   LineString 
-      A LineString is defined by an array of two or more positions. A
-      closed LineString with four or more positions is called a
-      LinearRing, as described in the `GeoJSON LineString
-      specification <http://geojson.org/geojson-spec.html#linestring>`_.
+   working set
+      The collection of data that MongoDB uses regularly. This data
+      is typically (or preferably) held in RAM.
 
-   Polygon 
-      A Polygon is defined by an array of :term:`LinearRing
-      <LineString>` coordinate arrays, as described in `the GeoJSON Polygon
-      specification <http://geojson.org/geojson-spec.html#polygon>`_.
-      For Polygons with multiple rings, the first **must** be the
-      exterior ring and any others must be interior rings or holes.
-      
-      MongoDB does not permit the exterior ring to self-intersect, and
-      interior rings must be fully contained within the outer loop and
-      cannot intersect or overlap with each other.
+   write concern
+      Specifies whether a write operation has succeeded. Write concern
+      allows your application to detect insertion errors or unavailable
+      :program:`mongod` instances. For :term:`replica sets <replica
+      set>`, you can configure write concern to confirm replication to a
+      specified number of members.
+
+      See :ref:`Write Concern <write-concern>`,
+      :doc:`/core/write-operations`, and :doc:`Write Concern for Replica
+      Sets </core/write-concern>`.
+
+   write-lock
+      A lock on the database for a given writer. When a process
+      writes to the database, it takes an exclusive write-lock to
+      prevent other processes from writing or reading.
+
+   writeBacks
+      The process within the sharding system that ensures that writes
+      issued to a :term:`shard` that isn't responsible for the
+      relevant chunk, get applied to the proper shard.
diff --git a/source/tutorial/use-database-commands.txt b/source/tutorial/use-database-commands.txt
index 4c891484e54..deef03db45a 100644
--- a/source/tutorial/use-database-commands.txt
+++ b/source/tutorial/use-database-commands.txt
@@ -25,6 +25,8 @@ specify the :dbcommand:`isMaster` command using the following
 
    { isMaster: 1 }
 
+.. _issue-commands:
+
 Issue Commands
 --------------