index.html

<!doctype html>
<html>
<head>
    <meta charset="utf-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0, maximum-scale=1.0, user-scalable=no">

    <title>Compiler Explorer</title>

    <link rel="stylesheet" href="reveal.js/css/reveal.css">
    <link rel="stylesheet" href="drw.css">

    <style>
        .faded {
            opacity: 0.5;
        }

        span.opt {
            font-size: 70%;
            vertical-align: sub;
        }

        img.logo {
            padding: 5px;
        }

        div.footnote {
            margin-top: 2em;
            font-size: smaller;
            font-style: italic;
        }

        #sum td {
            border: 1px solid black;
        }

        #sum tr {
            border: 1px solid black;
        }

        #sum .filled {
            background: rgb(141, 211, 199);
        }

        code.smaller {
            font-size: smaller;
        }

        #registers th {
            font-size: 30px;
            text-align: center;
        }

        #registers td {
            text-align: center;
        }

        #registers td.register {
            border: 1px solid black;
        }

        #registers td.rax {
            background: rgb(141, 211, 199);
        }

        #registers td.eax {
            background: rgb(255, 255, 179);
        }

        #registers td.ax {
            background: rgb(190, 186, 218);
        }

        #registers td.ah {
            background: rgb(251, 128, 114);
        }

        #registers td.al {
            background: rgb(128, 177, 211);
        }

        #registers td.regnote {
            font-size: smaller;
            font-style: italic;
        }

        .soh {
            color: rgb(27, 145, 33);
        }

        a.view-button {
            font-size: 12px;
        }

        div.left-pane {
            width: 50%;
            float: left;
        }

        div.right-pane {
            width: 50%;
            float: right;
        }

        .fix-key {
            color: #03330c;
        }

        .fix-value {
            color: #1f1f1f;
        }
    </style>

    <link rel="stylesheet" href="reveal.js/lib/css/zenburn.css">

    <script>
        var link = document.createElement('link');
        link.rel = 'stylesheet';
        link.type = 'text/css';
        link.href = window.location.search.match(/print-pdf/gi) ? 'reveal.js/css/print/pdf.css' : 'reveal.js/css/print/paper.css';
        document.getElementsByTagName('head')[0].appendChild(link);
    </script>
