<!--#include virtual="../../header.incl" -->

<div class="www_sectiontitle">Women and Compilers and Tools Workshop at CGO 2020</div>
<p>
 The first ever Women in Compilers and Tools Workshop at CGO 2020!
</p>

<div style="float:left; width:68%;">
<p>When: Febuary 22, 2020</p>
<p>Where: San Diego, CA</p>
<p>The workshop is co-located with CC, HPCA, and PPoPP. It takes place at <a
    href="https://cgo-conference.github.io/cgo2020/venue/">Hilton San Diego Resort and Spa</a>
  in San Diego, CA.
</p>
<p>Register:
  <a href="https://cgo-conference.github.io/cgo2020/">At the CGO website.</a></p>

<div class="www_sectiontitle" id="#about">About</div>

<p>
The LLVM community has seen continued growth in our project, but one glance at an LLVM Developers’ Meeting and there is still an obvious diversity concern. This is not unique to the LLVM Developers’ Meeting but can be seen at CGO and other compiler related conferences. Companies, university, projects, research, and open source communities all benefit from different voices. 
</p><p>
This workshop is aimed to gather women and allies who share a common interest in increasing diversity within the field of compilers and tools. The workshop will feature a guest speaker, a panel discussion, and open conversation about important topics relevant to increasing diversity within compilers and tools. 
</p><p>
As we are finalizing speakers, the agenda will be published here. We encourage you to sign up and join our efforts.
</p>

<div class="www_sectiontitle" id="#faq">FAQ</div>
<p>
<ul>
<li>Who should attend? - Any one interested in increasing diversity within the field of compilers and tools.</li>
<li>Is this only for women? - Absolutely not! We need allies to help achieve our goals.
</li>
<li>
Is this only for students? - This workshop should be relatable for all attendees regardless of experience or years in the field.
</li>
</ul>
</p>

<div class="www_sectiontitle" id="#agenda">Agenda</div>
<p>Coming soon!</p>

<!--#include virtual="../../footer.incl" -->
