Merge remote-tracking branch 'origin/master' into restyle

sdiehl · sdiehl · commit 063b823e6512 · 2012-09-07T10:15:17.000-04:00
diff --git a/index.html b/index.html
@@ -261,7 +261,7 @@ <h2 id="synchronous-asynchronous-execution">Synchronous &amp; Asynchronous Execu
 Task 5 done
 </pre></code></p>
 <p>In the synchronous case all the tasks are run sequentially,
-which results in the main programming <em>blocking</em> (
+which results in the main program <em>blocking</em> (
 i.e. pausing the execution of the main program )
 while each task executes.</p>
 <p>The important parts of the program are the
@@ -319,7 +319,7 @@ <h2 id="synchronous-asynchronous-execution">Synchronous &amp; Asynchronous Execu
 <h2 id="determinism">Determinism</h2>
 <p>As mentioned previously, greenlets are deterministic. Given the same
 configuration of greenlets and the same set of inputs and they always
-produce the same output. For example lets spread a task across a
+produce the same output. For example let's spread a task across a
 multiprocessing pool compared to a gevent pool.</p>
 <pre>
 <code class="python">
@@ -644,7 +644,7 @@ <h2 id="events">Events</h2>
 </code>
 </pre>
 
-<p>A extension of the Event object is the AsyncResult which
+<p>An extension of the Event object is the AsyncResult which
 allows you to send a value along with the wakeup call. This is
 sometimes called a future or a deferred, since it holds a 
 reference to a future value that can be set on an arbitrary time
@@ -745,7 +745,7 @@ <h2 id="queues">Queues</h2>
 counterpart, <code>put_nowait</code> and 
 <code>get_nowait</code> which will not block, but instead raise
 either <code>gevent.queue.Empty</code> or
-<code>gevent.queue.Full</code> in the operation is not possible.</p>
+<code>gevent.queue.Full</code> if the operation is not possible.</p>
 <p>In this example we have the boss running simultaneously to the
 workers and have a restriction on the Queue that it can contain no
 more than three elements. This restriction means that the <code>put</code>
@@ -821,7 +821,7 @@ <h2 id="queues">Queues</h2>
 </pre></code></p>
 <h2 id="groups-and-pools">Groups and Pools</h2>
 <p>A group is a collection of running greenlets which are managed
-and scheduled together as group. It also doubles as parallel
+and scheduled together as group. It also doubles as a parallel
 dispatcher that mirrors the Python <code>multiprocessing</code> library.</p>
 <pre><code class="python">
 import gevent
@@ -856,9 +856,9 @@ <h2 id="groups-and-pools">Groups and Pools</h2>
 fizz
 fizz
 </pre></code></p>
-<p>This is very usefull for managing groups of asynchronous tasks
-that.</p>
-<p>As mentioned above Group also provides an API for dispatching
+<p>This is very useful for managing groups of asynchronous tasks
+that run in parallel.</p>
+<p>As mentioned above, Group also provides an API for dispatching
 jobs to grouped greenlets and collecting their results in various
 ways.</p>
 <pre><code class="python">
@@ -963,8 +963,8 @@ <h2 id="groups-and-pools">Groups and Pools</h2>
 <h2 id="locks-and-semaphores">Locks and Semaphores</h2>
 <p>A semaphore is a low level synchronization primitive that allows
 greenlets to coordinate and limit concurrent access or execution. A
-semaphore exposes two methods, <code>acquire</code> and <code>release</code> The
-difference between the number of times and a semaphore has been
+semaphore exposes two methods, <code>acquire</code> and <code>release</code>.
+The difference between the number of times and a semaphore has been
 acquired and released is called the bound of the semaphore. If a
 semaphore bound reaches 0 it will block until another greenlet
 releases its acquisition.</p>
@@ -1006,7 +1006,7 @@ <h2 id="locks-and-semaphores">Locks and Semaphores</h2>
 Worker 5 acquired semaphore
 Worker 5 released semaphore
 </pre></code></p>
-<p>A semaphore with bound of 1 is known as a Lock. it provides
+<p>A semaphore with bound of 1 is known as a Lock. It provides
 exclusive execution to one greenlet. They are often used to
 ensure that resources are only in use at one time in the context
 of a program.</p>
@@ -1083,7 +1083,7 @@ <h2 id="gevent-zeromq">Gevent ZeroMQ</h2>
 distributed applications. </p>
 <p>ZeroMQ provides a variety of socket primitives, the simplest of
 which being a Request-Response socket pair. A socket has two
-methods of interest <code>send</code> and <code>recv</code>, both of which are
+methods of interest: <code>send</code> and <code>recv</code>, both of which are
 normally blocking operations. But this is remedied by a briliant
 library by <a href="https://github.com/traviscline">Travis Cline</a> which
 uses gevent.socket to poll ZeroMQ sockets in a non-blocking
@@ -1451,4 +1451,4 @@ <h2 id="chat-server">Chat Server</h2>
 </div>
 
 </body>
-</html>
+</html>
diff --git a/tutorial.md b/tutorial.md
@@ -282,7 +282,7 @@ modify this value. This results in resources whose values become
 time-dependent on the execution order. This is a problem, and in
 general one should very much try to avoid race conditions since
 they result program behavior which is globally
-non-deterministic.*
+non-deterministic.
 
 The best approach to this is to simply avoid all global state all
 times. Global state and import-time side effects will always come
@@ -324,7 +324,7 @@ gevent.joinall(threads)
 [[[end]]]
 
 In addition to using the base Greenlet class, you may also subclass
-Greenlet class and overload the ``_run`` method.
+Greenlet class and override the ``_run`` method.
 
 [[[cog
 import gevent
@@ -457,7 +457,7 @@ except Timeout:
 </code>
 </pre>
 
-Or with a context manager in a ``with`` a statement.
+Or with a context manager in a ``with`` statement.
 
 <pre>
 <code class="python">import gevent
