Merge pull request visionmedia#18 from grantheaslip/master

Fixed some typos, cleaned up awkward/unclear sentences

Author: tj

book.html

@@ -1,8 +1,8 @@
 <div class='mp'>
 <h1>Buffers</h1>
-<p> To handle binary data, node provides us with the global <code>Buffer</code> object. Buffer instances represent memory allocated independently to that of V8's heap. There are several ways to construct a <code>Buffer</code> instance, and many ways you can manipulate it's data.</p>
+<p> To handle binary data, node provides us with the global <code>Buffer</code> object. <code>Buffer</code> instances represent memory allocated independently of V8's heap. There are several ways to construct a <code>Buffer</code> instance, and many ways you can manipulate its data.</p>
 
-<p>The simplest way to construct a <code>Buffer</code> from a string is to simply pass a string as the first argument. As you can see by the log output, we now have a buffer object containing 5 bytes of data represented in hexadecimal.</p>
+<p>The simplest way to construct a <code>Buffer</code> from a string is to simply pass a string as the first argument. As you can see in the log output, we now have a buffer object containing 5 bytes of data represented in hexadecimal.</p>
 
 <pre><code>var hello = new Buffer('Hello');
 
@@ -13,7 +13,7 @@ <h1>Buffers</h1>
 // =&gt; "Hello"
 </code></pre>
 
-<p>By default the encoding is "utf8", however this can be specified by passing as string as the second argument. The ellipsis below for example will be printed to stdout as the '&amp;' character when in "ascii" encoding.</p>
+<p>By default, the encoding is "utf8", but this can be overridden by passing a string as the second argument. For example, the ellipsis below will be printed to stdout as the "&amp;" character when in "ascii" encoding.</p>
 
 <pre><code>var buf = new Buffer('…');
 console.log(buf.toString());
@@ -24,12 +24,12 @@ <h1>Buffers</h1>
 // =&gt; &amp;
 </code></pre>
 
-<p>An alternative method is to pass an array of integers representing the octet stream, however in this case functionality equivalent.</p>
+<p>An alternative (but in this case functionality equivalent) method is to pass an array of integers representing the octet stream.</p>
 
 <pre><code>var hello = new Buffer([0x48, 0x65, 0x6c, 0x6c, 0x6f]);
 </code></pre>
 
-<p>Buffers can also be created with an integer representing the number of bytes allocated, after which we may call the <code>write()</code> method, providing an optional offset and encoding. As shown below we provide the offset of 2 bytes to our second call to <code>write()</code>, buffering "Hel", and then we continue on to write another two bytes with an offset of 3, completing "Hello".</p>
+<p>Buffers can also be created with an integer representing the number of bytes allocated, after which we can call the <code>write()</code> method, providing an optional offset and encoding. Below, we provide an offset of 2 bytes to our second call to <code>write()</code> (buffering "Hel") and then write another two bytes with an offset of 3 (completing "Hello").</p>
 
 <pre><code>var buf = new Buffer(5);
 buf.write('He');
@@ -39,7 +39,7 @@ <h1>Buffers</h1>
 // =&gt; "Hello"
 </code></pre>
 
-<p>The <code>.length</code> property of a buffer instance contains the byte length of the stream, opposed to JavaScript strings which will simply return the number of characters. For example the ellipsis character '…' consists of three bytes, however the buffer will respond with the byte length, and not the character length.</p>
+<p>The <code>.length</code> property of a buffer instance contains the byte length of the stream, as opposed to native strings, which simply return the number of characters. For example, the ellipsis character '…' consists of three bytes, so the buffer will respond with the byte length (3), and not the character length (1).</p>
 
 <pre><code>var ellipsis = new Buffer('…', 'utf8');
 
@@ -53,16 +53,16 @@ <h1>Buffers</h1>
 // =&gt; &lt;Buffer e2 80 a6>
 </code></pre>
 
-<p>When dealing with JavaScript strings, we may pass it to the <code>Buffer.byteLength()</code> method to determine it's byte length.</p>
+<p>To determine the byte length of a native string, pass it to the <code>Buffer.byteLength()</code> method.</p>
 
-<p>The api is written in such a way that it is String-like, so for example we can work with "slices" of a <code>Buffer</code> by passing offsets to the <code>slice()</code> method:</p>
+<p>The API is written in such a way that it is String-like. For example, we can work with "slices" of a <code>Buffer</code> by passing offsets to the <code>slice()</code> method:</p>
 
 <pre><code>var chunk = buf.slice(4, 9);
 console.log(chunk.toString());
 // =&gt; "some"
 </code></pre>
 
-<p>Alternatively when expecting a string we can pass offsets to <code>Buffer#toString()</code>:</p>
+<p>Alternatively, when expecting a string, we can pass offsets to <code>Buffer#toString()</code>:</p>
 
 <pre><code>var buf = new Buffer('just some data');
 console.log(buf.toString('ascii', 4, 9));

