diff --git a/docs/topics/class-based-views/index.txt b/docs/topics/class-based-views/index.txt
index c2900ec..1f10935 100644
--- a/docs/topics/class-based-views/index.txt
+++ b/docs/topics/class-based-views/index.txt
@@ -11,8 +11,7 @@ to structure your views and reuse code by harnessing inheritance and
 mixins. There are also some generic views for simple tasks which we'll
 get to later, but you may want to design your own structure of
 reusable views which suits your use case. For full details, see the
-:doc:`class-based views reference
-documentation</ref/class-based-views/index>`.
+:doc:`class-based views reference documentation</ref/class-based-views/index>`.
 
 .. toctree::
    :maxdepth: 1
@@ -32,41 +31,12 @@ redirect, and :class:`~django.views.generic.base.TemplateView` extends the base
 to make it also render a template.
 
 
-Simple usage
-============
-
-Class-based generic views (and any class-based views that inherit from
-the base classes Django provides) can be configured in two
-ways: subclassing, or passing in arguments directly in the URLconf.
-
-When you subclass a class-based view, you can override attributes
-(such as the ``template_name``) or methods (such as ``get_context_data``)
-in your subclass to provide new values or methods. Consider, for example,
-a view that just displays one template, ``about.html``. Django has a
-generic view to do this - :class:`~django.views.generic.base.TemplateView` -
-so we can just subclass it, and override the template name::
-
-    # some_app/views.py
-    from django.views.generic import TemplateView
-
-    class AboutView(TemplateView):
-        template_name = "about.html"
-
-Then, we just need to add this new view into our URLconf. As the class-based
-views themselves are classes, we point the URL to the ``as_view`` class method
-instead, which is the entry point for class-based views::
-
-    # urls.py
-    from django.conf.urls import patterns, url, include
-    from some_app.views import AboutView
-
-    urlpatterns = patterns('',
-        (r'^about/', AboutView.as_view()),
-    )
+Simple usage in your URLconf
+============================
 
-Alternatively, if you're only changing a few simple attributes on a
-class-based view, you can simply pass the new attributes into the ``as_view``
-method call itself::
+The simplest way to use generic views is to create them directly in your
+URLconf. If you're only changing a few simple attributes on a class-based view,
+you can simply pass them into the ``as_view`` method call itself::
 
     from django.conf.urls import patterns, url, include
     from django.views.generic import TemplateView
@@ -75,93 +45,41 @@ method call itself::
         (r'^about/', TemplateView.as_view(template_name="about.html")),
     )
 
+Any arguments given will override the ``template_name`` on the 
 A similar overriding pattern can be used for the ``url`` attribute on
 :class:`~django.views.generic.base.RedirectView`.
 
-.. _jsonresponsemixin-example:
-
-More than just HTML
--------------------
-
-Where class based views shine is when you want to do the same thing many times.
-Suppose you're writing an API, and every view should return JSON instead of
-rendered HTML.
-
-We can create a mixin class to use in all of our views, handling the
-conversion to JSON once.
 
-For example, a simple JSON mixin might look something like this::
+Subclassing generic views
+=========================
 
-    import json
-    from django.http import HttpResponse
+The second, more powerful way to use generic views is to inherit from an
+existing view and override attributes (such as the ``template_name``) or
+methods (such as ``get_context_data``) in your subclass to provide new values
+or methods. Consider, for example, a view that just displays one template,
+``about.html``. Django has a generic view to do this -
+:class:`~django.views.generic.base.TemplateView` - so we can just subclass it,
+and override the template name::
 
-    class JSONResponseMixin(object):
-        """
-        A mixin that can be used to render a JSON response.
-        """
-        response_class = HttpResponse
+    # some_app/views.py
+    from django.views.generic import TemplateView
 
-        def render_to_response(self, context, **response_kwargs):
-            """
-            Returns a JSON response, transforming 'context' to make the payload.
-            """
-            response_kwargs['content_type'] = 'application/json'
-            return self.response_class(
-                self.convert_context_to_json(context),
-                **response_kwargs
-            )
+    class AboutView(TemplateView):
+        template_name = "about.html"
 