</head>
<body>
<div class="reveal">
    <section class="slides">
        <section id="title">
            <h2>What Has My Compiler Done for Me Lately?</h2>
            <h5>Unbolting the Compiler's Lid</h5>
            <em><a href="https://xania.org/">Matt Godbolt</a>, <a href="https://drw.com/careers">DRW Trading</a></em>
            <br>
            <em>
                <a href="https://twitter.com/mattgodbolt">@mattgodbolt</a>
                <a href="mailto:matt@godbolt.org">matt@godbolt.org</a>
            </em>
        </section>


        <!------------------------------------------------------>
        <section id="why">
            <section>
                <h3>About me</h3>
                <div class="fragment">
                    <img src="images/6502_z80.jpg" height="160">
                    <img src="images/ARM_610.jpg" height="160">
                    <img src="images/red_dog.png" height="160">
                </div>
                <div class="fragment">
                    <img class="logo" src="images/profactor.jpg" height="30">
                    <img class="logo" src="images/google.png" height="30">
                    <img class="logo" src="images/DRWSmallLogo.png" height="30">
                </div>
                <aside class="notes">
                    <h4>Potted history:</h4>
                    <ul>
                        <li>Learned Z80, 6502 assembly in the 80s to write my own games</li>
                        <li>Moved on to ARM assembly</li>
                        <li>Wrote full functioned IRC client in ARM asm</li>
                        <li>Dismissed C as just a macro assembler</li>
                        <li>Learned C to write a MUD at Uni</li>
                        <li>Eventually moved on to C++</li>
                        <li>Got a job making games, high performance stuff</li>
                        <li>Co-ran C++ tools company</li>
                        <li>Google; occasional performance stuff for cellphones</li>
                        <li>Now 6 years at DRW doing performance stuff for trading systems</li>
                        <li>Still an asm hacker at heart though don't touch it so more</li>
                    </ul>
                    <p>Amazing opportunity to talk to lots of C++ programmers at all levels. My passion.</p>
                </aside>
            </section>
            <section>
                <h3>My goals</h3>
                <!--<div>
                    <img src="images/goal.jpg" height="150px">
                </div>-->
                <ul>
                    <li>Un-scary-fy assembler</li>
                    <li>Appreciate your compiler!</li>
                </ul>
            </section>
            <section>
                <h3>Outline</h3>
                <ul>
                    <li>Compiler Explorer story</li>
                    <li>Assembly 101</li>
                    <li>What has my compiler done for me lately?</li>
                    <li>Behind the scenes of Compiler Explorer</li>
                </ul>
            </section>
        </section>


        <!------------------------------------------------------>
        <section id="backstory">
            <section>
                <h3>Backstory</h3>
                <pre><code data-trim class="cpp">
                int sum(const vector&lt;int> &v) {
                  int result = 0;
                  for (size_t i = 0; i < v.size(); ++i)
                    result += v[i];
                  return result;
                }</code></pre>
                <pre class="fragment"><code data-trim class="cpp">
                int sum(const vector&lt;int> &v) {
                  int result = 0;
                  for (int x : v) result += x;
                  return result;
                }</code></pre>
                <div class="fragment">Is one better than the other?</div>
                <aside class="notes">
                    <ul>
                        <li>2012, C++11isms, range-for</li>
                    </ul>
                </aside>
            </section>
            <section>
                <h3>WARNING</h3>
                <ul>
                    <li>Reading assembly alone can be misleading</li>
                    <li><em>Always</em> measure too</li>
                    <li>Google Benchmark</li>
                    <li><a href="http://www.quick-bench.com/">quick-bench.com</a></li>
                </ul>
                <aside class="notes">
                    Shout out to google benchmarking tool. Microbenchmarks, perils.

                    But always measure end-to-end perf if you can too.
                </aside>
            </section>
        </section>


        <!------------------------------------------------------->
        <section id="asm101">
            <!-- reference "just enough asm to be dangerous talk -->
            <section>
                <h3>x86 Assembly 101</h3>
            </section>
            <section>
                <!-- TODO Mighty Boosh? -->
                <h3>Registers</h3>
                <ul>
                    <li><code>rax</code>, <code>rbx</code>, <code>rcx</code>, <code>rdx</code>, <code>rsp</code>,
                        <code>rbp</code>, <code>rsi</code>, <code>rdi</code>, <code>r8</code>-<code>r15</code></li>
                    <li><code>xmm0</code>-<code>xmm15</code></li>
                    <li><code>rdi</code>, <code>rsi</code>, <code>rdx</code>... arguments</li>
                    <li><code>rax</code> is return value</li>
                </ul>
            </section>
            <section>
                <h3>Registers</h3>
                <table id="registers">
                    <thead>
                    <tr>
                        <th>63...56</th>
                        <th>55...48</th>
                        <th>47...40</th>
                        <th>39...32</th>
                        <th>31...24</th>
                        <th>23...16</th>
                        <th>15...8</th>
                        <th>7...0</th>
                    </tr>
                    </thead>
                    <tbody>
                    <tr>
                        <td colspan="8" class="register rax">rax</td>
                    </tr>
                    <tr>
                        <td colspan="4" class="regnote">(zeroed on write)</td>
                        <td colspan="4" class="register eax">eax</td>
                    </tr>
                    <tr>
                        <td colspan="6"></td>
                        <td colspan="2" class="register ax">ax</td>
                    </tr>
                    <tr>
                        <td colspan="6"></td>
                        <td colspan="1" class="register ah">ah</td>
                        <td colspan="1"></td>
                    </tr>
                    <tr>
                        <td colspan="7"></td>
                        <td colspan="1" class="register al">al</td>
                    </tr>
                    </tbody>
                </table>
            </section>

            <section>
                <h3>Instructions</h3>
                <pre><code data-trim class="x86asm">
                    op
                    op dest
                    op dest, src
                    op dest, src1, src2
                </code></pre>
                <ul>
                    <li><code>op</code> is e.g. <code>call</code>, <code>ret</code>, <code>add</code>, <code>sub</code>,
                        <code>cmp</code>...
                    </li>
                    <li><code>dest</code>, <code>src</code> is register or memory reference:<br>
                        <code class="smaller">[base + reg1<span class="opt">opt</span> + reg2*(1, 2, 4 or 8)<span
                                class="opt">opt</span>]</code>
                    </li>
                </ul>
                <div class="footnote">(Intel asm syntax)</div>
            </section>
            <section>
                <h3>Instructions</h3>
                <div class="left-pane">
                <pre class="smaller"><code data-trim class="x86asm">
                mov eax, DWORD PTR [r14]
                add rax, rdi
                add eax, DWORD PTR [r14+4]
                sub eax, DWORD PTR [r14+4*rbx]
                lea rax, [r14+4*rbx]
                xor edx, edx
                </code></pre>
                </div>
                <div class="right-pane">
                <pre class="fragment smaller"><code data-trim class="cpp">
                int eax = *r14;   // int *r14;
                rax += rdi;
                eax += r14[1];
                eax -= r14[rbx];
                int *rax = &r14[rbx];
                edx = 0;
                </code></pre>
                </div>
            </section>
            <section>
                <h3>Summary</h3>
                <ul>
                    <li>Registers: <code>rax</code>, <code>rbx</code>, <code>rcx</code> ...</li>
                    <li>Size: <code>rax</code>, <code>eax</code>, <code>ax</code> ...</li>
                    <li>Params: <code>rdi</code>, <code>rsi</code>, <code>rdx</code>, <code>rcx</code> ...</li>
                    <li>Result: <code>rax</code></li>
                    <li><code>op dest, src</code></li>
                    <li><code>dest</code>, <code>src</code> are registers or memory</li>
                </ul>
            </section>
        </section>


        <!------------------------------------------------------->
        <section id="back2backstory">
            <section>
                <h3>Where were we?</h3>
                <pre><code data-trim class="cpp">
                int sum(const vector&lt;int> &v) {
                  int result = 0;
                  for (size_t i = 0; i < v.size(); ++i)
                    result += v[i];
                  return result;
                }</code></pre>
                <pre><code data-trim class="cpp">
                int sum(const vector&lt;int> &v) {
                  int result = 0;
                  for (int x : v) result += x;
                  return result;
                }</code></pre>
                <div class="fragment">Which is better?</div>
            </section>
            <section>
                <h3>Compiler Explorer v0.1</h3>
                <pre><code data-noescape data-trim class="bash">
                 $ g++ /tmp/test.cc -O2 -c -S -o - -masm=intel \
                    | c++filt \
                    | grep -vE '\s+\.'
            </code></pre>
                <pre><code class="x86asm" data-trim>