chapters/buffers.html

@@ -1,9 +1,9 @@
 
 # Buffers
 
- To handle binary data, node provides us with the global `Buffer` object. Buffer instances represent memory allocated independently to that of V8's heap. There are several ways to construct a `Buffer` instance, and many ways you can manipulate it's data.
+ To handle binary data, node provides us with the global `Buffer` object. `Buffer` instances represent memory allocated independently of V8's heap. There are several ways to construct a `Buffer` instance, and many ways you can manipulate its data.
 
-The simplest way to construct a `Buffer` from a string is to simply pass a string as the first argument. As you can see by the log output, we now have a buffer object containing 5 bytes of data represented in hexadecimal.
+The simplest way to construct a `Buffer` from a string is to simply pass a string as the first argument. As you can see in the log output, we now have a buffer object containing 5 bytes of data represented in hexadecimal.
 
     var hello = new Buffer('Hello');
 
@@ -13,7 +13,7 @@ The simplest way to construct a `Buffer` from a string is to simply pass a strin
     console.log(hello.toString());
     // => "Hello"
 
-By default the encoding is "utf8", however this can be specified by passing as string as the second argument. The ellipsis below for example will be printed to stdout as the '&' character when in "ascii" encoding.
+By default, the encoding is "utf8", but this can be overridden by passing a string as the second argument. For example, the ellipsis below will be printed to stdout as the "&" character when in "ascii" encoding.
 
     var buf = new Buffer('…');
     console.log(buf.toString());
@@ -23,11 +23,11 @@ By default the encoding is "utf8", however this can be specified by passing as s
     console.log(buf.toString());
     // => &
 
-An alternative method is to pass an array of integers representing the octet stream, however in this case functionality equivalent.
+An alternative (but in this case functionality equivalent) method is to pass an array of integers representing the octet stream.
 
     var hello = new Buffer([0x48, 0x65, 0x6c, 0x6c, 0x6f]);
 
-Buffers can also be created with an integer representing the number of bytes allocated, after which we may call the `write()` method, providing an optional offset and encoding. As shown below we provide the offset of 2 bytes to our second call to `write()`, buffering "Hel", and then we continue on to write another two bytes with an offset of 3, completing "Hello".
+Buffers can also be created with an integer representing the number of bytes allocated, after which we can call the `write()` method, providing an optional offset and encoding. Below, we provide an offset of 2 bytes to our second call to `write()` (buffering "Hel") and then write another two bytes with an offset of 3 (completing "Hello").
 
     var buf = new Buffer(5);
     buf.write('He');
@@ -36,7 +36,7 @@ Buffers can also be created with an integer representing the number of bytes all
     console.log(buf.toString());
     // => "Hello"
 
-The `.length` property of a buffer instance contains the byte length of the stream, opposed to JavaScript strings which will simply return the number of characters. For example the ellipsis character '…' consists of three bytes, however the buffer will respond with the byte length, and not the character length.
+The `.length` property of a buffer instance contains the byte length of the stream, as opposed to native strings, which simply return the number of characters. For example, the ellipsis character '…' consists of three bytes, so the buffer will respond with the byte length (3), and not the character length (1).
 
     var ellipsis = new Buffer('…', 'utf8');
 
@@ -49,17 +49,16 @@ The `.length` property of a buffer instance contains the byte length of the stre
     console.log(ellipsis);
     // => <Buffer e2 80 a6>
 
-When dealing with JavaScript strings, we may pass it to the `Buffer.byteLength()` method to determine it's byte length.
+To determine the byte length of a native string, pass it to the `Buffer.byteLength()` method.
 
-The api is written in such a way that it is String-like, so for example we can work with "slices" of a `Buffer` by passing offsets to the `slice()` method:
+The API is written in such a way that it is String-like. For example, we can work with "slices" of a `Buffer` by passing offsets to the `slice()` method:
 
     var chunk = buf.slice(4, 9);
     console.log(chunk.toString());
     // => "some"
 
-Alternatively when expecting a string we can pass offsets to `Buffer#toString()`:
+Alternatively, when expecting a string, we can pass offsets to `Buffer#toString()`:
 
     var buf = new Buffer('just some data');
     console.log(buf.toString('ascii', 4, 9));
     // => "some"
-

chapters/buffers.md

@@ -1,10 +1,10 @@
 <div class='mp'>
 <h1>Events</h1>
