--- SQLBuilder.new.txt	2010-12-15 23:16:11.000000000 +0100
+++ SQLBuilder.txt	2010-12-15 22:06:08.000000000 +0100
@@ -16,9 +16,9 @@
 expressions build SQL expressions -- so long as you start with a Magic
 Object that knows how to fake it.
 
-With SQLObject, you get a Magic Object by accessing the ``q`` attribute
+With SQLObject, you get a Magic Object by access the ``q`` attribute
 of a table class -- this gives you an object that represents the
-field. All of this is probably easier to grasp in an example::
+field.  Maybe explanations aren't as good.  Here's some examples::
 
     >>> from sqlobject.sqlbuilder import *
     >>> person = table.person
@@ -52,13 +52,13 @@
 also work -- I find these easier to work with.  ``AND`` and ``OR`` can
 take any number of arguments.
 
-You can also use ``.startswith()`` and ``.endswith()`` on an SQL
+You can also use ``.startswith()`` and ``.endswith()`` on a SQL
 expression -- these will translate to appropriate ``LIKE`` statements
-and all ``%`` quoting is handled for you, so you can ignore that
-implementation detail.  There is also a ``LIKE`` function, where you
+(but all ``%`` quoting is handled for you, so you can ignore that
+implementation detail).  There is also a ``LIKE`` function, where you
 can pass your string, with ``%`` for the wildcard, as usual.
 
-If you want to access an SQL function, use the ``func`` variable,
+If you want to access a SQL function, use the ``func`` variable,
 like::
 
     >> person.created < func.NOW()
@@ -71,7 +71,7 @@
 
 SQLBuilder implements objects that execute SQL statements. SQLObject
 uses them internally in its `higher-level API`_, but users can use this
-mid-level API to execute SQL queries that are not supported by the
+mid-level API to executes SQL queries that aren't supported by the
 high-level API. To use these objects first construct an instance of a
 statement object, then ask the connection to convert the instance to an
 SQL query and finally ask the connection to execute the query and return