-        def convert_context_to_json(self, context):
-            "Convert the context dictionary into a JSON object"
-            # Note: This is *EXTREMELY* naive; in reality, you'll need
-            # to do much more complex handling to ensure that arbitrary
-            # objects -- such as Django model instances or querysets
-            # -- can be serialized as JSON.
-            return json.dumps(context)
+Then we just need to add this new view into our URLconf. 
+`~django.views.generic.base.TemplateView` is a class, not a function, so we
+point the URL to the ``as_view`` class method instead, which provides a
+function-like entry to class-based views::
 
-Now we mix this into the base TemplateView::
+    # urls.py
+    from django.conf.urls import patterns, url, include
+    from some_app.views import AboutView
 
-    from django.views.generic import TemplateView
+    urlpatterns = patterns('',
+        (r'^about/', AboutView.as_view()),
+    )
 
-    class JSONView(JSONResponseMixin, TemplateView):
-        pass
-
-Equally we could use our mixin with one of the generic views. We can make our
-own version of :class:`~django.views.generic.detail.DetailView` by mixing
-:class:`JSONResponseMixin` with the
-:class:`~django.views.generic.detail.BaseDetailView` -- (the
-:class:`~django.views.generic.detail.DetailView` before template
-rendering behavior has been mixed in)::
-
-    class JSONDetailView(JSONResponseMixin, BaseDetailView):
-        pass
-
-This view can then be deployed in the same way as any other
-:class:`~django.views.generic.detail.DetailView`, with exactly the
-same behavior -- except for the format of the response.
-
-If you want to be really adventurous, you could even mix a
-:class:`~django.views.generic.detail.DetailView` subclass that is able
-to return *both* HTML and JSON content, depending on some property of
-the HTTP request, such as a query argument or a HTTP header. Just mix
-in both the :class:`JSONResponseMixin` and a
-:class:`~django.views.generic.detail.SingleObjectTemplateResponseMixin`,
-and override the implementation of :func:`render_to_response()` to defer
-to the appropriate subclass depending on the type of response that the user
-requested::
-
-    class HybridDetailView(JSONResponseMixin, SingleObjectTemplateResponseMixin, BaseDetailView):
-        def render_to_response(self, context):
-            # Look for a 'format=json' GET argument
-            if self.request.GET.get('format','html') == 'json':
-                return JSONResponseMixin.render_to_response(self, context)
-            else:
-                return SingleObjectTemplateResponseMixin.render_to_response(self, context)
-
-Because of the way that Python resolves method overloading, the local
-``render_to_response()`` implementation will override the versions provided by
-:class:`JSONResponseMixin` and
-:class:`~django.views.generic.detail.SingleObjectTemplateResponseMixin`.
 
 For more information on how to use the built in generic views, consult the next
 topic on :doc:`generic class based views</topics/class-based-views/generic-display>`.
@@ -171,16 +89,16 @@ Decorating class-based views
 
 .. highlightlang:: python
 
-The extension of class-based views isn't limited to using mixins. You
-can use also use decorators.
+Since class-based views aren't functions, decorating them works differently
+depending on if you're using ``as_view`` or want to apply the decorator 
+more widely.
 
 Decorating in URLconf
 ---------------------
 
 The simplest way of decorating class-based views is to decorate the
 result of the :meth:`~django.views.generic.base.View.as_view` method.
-The easiest place to do this is in the URLconf where you deploy your
-view::
+The easiest place to do this is in the URLconf where you deploy your view::
 
     from django.contrib.auth.decorators import login_required, permission_required
     from django.views.generic import TemplateView
@@ -231,3 +149,4 @@ login protection.
     as parameters to the decorated method on the class. If your method
     does not accept a compatible set of parameters it will raise a
     ``TypeError`` exception.
+
diff --git a/docs/topics/class-based-views/mixins.txt b/docs/topics/class-based-views/mixins.txt
index 0c19d60..937a5fe 100644
--- a/docs/topics/class-based-views/mixins.txt
+++ b/docs/topics/class-based-views/mixins.txt
@@ -27,8 +27,95 @@ encapsulated in the
 reference documentation contains :doc:`full documentation of all the
 mixins</ref/class-based-views/mixins>`.
 