-<p> The concept of an "event" is crucial to node, and used greatly throughout core and 3rd-party modules. Node's core module <em>events</em> supplies us with a single constructor, <em>EventEmitter</em>.</p>
+<p> The concept of an "event" is crucial to node, and is used heavily throughout core and 3rd-party modules. Node's core module <em>events</em> supplies us with a single constructor, <em>EventEmitter</em>.</p>
 
 <h2 id="Emitting-Events">Emitting Events</h2>
 
-<p>Typically an object inherits from <em>EventEmitter</em>, however our small example below illustrates the api. First we create an <code>emitter</code>, after which we can define any number of callbacks using the <code>emitter.on()</code> method which accepts the <em>name</em> of the event, and arbitrary objects passed as data. When <code>emitter.emit()</code> is called we are only required to pass the event <em>name</em>, followed by any number of arguments, in this case the <code>first</code> and <code>last</code> name strings.</p>
+<p>Typically an object inherits from <em>EventEmitter</em>, however our small example below illustrates the API. First we create an <code>emitter</code>, after which we can define any number of callbacks using the <code>emitter.on()</code> method, which accepts the <em>name</em> of the event and arbitrary objects passed as data. When <code>emitter.emit()</code> is called, we are only required to pass the event <em>name</em>, followed by any number of arguments (in this case the <code>first</code> and <code>last</code> name strings).</p>
 
 <pre><code>var EventEmitter = require('events').EventEmitter;
 
@@ -20,9 +20,9 @@ <h2 id="Emitting-Events">Emitting Events</h2>
 
 <h2 id="Inheriting-From-EventEmitter">Inheriting From EventEmitter</h2>
 
-<p>A perhaps more practical use of <code>EventEmitter</code>, and commonly used throughout node is to inherit from it. This means we can leave <code>EventEmitter</code>'s prototype untouched, while utilizing its api for our own means of world domination!</p>
+<p>A more practical and common use of <code>EventEmitter</code> is to inherit from it. This means we can leave <code>EventEmitter</code>'s prototype untouched while utilizing its API for our own means of world domination!</p>
 
-<p>To do so we begin by defining the <code>Dog</code> constructor, which of course will bark from time to time, also known as an <em>event</em>.</p>
+<p>To do so, we begin by defining the <code>Dog</code> constructor, which of course will bark from time to time (also known as an <em>event</em>).</p>
 
 <pre><code>var EventEmitter = require('events').EventEmitter;
 
@@ -31,12 +31,12 @@ <h2 id="Inheriting-From-EventEmitter">Inheriting From EventEmitter</h2>
 }
 </code></pre>
 
-<p>Here we inherit from <code>EventEmitter</code>, so that we may use the methods provided such as <code>EventEmitter#on()</code> and <code>EventEmitter#emit()</code>. If the <code>__proto__</code> property is throwing you off, no worries! we will be touching on this later.</p>
+<p>Here we inherit from <code>EventEmitter</code> so we can use the methods it provides, such as <code>EventEmitter#on()</code> and <code>EventEmitter#emit()</code>. If the <code>__proto__</code> property is throwing you off, don't worry, we'll be coming back to this later.</p>
 
 <pre><code>Dog.prototype.__proto__ = EventEmitter.prototype;
 </code></pre>
 
-<p>Now that we have our <code>Dog</code> set up, we can create .... simon! When simon barks we can let <em>stdout</em> know by calling <code>console.log()</code> within the callback. The callback it-self is called in context to the object, aka <code>this</code>.</p>
+<p>Now that we have our <code>Dog</code> set up, we can create... Simon! When Simon barks, we can let <em>stdout</em> know by calling <code>console.log()</code> within the callback. The callback itself is called in the context of the object (aka <code>this</code>).</p>
 
 <pre><code>var simon = new Dog('simon');
 
@@ -45,7 +45,7 @@ <h2 id="Inheriting-From-EventEmitter">Inheriting From EventEmitter</h2>
 });
 </code></pre>
 