sum(std::vector&lt;int, std::allocator&lt;int> > const&):
.LFB786:
    mov	rcx, QWORD PTR [rdi]
    mov	rax, QWORD PTR 8[rdi]
    sub	rax, rcx
    shr	rax, 2
    mov	rsi, rax
    ...</code></pre>
            </section>
            <section><h3>Compiler Explorer v0.1</h3>
                <div>Not very pretty</div>
                <h5 class="fragment">To the web!</h5>
            </section>
        </section>


        <!------------------------------------------------------->
        <section id="andNow">
            <section>
                <h3>Demo</h3>
                <pre class="ce">
/// g71:-O2 -std=c++1z -march=haswell
// setup
  #include &lt;numeric>
  #include &lt;vector>
  using namespace std;

int sum(const vector&lt;int> &v) {
  int result = 0;
  for (size_t i = 0; i < v.size(); ++i)
    result += v[i];
  return result;
}</pre>
                <aside class="notes">
                    <ul>
                        <li>Pop out</li>
                        <li>Show code</li>
                        <li>Show optimizer off</li>
                        <li>Show diff</li>
                    </ul>
                </aside>
            </section>
            <section>
                <h3>Walkthrough</h3>
                <pre><code data-trim class="x86asm">
  ; rdi = const vector&lt;int> *
  mov rdx, QWORD PTR [rdi]   ; rdx = *rdi     &equiv; begin()
  mov rcx, QWORD PTR [rdi+8] ; rcx = *(rdi+8) &equiv; end()
                </code></pre>
                <pre class="fragment"><code data-trim class="cpp">
