title: Why use Object.create inside this reduce callback?
body: <p>So while working on #19 of this fine tutorial - <a href="http://jhusain.github.io/learnrx/" rel="nofollow">http://jhusain.github.io/learnrx/</a>, I find that the exercise works without using Object.create. (See the commented-out lines)</p>
  
  <h3>1. So what is the point of creating that copy of the accumulatedMap? Other than showing that it is possible...</h3>
  
  <pre><code>function() {
      var videos = [
          {
              "id": 65432445,
              "title": "The Chamber"
          },
          {
              "id": 675465,
              "title": "Fracture"
          },
          {
              "id": 70111470,
              "title": "Die Hard"
          },
          {
              "id": 654356453,
              "title": "Bad Boys"
          }
      ];
  
      // Expecting this output...
      // [
      //     {
      //         "65432445": "The Chamber",
      //         "675465": "Fracture",
      //         "70111470": "Die Hard",
      //         "654356453": "Bad Boys"
      //     }
      // ]
      return videos.
          reduce(function(accumulatedMap, video) {
  
              // Object.create() makes a fast copy of the accumulatedMap by
              // creating a new object and setting the accumulatedMap to be the
              // new object's prototype.
              // Initially the new object is empty and has no members of its own,
              // except a pointer to the object on which it was based. If an
              // attempt to find a member on the new object fails, the new object
              // silently attempts to find the member on its prototype. This
              // process continues recursively, with each object checking its
              // prototype until the member is found or we reach the first object
              // we created.
              // If we set a member value on the new object, it is stored
              // directly on that object, leaving the prototype unchanged.
              // Object.create() is perfect for functional programming because it
              // makes creating a new object with a different member value almost
              // as cheap as changing the member on the original object!
  
              //var copyOfAccumulatedMap = Object.create(accumulatedMap);
  
              //copyOfAccumulatedMap[video.id] = video.title;
              accumulatedMap[video.id] = video.title;
  
            //return copyOfAccumulatedMap;
              return accumulatedMap;
          },
          // Use an empty map as the initial value instead of the first item in
          // the list.
          {});
  }
  </code></pre>
  
  <h3>2 And if you <em>do</em> do it using <code>copyOfAccumulatedMap</code>, you end up with an object like this</h3>
  
  <p><img src="https://dl.dropboxusercontent.com/spa/lkj2dewi3ofvkgc/7dpsz4-5.jpg" alt=""></p>
  
  <p>which looks intriguing, but is puzzling because I cannot do the same thing with this code here</p>
  
  <pre><code>var fruit = { 'taste' : 3 };
  
  var apple = Object.create(fruit);
      apple['size'] = 7;
  
  var apple = Object.create(fruit);
      apple['hardness'] = 6;
  
  var apple = Object.create(fruit);
      apple['weight'] = 10;
  
  console.log(apple.taste);
  console.log(apple.size);     // undefined as I would expect
  console.log(apple.hardness); // undefined as I would expect
  console.log(apple.weight);
  </code></pre>
  
  <p>So what is it that allows the object in the exercise to have all the chained prototypes but doesn't allow my apple to do the same?</p>