-<p>Bark twice a second:</p>
+<p>Bark twice per second:</p>
 
 <pre><code>setInterval(function(){
     simon.emit('bark');
@@ -54,7 +54,7 @@ <h2 id="Inheriting-From-EventEmitter">Inheriting From EventEmitter</h2>
 
 <h2 id="Removing-Event-Listeners">Removing Event Listeners</h2>
 
-<p>As we have seen event listeners are simply functions which are called when we <code>emit()</code> an event. Although not seen often we can remove these listeners by calling the <code>removeListener(type, callback)</code> method. In the example below we emit the <em>message</em> "foo bar" every <code>300</code> milliseconds, which has the callback of <code>console.log()</code>. After 1000 milliseconds we call <code>removeListener()</code> with the same arguments that we passed to <code>on()</code> originally. To compliment this method is <code>removeAllListeners(type)</code> which removes all listeners associated to the given <em>type</em>.</p>
+<p>As we have seen, event listeners are simply functions which are called when we <code>emit()</code> an event. We can remove these listeners by calling the <code>removeListener(type, callback)</code> method, although this isn't seen often. In the example below we emit the <em>message</em> "foo bar" every <code>300</code> milliseconds, which has a callback of <code>console.log()</code>. After 1000 milliseconds, we call <code>removeListener()</code> with the same arguments that we passed to <code>on()</code> originally. We could also have used <code>removeAllListeners(type)</code>, which removes all listeners registered to the given <em>type</em>.</p>
 
 <pre><code>var EventEmitter = require('events').EventEmitter;
 

chapters/events.html

@@ -1,11 +1,11 @@
 
 # Events
 
- The concept of an "event" is crucial to node, and used greatly throughout core and 3rd-party modules. Node's core module _events_ supplies us with a single constructor, _EventEmitter_.
+ The concept of an "event" is crucial to node, and is used heavily throughout core and 3rd-party modules. Node's core module _events_ supplies us with a single constructor, _EventEmitter_.
 
 ## Emitting Events
 
-Typically an object inherits from _EventEmitter_, however our small example below illustrates the api. First we create an `emitter`, after which we can define any number of callbacks using the `emitter.on()` method which accepts the _name_ of the event, and arbitrary objects passed as data. When `emitter.emit()` is called we are only required to pass the event _name_, followed by any number of arguments, in this case the `first` and `last` name strings.
+Typically an object inherits from _EventEmitter_, however our small example below illustrates the API. First we create an `emitter`, after which we can define any number of callbacks using the `emitter.on()` method, which accepts the _name_ of the event and arbitrary objects passed as data. When `emitter.emit()` is called, we are only required to pass the event _name_, followed by any number of arguments (in this case the `first` and `last` name strings).
 
 	var EventEmitter = require('events').EventEmitter;
 
@@ -20,37 +20,37 @@ Typically an object inherits from _EventEmitter_, however our small example belo
 
 ## Inheriting From EventEmitter
 
-A perhaps more practical use of `EventEmitter`, and commonly used throughout node is to inherit from it. This means we can leave `EventEmitter`'s prototype untouched, while utilizing its api for our own means of world domination!
+A more practical and common use of `EventEmitter` is to inherit from it. This means we can leave `EventEmitter`'s prototype untouched while utilizing its API for our own means of world domination!
 
-To do so we begin by defining the `Dog` constructor, which of course will bark from time to time, also known as an _event_.
+To do so, we begin by defining the `Dog` constructor, which of course will bark from time to time (also known as an _event_).
 
 	var EventEmitter = require('events').EventEmitter;
 
 	function Dog(name) {
 	    this.name = name;
 	}
 
-Here we inherit from `EventEmitter`, so that we may use the methods provided such as `EventEmitter#on()` and `EventEmitter#emit()`. If the `__proto__` property is throwing you off, no worries! we will be touching on this later.
+Here we inherit from `EventEmitter` so we can use the methods it provides, such as `EventEmitter#on()` and `EventEmitter#emit()`. If the `__proto__` property is throwing you off, don't worry, we'll be coming back to this later.
 
 	Dog.prototype.__proto__ = EventEmitter.prototype;
 
-Now that we have our `Dog` set up, we can create .... simon! When simon barks we can let _stdout_ know by calling `console.log()` within the callback. The callback it-self is called in context to the object, aka `this`.
+Now that we have our `Dog` set up, we can create... Simon! When Simon barks, we can let _stdout_ know by calling `console.log()` within the callback. The callback itself is called in the context of the object (aka `this`).
 
 	var simon = new Dog('simon');
 
 	simon.on('bark', function(){
 	    console.log(this.name + ' barked');
 	});
 
-Bark twice a second:
+Bark twice per second:
 
 	setInterval(function(){
 	    simon.emit('bark');
 	}, 500);
 
 ## Removing Event Listeners
 
-As we have seen event listeners are simply functions which are called when we `emit()` an event. Although not seen often we can remove these listeners by calling the `removeListener(type, callback)` method. In the example below we emit the _message_ "foo bar" every `300` milliseconds, which has the callback of `console.log()`. After 1000 milliseconds we call `removeListener()` with the same arguments that we passed to `on()` originally. To compliment this method is `removeAllListeners(type)` which removes all listeners associated to the given _type_.
+As we have seen, event listeners are simply functions which are called when we `emit()` an event. We can remove these listeners by calling the `removeListener(type, callback)` method, although this isn't seen often. In the example below we emit the _message_ "foo bar" every `300` milliseconds, which has a callback of `console.log()`. After 1000 milliseconds, we call `removeListener()` with the same arguments that we passed to `on()` originally. We could also have used `removeAllListeners(type)`, which removes all listeners registered to the given _type_.
 
 	var EventEmitter = require('events').EventEmitter;