template&lt;typename T> struct _Vector_impl {
  T *_M_start;
  T *_M_finish;
  T *_M_end_of_storage;
};
                    </code></pre>
            </section>
            <section>
                <div class="left-pane">
                    <h5>Traditional</h5>
                    <pre class="smaller"><code data-trim class="x86asm">
sub rcx, rdx ; rcx = end-begin
mov rax, rcx
shr rax, 2   ; (end-begin)/4
je .L4
add rcx, rdx
xor eax, eax
                    </code></pre>
                    <pre class="fragment smaller"><code data-trim class="cpp">
size_t size() const noexcept {
  return _M_finish - _M_start;
}</code></pre>
                </div>
                <div class="right-pane">
                    <h5>Range</h5>
                    <pre><code data-trim class="x86asm">
xor eax, eax
cmp rdx, rcx ; begin==end?
je .L4
                </code></pre>
                    <pre class="fragment"><code data-trim class="cpp">
                        auto __begin = begin(v);
                        auto __end = end(v);
                        for (auto __it = __begin;
                             __it != __end;
                             ++it)
</code></pre>
                </div>
            </section>
            <section>
                <h3>Walkthrough</h3>
                <pre><code data-trim class="x86asm">
; rcx &equiv; end, rdx = begin, eax = 0
.L3:
  add eax, DWORD PTR [rdx]    ; eax += *rdx
  add rdx, 4                  ; rdx += sizeof(int)
  cmp rdx, rcx                ; is rdx == end?
  jne .L3                     ;   if not, loop
  ret                         ; we're done
            </code></pre>
            </section>
            <section><h3>Backstory</h3>
                <h5>So, which approach is best?</h5></section>
            <section>
                <h3>Also</h3>
                <ul>
                    <li>Optimizer settings are important</li>
                    <li><code>std::accumulate</code></li>
                </ul>
            </section>
        </section>


        <!------------------------------------------------------->
        <section id="compilersAreSuperSmart">
            <section><h3>What has my compiler done for me lately?</h3></section>
            <section>
                <h3>Multiplication</h3>
                <div class="left-pane">
                    <pre><code class="cpp ce" data-trim>
/// g71:-O2 -std=c++1z -march=haswell
int mulByY(int x, int y) {
  return x * y;
}
                    </code></pre>
                </div>
                <div class="right-pane">
                    <pre><code class="x86asm" data-trim>
mulByY(int, int):
  mov eax, edi
  imul eax, esi
  ret
                    </code></pre>
                </div>
            </section>
            <section>
                <h3>Multiplication</h3>
                <pre>
                            1101    (13)
                          x 0101     (5)
                        --------
                            1101
                           0000
                          1101
                       + 0000
                        --------
                        01000001    (65)</pre>
                <div class="fragment">That's a lot of additions!</div>
                <div class="fragment">Haswell 32-bit multiply - 4 cycles</div>
            </section>
            <section>
                <h3>Multiplication</h3>
                <pre><code class="cpp ce">
/// g71:-O2 -std=c++1z -march=haswell
int mulByConstant(int x) { return x * 2; }
                </code></pre>
            </section>
            <section>
                <h3>Multiplication</h3>
                <pre><code class="cpp ce">
/// g71:-O2 -std=c++1z -march=haswell
int mulBy65599(int a) {
  return (a << 16) + (a << 6) - a;
  //         ^          ^
  //     a * 65536      |
  //                  a * 64
  // 65536a + 64a - 1a = 65599a
}                </code></pre>
                <aside class="notes">
                    <pre>-march=i486 -m32</pre>
                    shows up what you asked
                </aside>
            </section>
            <section>
                <h3>Division</h3>
                <div class="left-pane">
                    <!---/// g71:-O2 -std=c++1z -->
                    <pre><code class="cpp ce" data-trim>
int divByY(int x, int y) {
  return x / y;
}
int modByY(int x, int y) {
  return x % y;
}
                    </code></pre>
                </div>
                <div class="right-pane">
                    <pre><code class="x86asm" data-trim>
divByY(int, int):
  mov eax, edi
  cdq
  idiv esi
  ret
