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

<div class="www_sectiontitle">EuroLLVM'19 Developers' Meeting</div>
<div style="float:left; width:68%;">
<br>
<div style="width:100%;"> 
<table><tr>
<td valign="top">
<ol>
        <li><a href="index.html">Conference Home Page</a></li>
</ol>
</td>

<td valign="top">
<ul>
   <li><b>Conference Dates</b>: April 8-9, 2019</li>
   <li><b>Location</b>: Brussels, Belgium</li>
</ul>
</td>
</tr></table>
</div>

<div class="www_sectiontitle" id="guide">Call for Papers - Detailed guidance on
  writing a proposal for the LLVM developers' meeting</div>

<p>This is a guide to help you submit the best proposal and increase your
chances of your proposal being accepted. The LLVM Developers' Meeting program
committee receives more proposals than can be accepted, so please read this
guide carefully.</p>

<p>If you have never presented at an LLVM Developers' Meeting, then do not fear
this process. We are actively looking for new speakers who are excited about
LLVM and helping grow the community through these educational talks! You do not
need to be a long time developer to submit a proposal.</p>

<p><b>General guidelines:</b>
<ul>
  <li>It should be clear from your abstract what your topic is, who your
    targeted audience is, and what are the takeaways for attendees. The program
    committee gets a lot of proposals and does not have time to read 10 page
    papers for each submission (excluding SRC submissions).</li>
  <li>Talks about a use of LLVM (etc) should include details about how LLVM is
    used and not only be about the resulting application.</li>
  <li>Tutorials on "how to use X" in LLVM (or other subproject) are greatly
    desired and beneficial to many developers. Entry level topics are
    encouraged as well.</li>
  <li>Talks that have been presented at other technical conferences tend to not
    get accepted. If you have presented this topic before, make it clear what
    is new and different in your talk.</li>
  <li>We suggest you proofread and pay attention to grammar.</li>
</ul>
</p>

<p><b>Technical talk &amp; tutorial proposal template:</b></p>

<p><em>Title:</em></p>
<ul>
  <li>This will be displayed on the website, schedule, and signs.</li>
  <li>Keep it short and catchy to attract attendees to your talk. A couple of
    examples are "WebAssembly: Here Be Dragons" or "Beyond Sanitizers: guided
    fuzzing and security hardening".</li>
</ul>

<p><em>Speaker Name(s), Company, Email:</em></p>
<ul>
  <li>This should be only the people giving the talk. HotCRP allows you to list
  authors but not speakers. We also recommend you put speakers only in the HotCRP
  "Contact" field so they are the ones contacted regarding conference
  details.</li>
</ul>

<p><em>Abstract:</em><p>
<ul>
  <li>1-2 paragraphs. Keep in mind that this is displayed on the schedule and
  website for attendees to consider when selecting talks.</li>
</ul>

<p><em>Submission:</em></p>
<ul>
  <li>Include details about your talk in the PDF you upload: an outline, demo
    description, background of the speaker, etc.</li>
  <li>For tutorials, include additional details such as tutorial outline, what
    materials you will provide attendees, etc.</li>
  <li>This will not be published and is intended for the PC to better
    understand how interesting your talk will be to the audience. For example,
    if you would prefer not to reveal some conclusions in the published
    abstract, explaining them here ensures that the PC can take them into
    account when evaluating your proposal.</li>
</ul>

<p><b>SRC talk proposal template:</b></p>

<p><em>Title:</em></p>
<ul>
  <li>This will be displayed on the website, schedule, and signs.</li>
  <li>Keep it short and catchy to attract attendees to your talks. A couple of
    examples are "WebAssembly: Here Be Dragons" or "Beyond Sanitizers: guided
    fuzzing and security hardening".</li>
</ul>

<p><em>Speaker Name(s), Company, Email:</em></p>
<ul>
  <li>This should be only the people giving the talk. HotCRP allows you to list
    authors but not speakers. We also recommend you put speakers only in the
    HotCRP "Contact" field so they are the ones contacted regarding conference
    details.</li>
</ul>

<p><em>Abstract:</em></p>
<ul>
  <li>1-2 paragraphs. Keep in mind that this is displayed on the schedule and
  website for attendees to consider when selecting talks.</li>
</ul>

<p><em>Submission:</em></p>
<ul>
  <li>Details must be provided in a 2 pages pdf, formatted using the SIGPLAN
    article format : 8.5in x 11in single spaced, double column page with a 10pt
    or larger font.</li>
  <li>Optionally, you can attach your actual research paper, but that's mainly
    for the benefit of the reviewers who may not have time to actually read
    it.</li>
  <li>If you need an embargo (delaying the publishing of the slides and video
    by up to 12 months), please fill-in the embargo request text box.</li>
  <li>You are strongly encouraged to submit your talk as a poster as well as it
    will enable wider discussions at the meeting. The Program committee might
    also not select your talk proposal, but still offers you to present a
    poster.</li>
  <li>This will not be published and is intended for the PC to better
    understand how interesting your talk will be to the audience. For example,
    if you would prefer not to reveal some conclusions in the published
    abstract, explaining them here ensures that the PC can take them into
    account when evaluating your proposal.</li>
</ul>

<p><b>BoF proposal template:</b></p>

<p><em>Title:</em></p>
<ul>
  <li>This will be displayed on the website, schedule, and signs. These tend to
    be very straight forward about the area being discussed. An example is
    "Future directions and features for LLDB".</li>
</ul>

<p><em>Speaker Name(s), Company, Email:</em></p>
<ul>
  <li>This should be only the people giving the talk. HotCRP allows you to list
    authors but not speakers. We also recommend you put speakers only in the
    HotCRP "Contact" field so they are the ones contacted regarding conference
    details.</li>
</ul>

<p><em>Abstract:</em></p>
<ul>
  <li>1-2 paragraphs. Keep in mind that this is displayed on the schedule and
  website for attendees to consider when selecting which BoFs to attend.</li>
</ul>

<p><em>Submission:</em></p>
<ul>
  <li>Provide additional details in the PDF you upload: goals of the BoF,
    presentation style. BoFs are to brainstorm ideas on a specific topic but
    you will be more successful if you have a guided discussion with talking
    points and actionable items at the end.</li>
  <li>Provide some talking points or potential subtopics.</li>
  <li>This will not be published and is intended for the PC to better
    understand how interesting your talk will be to the audience.</li>
</ul>

<p><b>Lightning talks & Poster proposal template:</b></p>

<p><em>Title:</em></p>
<ul>
  <li>This will be displayed on the website, schedule, and signs.</li>
  <li>Keep it short and catchy to attract attendees to your talks. A couple of
    examples are "WebAssembly: Here Be Dragons" or "Beyond Sanitizers: guided
    fuzzing and security hardening".</li>
</ul>

<p><em>Speaker Name(s), Company, Email:</em></p>
<ul>
  <li>This should be only the people presenting the poster. HotCRP allows you to
    list authors but not presenters. We also recommend you put presenters only
    in the HotCRP "Contact" field so they are the ones contacted regarding
    conference details.</li>
</ul>

<p><em>Abstract:</em></p>
<ul>
  <li>1-2 paragraphs. Keep in mind that this is displayed on the schedule and
    website for attendees to consider when selecting the posters they want to
    look at.</li>
</ul>

<p><em>Submission:</em></p>
<ul>
  <li>No need for a detailed PDF submission.</li>
</ul>
</div>

<!-- *********************************************************************** -->

<!--#include virtual="sponsors.incl" -->

<hr>

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