anchor.diff:  
         section
           h1 Generators
  -
  +        h3.bullet Generators are a special kind of iterator
  +          ul
  +            li
  +              h3 Generators do not follow run-to-completion
  +            li
  +              h3 They can be paused using #[span.token.keyword yield] in the Generator
  +            li
  +              h3 And resumed on the outside by calling #[span.token.keyword next] on the Generator
  +
  +      section
  +        h1 Generators
  +        h3 They also allow 2 way message passing between the generator function and the calling code
  +
  +      section
  +        h1 Generators
  +        pre
  +          code.language-javascript.
  +            function *gen() {
  +              yield 1;
  +              yield 2;
  +              yield 3;
  +            }
  +            let it = gen();
  +            it.next(); // {value: 1, done: false}
  +            it.next(); // {value: 2, done: false}
  +            it.next(); // {value: 3, done: false}
  +            it.next(); // {value: undefined, done: true}
  +
  +      section
  +        h1 Generators
  +        pre
  +          code.language-javascript.
  +            function *fib() {
  +              let x = 0, y = 1;
  +              while (true) {
  +                let t = y;
  +                y = x + t; x = t;
  +                yield y;
  +              }
  +            }
  +
  +      section
  +        h1 Generators
  +        pre
  +          code.language-javascript.
  +            let it = fib();
  +            for (let n of fib) {
  +              if (n > 1000) {
  +                break;
  +              }
  +              console.log(n);
  +            }
  +
  +      section
  +        h2 Message passing
  +        pre
  +          code.language-javascript.
  +            function *gen(x) {
  +              let y = yield (x * 2);
  +              let z = yield (y * 2);
  +              return z * 2;
  +            }
  +            let it = gen(2);
  +            it.next().value; // 4
  +            it.next(3).value; // 6
  +            it.next(4).value; // 8
   
         section(data-bespoke-hash="es2016")
           h1 ES2016 and beyond
  
positive.code:           li
              h3 Highly composable using chaining, Promise.all, Promise.race
  
        section(data-bespoke-hash="generators")
          h1 Generators
          h3.bullet Asynchronous JavaScript
          ul
            li
              h3 JS uses an event-loop
            li
              h3 Called code is put on the event loop and executed
  
        section
          h2 Async JavaScript
          h3.bullet JS uses Promise, callbacks to handle asynchronous requests
          ul
            li
              h3 The async request is made and then the code finishes executing (non-blocking)
            li
              h3 Once the request comes back the handler is put on the event loop to handle the response
  
        section
          h2 Async JavaScript
          h3.bullet When a function is put on the event loop it is run in its entirety
          ul
            li
              h3 Until now..
  
        section
          h1 Generators
          h3.bullet ES2015 defines are a new type of function
          ul
  
negative.code:         h1.bullet Topics
          ul.bigger-list
            li New ES2015 Language Features
            li Coming ES2016+ Language Features
            li Focus on stuff we can use every day
            li Exciting stuff to look forward to
  
  