modByY(int, int):
  mov eax, edi
  cdq
  idiv esi
  mov eax, edx
  ret
                    </code></pre>
                </div>
                <div class="fragment">Haswell 32-bit divide - 22-29 cycles!</div>
                <aside class="notes">
                    <code>cdq</code> does sign expansion into registers. <code>div</code> divides eax:edx with the
                    operand, results in
                    eax (divisor) and edx (dividend).
                    <code>cdq</code> sign extends eax into edx, ready for a div
                </aside>
            </section>
            <section>
                <!-- TODO sxs ? -->
                <h3>Division</h3>
                <pre><code class="cpp ce">
/// g71:-O2 -std=c++1z -march=haswell
unsigned divByConstant(unsigned x) { return x / 2; }
                </code></pre>
            </section>
            <section>
                <h3>Division</h3>
                <!-- TODO C implementaiton? -->
                <pre><code class="x86asm" data-trim>
mov eax, edi        ; eax = x
mov edx, 0xaaaaaaab
mul edx             ; eax:edx = x * 0xaaaaaaab
mov eax, edx        ;   (x * 0xaaaaaaab) >> 32
                    ; &equiv; (x * 0xaaaaaaab) / 0x10000000
                    ; &equiv; x * 0.6666666667
shr eax             ; x * 0.333333333
ret
                </code></pre>
            </section>
            <section>
                <h3>Modulus</h3>
                <div class="left-pane">
                    <!---/// g71:-O2 -std=c++1z -->
                    <pre><code class="cpp ce" data-trim>
int modBy3(unsigned x) {
  return x % 3;
}
                    </code></pre>
                </div>
                <div class="right-pane">
                    <pre><code class="x86asm" data-noescape data-trim>
<span class="faded">mov eax, edi
mov edx, 0xaaaaaaab
mul edx
mov eax, edx
shr eax
</span>lea eax, [rdx+rdx*2]
sub edi, eax
mov eax, edi
<span class="faded">ret</span>
                    </code></pre>
                </div>
            </section>
            <section>
                <h3>Why modulus?</h3>
                <ul>
                    <li>
                        <a href="http://localhost:10240/#g:!((g:!((g:!((h:codeEditor,i:(fontScale:1.6,j:1,source:'//+setup%0A++%23include+%3Cunordered_map%3E%0A++using+namespace+std%3B%0A%0Aint+lookupOr0(int+i,%0A+++++++++++const+unordered_map%3Cint,+int%3E+%26m)+%7B%0A++if+(auto+it+%3D+m.find(i)%3B+it+!!%3D+m.end())%0A++++return+it-%3Esecond%3B%0A++return+0%3B%0A%7D'),l:'5',n:'0',o:'C%2B%2B+source+%231',t:'0')),k:50,l:'4',n:'0',o:'',s:0,t:'0'),(g:!((h:compiler,i:(compiler:gsnapshot,filters:(___0:(),b:'0',commentOnly:'0',directives:'0',intel:'0',jquery:'3.2.1',length:1,prevObject:(___0:(sizzle1504548572380:(undefined:(legend:!(5,0,'1')))),length:1,prevObject:(___0:(jQuery3210165493275017513991:(display:''),sizzle1504548572380:(undefined:(legend:!(5,0,'1')))),length:1)),trim:'0'),fontScale:1.8,options:'-O2+-std%3Dc%2B%2B1z+-march%3Dhaswell',source:1),l:'5',n:'0',o:'x86-64+gcc+(snapshot)+(Editor+%231,+Compiler+%231)',t:'0')),k:50,l:'4',n:'0',o:'',s:0,t:'0')),l:'2',n:'0',o:'',t:'0')),version:4">
                            Bucket selection in hash maps</a></li>
                    <li>
                        <a href="http://localhost:10240/#g:!((g:!((g:!((h:codeEditor,i:(fontScale:1.6,j:1,source:'//+setup%0A++%23include+%3Cunordered_map%3E%0A++using+namespace+std%3B%0A%0Aint+lookupOr0(int+i,%0A+++++++++++const+unordered_map%3Cint,+int%3E+%26m)+%7B%0A++if+(auto+it+%3D+m.find(i)%3B+it+!!%3D+m.end())%0A++++return+it-%3Esecond%3B%0A++return+0%3B%0A%7D'),l:'5',n:'0',o:'C%2B%2B+source+%231',t:'0')),k:50,l:'4',n:'0',o:'',s:0,t:'0'),(g:!((h:compiler,i:(compiler:clang_trunk,filters:(___0:(),b:'0',commentOnly:'0',directives:'0',intel:'0',jquery:'3.2.1',length:1,prevObject:(___0:(sizzle1504548572380:(undefined:(legend:!(5,0,'1')))),length:1,prevObject:(___0:(jQuery3210165493275017513991:(display:''),sizzle1504548572380:(undefined:(legend:!(5,0,'1')))),length:1)),trim:'0'),fontScale:1.8,options:'-O2+-std%3Dc%2B%2B1z+-march%3Dhaswell+-stdlib%3Dlibc%2B%2B',source:1),l:'5',n:'0',o:'x86-64+clang+(trunk)+(Editor+%231,+Compiler+%231)',t:'0')),k:50,l:'4',n:'0',o:'',s:0,t:'0')),l:'2',n:'0',o:'',t:'0')),version:4">
                            libc++</a> special-cases power-of-two
                    </li>
                    <li>boost multi_index</li>
                </ul>
            </section>
            <section><h3>Counting bits</h3>
                <pre><code class="ce">
