anchor.diff:            li
               h3 Highly composable using chaining, Promise.all, Promise.race
   
  +      section
  +        h1 Generators
  +        h3.bullet Whenever ever a function is executed in JS, the engine executes the whole function, top to bottom
  +        ul
  +          li
  +            h3 Run-to-completion
  +          li
  +            h3 Until now..
  +
         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
  
positive.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
  
  
negative.code: 
        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
  