+
+.. _jsonresponsemixin-example:
+
+More than just HTML
+-------------------
+
+Where class based views shine is when you want to do the same thing many times.
+Suppose you're writing an API, and every view should return JSON instead of
+rendered HTML.
+
+We can create a mixin class to use in all of our views, handling the
+conversion to JSON once.
+
+For example, a simple JSON mixin might look something like this::
+
+    import json
+    from django.http import HttpResponse
+
+    class JSONResponseMixin(object):
+        """
+        A mixin that can be used to render a JSON response.
+        """
+        response_class = HttpResponse
+
+        def render_to_response(self, context, **response_kwargs):
+            """
+            Returns a JSON response, transforming 'context' to make the payload.
+            """
+            response_kwargs['content_type'] = 'application/json'
+            return self.response_class(
+                self.convert_context_to_json(context),
+                **response_kwargs
+            )
+
+        def convert_context_to_json(self, context):
+            "Convert the context dictionary into a JSON object"
+            # Note: This is *EXTREMELY* naive; in reality, you'll need
+            # to do much more complex handling to ensure that arbitrary
+            # objects -- such as Django model instances or querysets
+            # -- can be serialized as JSON.
+            return json.dumps(context)
+
+Now we mix this into the base TemplateView::
+
+    from django.views.generic import TemplateView
+
+    class JSONView(JSONResponseMixin, TemplateView):
+        pass
+
+Equally we could use our mixin with one of the generic views. We can make our
+own version of :class:`~django.views.generic.detail.DetailView` by mixing
+:class:`JSONResponseMixin` with the
+:class:`~django.views.generic.detail.BaseDetailView` -- (the
+:class:`~django.views.generic.detail.DetailView` before template
+rendering behavior has been mixed in)::
+
+    class JSONDetailView(JSONResponseMixin, BaseDetailView):
+        pass
+
+This view can then be deployed in the same way as any other
+:class:`~django.views.generic.detail.DetailView`, with exactly the
+same behavior -- except for the format of the response.
+
+If you want to be really adventurous, you could even mix a
+:class:`~django.views.generic.detail.DetailView` subclass that is able
+to return *both* HTML and JSON content, depending on some property of
+the HTTP request, such as a query argument or a HTTP header. Just mix
+in both the :class:`JSONResponseMixin` and a
+:class:`~django.views.generic.detail.SingleObjectTemplateResponseMixin`,
+and override the implementation of :func:`render_to_response()` to defer
+to the appropriate subclass depending on the type of response that the user
+requested::
+
+    class HybridDetailView(JSONResponseMixin, SingleObjectTemplateResponseMixin, BaseDetailView):
+        def render_to_response(self, context):
+            # Look for a 'format=json' GET argument
+            if self.request.GET.get('format','html') == 'json':
+                return JSONResponseMixin.render_to_response(self, context)
+            else:
+                return SingleObjectTemplateResponseMixin.render_to_response(self, context)
+
+Because of the way that Python resolves method overloading, the local
+``render_to_response()`` implementation will override the versions provided by
+:class:`JSONResponseMixin` and
+:class:`~django.views.generic.detail.SingleObjectTemplateResponseMixin`.
+
+
 Context and template responses
-==============================
+------------------------------
 
 Two central mixins are provided that help in providing a consistent
 interface to working with templates in class-based views.
@@ -69,7 +156,7 @@ interface to working with templates in class-based views.
     add more members to the dictionary.
 
 Building up Django's generic class-based views
-===============================================
+----------------------------------------------
 
 Let's look at how two of Django's generic class-based views are built
 out of mixins providing discrete functionality. We'll consider
@@ -91,7 +178,7 @@ covered in the :doc:`mixin reference
 documentation</ref/class-based-views/mixins>`.
 
 DetailView: working with a single Django object
------------------------------------------------
+===============================================
 
 To show the detail of an object, we basically need to do two things:
 we need to look up the object and then we need to make a
@@ -128,7 +215,7 @@ views<generic-editing>` use ``_form`` for create and update views, and
 ``_confirm_delete`` for delete views.)
 
 ListView: working with many Django objects
-------------------------------------------
+==========================================
 
 Lists of objects follow roughly the same pattern: we need a (possibly
 paginated) list of objects, typically a :class:`QuerySet`, and then we need