/// g71:-O2 -std=c++1z -march=haswell
int countSetBits(int a) {
  int count = 0;
  while (a) {
    count++;
    a &amp;= (a-1);
  }
  return count;
}
            </code></pre>
                <aside class="notes">
                    Explain a &amp; (a - 1)
                </aside>
            </section>
            <section>
                <h3>Summation</h3>
                <pre><code data-trim class="cpp ce">
/// g71:-O2 -std=c++1z -march=haswell
constexpr int sumTo(int x) {
  int sum = 0;
  for (int i = 0; i &lt;= x; ++i)
    sum += i;
  return sum;
}

int main(int argc, const char *argv[]) {
  return sumTo(20);
}
            </code></pre>
                <aside class="notes">
                    <ul>
                        <li>Show code</li>
                        <li>Modify code to show how to make it depend on argc/argv</li>
                        <li>Show clang's cleverness</li>
                        <li>Show clang's weirdness if starting at 1 instead of 0</li>
                    </ul>
                </aside>
            </section>
            <section>
                <h3>Sum(x)</h3>
                <div>\[
                    \begin{aligned}
                    \sum{x} &amp;&equiv; \frac{x(x + 1)}{2} \\
                    &amp;&equiv; x + \frac{x(x - 1)}{2}
                    \end{aligned}
                    \]
                </div>
            </section>
            <section>
                <h3>What has my compiler done for me lately?</h3>
                <div class="fragment">A lot!</div>
            </section>
        </section>


        <!------------------------------------------------------->
        <section id="howitworks">
            <section>
                <h3>How it works</h3>
                <!-- TODO picture of duct tape disaster -->
            </section>
            <section>
                <h3>How it works - Backend</h3>
                <ul>
                    <li>Written in <code>node.js</code></li>
                    <li>Runs on Amazon</li>
                </ul>
            </section>
            <section>
                <h3><code>node.js</code></h3>
                <pre class="smaller"><code class="javascript" data-trim>
