Removed references to old bios parsed stuff

dynajoe · dynajoe · commit 3ed06f1dca43 · 2013-08-12T10:39:29.000-05:00
diff --git a/_posts/2012-11-5-async.md b/_posts/2012-11-5-async.md
@@ -20,7 +20,7 @@ for (var i = 0; i < 100; i++) {
 console.log('You might think this gets printed last.')
 {% endhighlight %}
 
-Go back to your command window and list files in your current working directory. Notice that the only file created was `3.json`. This is because the callback for setTimeout doesn't actually get executed until the for loop has completed. Any other statements after the for loop would also be executed before the callback. This is, in part, because Node is single threaded. The event loop hasn't had a chance to invoke your callback. In any case, all of the callbacks are being fired with the same value of `i`.
+Notice the value printed is 100, which is the terminal condition for this loop. This is because the callback for setTimeout doesn't actually get executed until the for loop has completed. Any other statements after the for loop would also be executed before the callback. This is, in part, because Node is single threaded. The event loop hasn't had a chance to invoke your callback. In any case, all of the callbacks are being fired with the same value of `i`.
 
 How do we avoid this? The important concept here is how scope is handled in JavaScript. Unlike other languages that use block level scope, JavaScript's scope is at a function level. We can get around this problem by introducing a new scope in each iteration of the loop to capture the value of `i` at that moment:
 
@@ -53,33 +53,32 @@ console.log('this still gets printed first.')
 
 ## Asynchronous calls in parallel and then joining them
 
-So how do we go about printing out a something after the loops work has been done.
+So how do we go about printing out a something after the loops work has been done?
 
-More often than not there's a need to invoke a set of tasks asynchronously and then start a new set of tasks after completion. There are a variety of libraries that help with performing this situation and cleaning up the code a lot. 
+More often than not there's a need to invoke a set of tasks asynchronously and then start a new set of tasks after completion. There are a variety of libraries that help with performing this situation and cleaning up the code a lot.
 
 {% highlight javascript %}
-var printNumberLater = function (i, cb) {
-  setTimeout(function () {
-    console.log(i);
-    cb();
-  }, 100);
-};
-
 var totalNumbersToPrint = 100;
 var finishedCount = 0;
 
-for (var i = 0; i < totalNumbersToPrint; i++) {
-  printNumberLater(i, function () {
-    finishedCount++;
+var printNumberLater = function (i) {
+  setTimeout(function () {
+    console.log(i);
     
+    finishedCount++;
+
     if (finishedCount === totalNumbersToPrint) {
       console.log('this finally gets printed after all work is done!');
     }
-  });
+  }, 100);
+};
+
+for (var i = 0; i < totalNumbersToPrint; i++) {
+  printNumberLater(i);
 }
 {% endhighlight %}
 
-In the example above, note that we keep track of how many times the `readFile` callback is invoked. Once the value matches the number of callbacks we're waiting on we can continue with saving off the biographies. This can get quite ugly the more complex your application becomes. A very good library for dealing with this is `async`. Here's an example of how async could be used to clean up the code above.
+In the example above, note that we keep track of how many times the `setTimeout` callback is invoked. Once the value matches the number of callbacks we're waiting on we can continue with printing out our message. This can get quite ugly the more complex your application becomes. A very good library for dealing with this is `async`. Here's an example of how async could be used to clean up the code above.
 
 First, you should install the async module.
 
@@ -109,7 +108,7 @@ async.parallel(workToBeDone, function () {
 });
 {% endhighlight %}
 
-Imagine the above where you had multiple things needing to happen in parallel. Remember how we kept around the `biosParsed` counter a few examples back? Keeping track of all the counters for more complicated examples could get extremely messy. Using `async` we're able to avoid these arbitrary counters and organize our code better. Another pattern to use is called `promises`.
+Imagine the above where you had multiple things needing to happen in parallel. Remember how we kept around the `finishedCount` counter a few examples back? Keeping track of all the counters for more complicated examples could get extremely messy. Using `async` we're able to avoid these arbitrary counters and organize our code better. Another pattern to use is called `promises`.
 
 ## Promises
 
