diff --git a/includes/cache.inc b/includes/cache.inc
index 9b60a7e..3f85e78 100644
--- a/includes/cache.inc
+++ b/includes/cache.inc
@@ -4,10 +4,28 @@
  * Factory for instantiating and statically caching the correct class for a cache bin.
  *
  * By default, this returns an instance of the DrupalDatabaseCache class.
- * Classes implementing DrupalCacheInterface can register themselves both as a
- * default implementation and for specific bins.
+ * Classes implementing DrupalCacheInterface can be used instead, either
+ * as a default for all cache requests, or for specific bins.
  *
- * @see DrupalCacheInterface
+ * Configuration of cache bins should be done in settings.php
+ *
+ * For example to use 'MyCustomCache' for the''page' bin. Set the following
+ * variables:
+ *
+ * @code
+ * $conf['cache_backends'] = array(
+ *  'DrupalDatabaseCache' => 'includes/cache.inc',
+ *  'MyCustomCache' => 'sites/all/modules/mycustomcache/MyCustomCache.inc',
+ * );
+ * $conf['cache_class_page'] = 'MyCustomCache',
+ * @endcode
+ *
+ * Additionally, you can register your cache implementation to be used by
+ * default for all cache bins by setting the variable 'cache_default_class' to
+ * the name of your implementation of the DrupalCacheInterface, e.g.
+ * @code
+ * $conf['cache_default_class'] = 'MyCustomCache';
+ * @endcode
  *
  * @param $bin
  *   The cache bin for which the cache object should be returned, defaults to