function compile(req, res, next) {
  // exec compiler, feed it req.body, parse output
}
var webServer = express();
var apiHandler = express.Router();
apiHandler.param('compiler',
    function (req, res, next, compiler) {
  req.compiler = compiler;
  next();
});
apiHandler.post('/compiler/:compiler/compile', compile);
webServer.use('/api', apiHandler);
webServer.listen(10240);
                </code></pre>
            </section>
            <section>
                <h3>Amazon EC2</h3>
                <ul>
                    <li>Edge cache</li>
                    <li>Load balancer</li>
                    <li>Virtual machines</li>
                    <li>Docker images</li>
                    <li>Shared compiler storage</li>
                </ul>
            </section>
            <section>
                <h3>The compilers</h3>
                <ul>
                    <li>Built through docker images</li>
                    <li>Compilers stored on S3</li>
                    <li>OSS ones publically available</li>
                    <li>MS compilers via WINE</li>
                </ul>
                <aside class="notes">
                    30+ GB of compilers currently
                </aside>
            </section>
            <section>
                <h3>How it works - security</h3>
                <ul>
                    <li>Compilers: huge attack vector</li>
                    <li>Principle of "what's the worst could happen"</li>
                    <li>Docker</li>
                    <li><code>LD_PRELOAD</code></li>
                </ul>
                <aside class="notes">
                    Known attacks:
                    * crash clang leaving temporary file, filename in crash dump, load temporary file using compiler
                    plugin
                    * crash compiler with temporary file (the input) in /tmp, use it as a specs file
                </aside>
            </section>
            <section>
                <h3>How it works - Frontend</h3>
                <ul>
                    <li>Microsoft's Monaco</li>
                    <li>GoldenLayout</li>
                </ul>
            </section>
            <section>
                <h3>The code</h3>
                <ul>
                    <li>
                        <a href="https://github.com/mattgodbolt/compiler-explorer">github.com/mattgodbolt/compiler-explorer</a>
                    </li>
                    <li><a href="https://github.com/mattgodbolt/compiler-explorer-image">github.com/mattgodbolt/compiler-explorer-image</a>
                    </li>
                    <li class="fragment">Running locally is easy!<br>
                        <pre>$ make</pre>
                    </li>
                    <li class="fragment">More in next C++ Weekly</li>
                </ul>
            </section>
        </section>


        <!------------------------------------------------------->
        <section id="conclusions">
            <section>
                <h3>Other uses</h3>
                <ul>
                    <li>Code pastebin</li>
                    <li>Compiler development</li>
                    <li>C++ REPL</li>
                    <li>Training resource</li>
                </ul>
                <aside class="notes">
                    <ul>
                        <li>160 bugs in GCC tracker refer to godbolt.org</li>
                        <li>104 in clang</li>
                    </ul>
                </aside>
            </section>
            <section>
                <h3>Coming soon...</h3>
                <ul>
                    <li>CFG viewer</li>
                    <li>Unified languages</li>
                    <li>Execution support</li>
                </ul>
            </section>
            <section>
                <h3>Thanks</h3>
                <ul>
                    <li>Thanks to contributors:
                        <ul>
                            <li>Rubén Rincón</li>
                            <li>Gabriel Devillers</li>
                            <li>Simon Brand, Johan Engelen, Jared Wyles, Chedy Najjar</li>
                            <li>...and the rest!</li>
                        </ul>
                    </li>
                    <li>Thanks to Patreon folks</li>
                    <li>Thanks to awesome C++ community</li>
                    <li class="fragment">Thanks to you!</li>
                </ul>
            </section>
            <section>
                <h3>Go read some assembly!</h3>
                <br>
                <div>
                    { <a href="https://gcc.godbolt.org/">gcc</a>
                    , <a href="https://gcc.godbolt.org/">cppx</a>
                    , <a href="https://d.godbolt.org/">d</a>
                    , <a href="https://swift.godbolt.org/">swift</a>
                    , <a href="https://haskell.godbolt.org/">haskell</a>
                    , <a href="https://go.godbolt.org/">go</a>
                    , <a href="https://ispc.godbolt.org/">ispc</a> }.godbolt.org
                </div>
                <div class="footnote fragment"><h6>(And thank a compiler developer)</h6></div>
            </section>
        </section>

    </section>
</div>

<script src="reveal.js/lib/js/head.min.js"></script>
<script src="reveal.js/js/reveal.js"></script>

<script>
    Reveal.initialize({
        transition: 'none',
        history: true,
        slideNumber: true,
        math: {config: 'TeX-AMS_HTML-full'},
        dependencies: [
            {src: 'reveal.js/plugin/markdown/marked.js'},
            {src: 'reveal.js/plugin/markdown/markdown.js'},
            {src: 'reveal.js/plugin/math/math.js'},
            {src: 'reveal.js/plugin/notes/notes.js', async: true},
            {
                src: 'reveal.js/plugin/highlight/highlight.js', async: true,
                callback: function () {
                    hljs.initHighlightingOnLoad();
                }
            },
            {
                src: 'compiler-explorer.js',
                async: true
            }
        ]
    });
</script>
</body>
</html>