@@ -16,10 +34,6 @@
  *   The cache object associated with the specified bin.
  */
 function cache($bin = 'cache') {
-  // Temporary backwards compatibiltiy layer, allow old style prefixed cache
-  // bin names to be passed as arguments.
-  $bin = str_replace('cache_', '', $bin);
-
   // We do not use drupal_static() here because we do not want to change the
   // storage of a cache bin mid-request.
   static $cache_objects;
@@ -34,159 +48,15 @@ function cache($bin = 'cache') {
 }
 
 /**
- * Return data from the persistent cache
- *
- * Data may be stored as either plain text or as serialized data. cache_get
- * will automatically return unserialized objects and arrays.
- *
- * @param $cid
- *   The cache ID of the data to retrieve.
- * @param $bin
- *   The cache bin to store the data in. Valid core values are 'cache_block',
- *   'cache_bootstrap', 'cache_field', 'cache_filter', 'cache_form',
- *   'cache_menu', 'cache_page', 'cache_path', 'cache_update' or 'cache' for
- *   the default cache.
- *
- * @return
- *   The cache or FALSE on failure.
- */
-function cache_get($cid, $bin = 'cache') {
-  return cache($bin)->get($cid);
-}
-
-/**
- * Return data from the persistent cache when given an array of cache IDs.
- *
- * @param $cids
- *   An array of cache IDs for the data to retrieve. This is passed by
- *   reference, and will have the IDs successfully returned from cache removed.
- * @param $bin
- *   The cache bin where the data is stored.
- * @return
- *   An array of the items successfully returned from cache indexed by cid.
- */
-function cache_get_multiple(array &$cids, $bin = 'cache') {
-  return cache($bin)->getMultiple($cids);
-}
-
-/**
- * Store data in the persistent cache.
- *
- * The persistent cache is split up into several cache bins. In the default
- * cache implementation, each cache bin corresponds to a database table by the
- * same name. Other implementations might want to store several bins in data
- * structures that get flushed together. While it is not a problem for most
- * cache bins if the entries in them are flushed before their expire time, some
- * might break functionality or are extremely expensive to recalculate. These
- * will be marked with a (*). The other bins expired automatically by core.
- * Contributed modules can add additional bins and get them expired
- * automatically by implementing hook_flush_caches().
- *
- *  - cache: Generic cache storage bin (used for variables, theme registry,
- *  locale date, list of simpletest tests etc).
- *
- *  - cache_block: Stores the content of various blocks.
- *
- *  - cache field: Stores the field data belonging to a given object.
- *
- *  - cache_filter: Stores filtered pieces of content.
- *
- *  - cache_form(*): Stores multistep forms. Flushing this bin means that some
- *  forms displayed to users lose their state and the data already submitted
- *  to them.
- *
- *  - cache_menu: Stores the structure of visible navigation menus per page.
- *
- *  - cache_page: Stores generated pages for anonymous users. It is flushed
- *  very often, whenever a page changes, at least for every ode and comment
- *  submission. This is the only bin affected by the page cache setting on
- *  the administrator panel.
- *
- *  - cache path: Stores the system paths that have an alias.
- *
- *  - cache update(*): Stores available releases. The update server (for
- *  example, drupal.org) needs to produce the relevant XML for every project
- *  installed on the current site. As this is different for (almost) every
- *  site, it's very expensive to recalculate for the update server.
- *
- * The reasons for having several bins are as follows:
- *
- * - smaller bins mean smaller database tables and allow for faster selects and
- *   inserts
- * - we try to put fast changing cache items and rather static ones into
- *   different bins. The effect is that only the fast changing bins will need a
- *   lot of writes to disk. The more static bins will also be better cacheable
- *   with MySQL's query cache.
- *
- * @param $cid
- *   The cache ID of the data to store.
- * @param $data
- *   The data to store in the cache. Complex data types will be automatically
- *   serialized before insertion.
- *   Strings will be stored as plain text and not serialized.
- * @param $bin
- *   The cache bin to store the data in. Valid core values are 'cache_block',
- *   'cache_bootstrap', 'cache_field', 'cache_filter', 'cache_form',
- *   'cache_menu', 'cache_page', 'cache_update' or 'cache' for the default
- *   cache.
- * @param $expire
- *   One of the following values:
- *   - CACHE_PERMANENT: Indicates that the item should never be removed unless
- *     explicitly told to using cache_clear_all() with a cache ID.
- *   - CACHE_TEMPORARY: Indicates that the item should be removed at the next
- *     general cache wipe.
- *   - A Unix timestamp: Indicates that the item should be kept at least until
- *     the given time, after which it behaves like CACHE_TEMPORARY.
- */
-function cache_set($cid, $data, $bin = 'cache', $expire = CACHE_PERMANENT) {
-  return cache($bin)->set($cid, $data, $expire);
-}
-
-/**
- * Expire data from the cache.
- *
- * If called without arguments, expirable entries will be cleared from the
- * cache_page and cache_block bins.
- *
- * @param $cid
- *   If set, the cache ID to delete. Otherwise, all cache entries that can
- *   expire are deleted.
- *
- * @param $bin
- *   If set, the bin $bin to delete from. Mandatory
- *   argument if $cid is set.
- *
- * @param $wildcard
- *   If $wildcard is TRUE, cache IDs starting with $cid are deleted in
- *   addition to the exact cache ID specified by $cid.  If $wildcard is
- *   TRUE and $cid is '*' then the entire bin $bin is emptied.
+ * Expire temporary items from the page and block caches.
  */
-function cache_clear_all($cid = NULL, $bin = NULL, $wildcard = FALSE) {
-  if (!isset($cid) && !isset($bin)) {
-    // Clear the block cache first, so stale data will
-    // not end up in the page cache.
-    if (module_exists('block')) {
-      cache('block')->expire();
-    }
-    cache('page')->expire();
-    return;
+function cache_clear_all() {
+  if (module_exists('block')) {
+    // Clear the block cache first, so stale data will not end up in the page
+    // cache.
+    cache('block')->expire();
   }
-  return cache($bin)->clear($cid, $wildcard);
-}
-
-/**
- * Check if a cache bin is empty.
- *
- * A cache bin is considered empty if it does not contain any valid data for any
- * cache ID.
- *
- * @param $bin
- *   The cache bin to check.
- * @return
- *   TRUE if the cache bin specified is empty.
- */
-function cache_is_empty($bin) {
-  return cache($bin)->isEmpty();
+  cache('page')->expire();
 }
 
 /**
@@ -196,33 +66,6 @@ function cache_is_empty($bin) {
  * DrupalDatabaseCache provides the default implementation, which can be
  * consulted as an example.
  *
- * To make Drupal use your implementation for a certain cache bin, you have to
- * set a variable with the name of the cache bin as its key and the name of
- * your class as its value. For example, if your implementation of
- * DrupalCacheInterface was called MyCustomCache, the following line would make
- * Drupal use it for the 'cache_page' bin:
- * @code
- *  variable_set('cache_class_cache_page', 'MyCustomCache');
- * @endcode
- *
- * Additionally, you can register your cache implementation to be used by
- * default for all cache bins by setting the variable 'cache_default_class' to
- * the name of your implementation of the DrupalCacheInterface, e.g.
- * @code
- *  variable_set('cache_default_class', 'MyCustomCache');
- * @endcode
- *
- * To implement a completely custom cache bin, use the same variable format:
- * @code
- *  variable_set('cache_class_custom_bin', 'MyCustomCache');
- * @endcode
- * To access your custom cache bin, specify the name of the bin when storing
- * or retrieving cached data:
- * @code
- *  cache_set($cid, $data, 'custom_bin', $expire);
- *  cache_get($cid, 'custom_bin');
- * @endcode
- *
  * @see cache()
  * @see DrupalDatabaseCache
  */
@@ -237,7 +80,7 @@ interface DrupalCacheInterface {
 
   /**
    * Return data from the persistent cache. Data may be stored as either plain
-   * text or as serialized data. cache_get will automatically return
+   * text or as serialized data. Will automatically return
    * unserialized objects and arrays.
    *
    * @param $cid
@@ -319,23 +162,6 @@ interface DrupalCacheInterface {
   function garbageCollection();
 
   /**
-   * Expire data from the cache. If called without arguments, expirable
-   * entries will be cleared from the cache_page and cache_block bins.
-   *
-   * @param $cid
-   *   If set, the cache ID to delete. Otherwise, all cache entries that can
-   *   expire are deleted.
-   * @param $wildcard
-   *   If set to TRUE, the $cid is treated as a substring
-   *   to match rather than a complete ID. The match is a right hand
-   *   match. If '*' is given as $cid, the bin $bin will be emptied.
-   *
-   * @todo: this method is deprecated, as it's functionality is covered by
-   * more targetted methods in the interface.
-   */
-  function clear($cid = NULL, $wildcard = FALSE);
-
-  /**
    * Check if a cache bin is empty.
    *
    * A cache bin is considered empty if it does not contain any valid data for
@@ -408,7 +234,8 @@ class DrupalDatabaseCache implements DrupalCacheInterface {
    * data as appropriate.
    *
    * @param $cache
-   *   An item loaded from cache_get() or cache_get_multiple().
+   *   An item loaded from DrupalDatabaseCache::get() or 
+   *   DrupalDatabaseCache::getMultiple().
    * @return
    *   The item with data unserialized as appropriate or FALSE if there is no
    *   valid item to load.
@@ -459,7 +286,7 @@ class DrupalDatabaseCache implements DrupalCacheInterface {
         ->execute();
     }
     catch (Exception $e) {
-      // The database may not be available, so we'll ignore cache_set requests.
+      // The database may not be available, so we'll ignore these calls.
     }
   }
 
@@ -538,30 +365,6 @@ class DrupalDatabaseCache implements DrupalCacheInterface {
     }
   }
 
-  function clear($cid = NULL, $wildcard = FALSE) {
-    global $user;
-
-    if (empty($cid)) {
-      $this->expire();
-    }
-    else {
-      if ($wildcard) {
-        if ($cid == '*') {
-          $this->flush();
-        }
-        else {
-          $this->deletePrefix($cid);
-        }
-      }
-      elseif (is_array($cid)) {
-        $this->deleteMultiple($cid);
-      }
-      else {
-        $this->delete($cid);
-      }
-    }
-  }
-
   function isEmpty() {
     $this->garbageCollection();
     $query = db_select($this->bin);
diff --git a/includes/module.inc b/includes/module.inc
index cc3aa8e..047d5bd 100644
--- a/includes/module.inc
+++ b/includes/module.inc
@@ -640,10 +640,10 @@ function module_implements($hook, $sort = FALSE, $reset = FALSE) {
   // request. Benchmarks show that the benefit of this caching outweighs the
   // additional database hit even when using the default database caching
   // backend and only a small number of modules are enabled. The cost of the
-  // cache_get() is more or less constant and reduced further when non-database
-  // caching backends are used, so there will be more significant gains when a
-  // large number of modules are installed or hooks invoked, since this can
-  // quickly lead to module_hook() being called several thousand times
+  // cache('bootstrap')->get() is more or less constant and reduced further when
+  // non-database caching backends are used, so there will be more significant
+  // gains when a large number of modules are installed or hooks invoked, since
+  // this can quickly lead to module_hook() being called several thousand times
   // per request.
   if ($reset) {
     $implementations = array();
diff --git a/modules/field/field.attach.inc b/modules/field/field.attach.inc
index c643e40..2dc924f 100644
--- a/modules/field/field.attach.inc
+++ b/modules/field/field.attach.inc
@@ -634,7 +634,7 @@ function field_attach_load($entity_type, $entities, $age = FIELD_LOAD_CURRENT, $
     foreach ($entities as $id => $entity) {
       $cids[] = "field:$entity_type:$id";
     }
-    $cache = cache_get_multiple($cids, 'cache_field');
+    $cache = cache('cache_field')->getMultiple($cids);
     // Put the cached field values back into the entities and remove them from
     // the list of entities to query.
     foreach ($entities as $id => $entity) {
diff --git a/modules/system/system.install b/modules/system/system.install
index 6d80c43..8a29eda 100644
--- a/modules/system/system.install
+++ b/modules/system/system.install
@@ -1471,7 +1471,7 @@ function system_schema() {
         'default' => 0,
       ),
       'cache' => array(
-        'description' => "The time of this user's last post. This is used when the site has specified a minimum_cache_lifetime. See cache_get().",
+        'description' => "The time of this user's last post. This is used when the site has specified a minimum_cache_lifetime. See DrupalCacheInterface::get().",
         'type' => 'int',
         'not null' => TRUE,
         'default' => 0,
diff --git a/modules/update/update.module b/modules/update/update.module
index a2d705a..98c6ceb 100644
--- a/modules/update/update.module
+++ b/modules/update/update.module
@@ -724,10 +724,10 @@ function update_verify_update_archive($project, $archive_file, $directory) {
  * plug-able cache system that assumes volatile caches.
  *
  * Update module still uses the {cache_update} table, but instead of using
- * cache_set(), cache_get(), and cache_clear_all(), there are private helper
- * functions that implement these same basic tasks but ensure that the cache
- * is not prematurely cleared, and that the data is always stored in the
- * database, even if memcache or another cache backend is in use.
+ * the cache API, there are private helper functions that implement these same
+ * basic tasks but ensure that the cache is not prematurely cleared, and that
+ * the data is always stored in the database, even if memcache or another cache
+ * backend is in use.
  */
 
 /**