
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional //EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd"><html xmlns="http://www.w3.org/1999/xhtml" xmlns:o="urn:schemas-microsoft-com:office:office" xmlns:v="urn:schemas-microsoft-com:vml" lang="en"><head>
  <title>Eclipse Foundation Member Newsletter - April 2021</title>
  <meta property="og:title" content="Eclipse Foundation Member Newsletter - April 2021">
  <meta name="twitter:title" content="Eclipse Foundation Member Newsletter - April 2021">
  
  
  
<meta name="x-apple-disable-message-reformatting">
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">

<meta http-equiv="X-UA-Compatible" content="IE=edge">

<meta name="viewport" content="width=device-width, initial-scale=1.0">


  <!--[if gte mso 9]>
<xml>
    <o:OfficeDocumentSettings>
    <o:AllowPNG/>
    <o:PixelsPerInch>96</o:PixelsPerInch>
    </o:OfficeDocumentSettings>
</xml>

<style>
  ul > li {
    text-indent: -1em;
  }
</style>
<![endif]-->
<!--[if mso]>
<style type="text/css">
body, td {font-family: Arial, Helvetica, sans-serif;}
</style>
<![endif]-->


  






    









  


<meta name="generator" content="HubSpot"><meta property="og:url" content="http://eclipse-5413615.hs-sites.com/eclipse-foundation-member-newsletter-april-2021"><meta name="robots" content="noindex,follow"><!--[if !((mso)|(IE))]><!-- --><style type="text/css">.moz-text-html .hse-column-container{max-width:600px !important;width:600px !important}
.moz-text-html .hse-column{display:table-cell;vertical-align:top}.moz-text-html .hse-section .hse-size-6{max-width:300px !important;width:300px !important}
.moz-text-html .hse-section .hse-size-12{max-width:600px !important;width:600px !important}
[owa] .hse-column-container{max-width:600px !important;width:600px !important}[owa] .hse-column{display:table-cell;vertical-align:top}
[owa] .hse-section .hse-size-6{max-width:300px !important;width:300px !important}
[owa] .hse-section .hse-size-12{max-width:600px !important;width:600px !important}
@media only screen and (min-width:640px){.hse-column-container{max-width:600px !important;width:600px !important}
.hse-column{display:table-cell;vertical-align:top}.hse-section .hse-size-6{max-width:300px !important;width:300px !important}
.hse-section .hse-size-12{max-width:600px !important;width:600px !important}}@media only screen and (max-width:639px){img.stretch-on-mobile,.hs_rss_email_entries_table img{height:auto !important;width:100% !important}
.display_block_on_small_screens{display:block}.hs_padded{padding-left:20px !important;padding-right:20px !important}
ul,blockquote{margin:0;padding:1em 40px}}</style><!--<![endif]--><style type="text/css">body[data-outlook-cycle] img.stretch-on-mobile,body[data-outlook-cycle] .hs_rss_email_entries_table img{height:auto !important;width:100% !important}
body[data-outlook-cycle] .hs_padded{padding-left:20px !important;padding-right:20px !important}
a[x-apple-data-detectors]{color:inherit !important;text-decoration:none !important;font-size:inherit !important;font-family:inherit !important;font-weight:inherit !important;line-height:inherit !important}
#outlook a{padding:0}.yshortcuts a{border-bottom:none !important}a{text-decoration:underline}
.ExternalClass{width:100%}.ExternalClass,.ExternalClass p,.ExternalClass td,.ExternalClass div,.ExternalClass span,.ExternalClass font{line-height:100%}
p{margin:0}body{-ms-text-size-adjust:100%;-webkit-text-size-adjust:100%;-webkit-font-smoothing:antialiased;moz-osx-font-smoothing:grayscale}</style></head>
<body bgcolor="#f2f2f2" style="margin:0 !important; padding:0 !important; font-family:Arial, sans-serif; font-size:15px; color:#444444; word-break:break-word">
  


<div id="preview_text" style="display:none!important;font-size:1px;color:#f2f2f2;line-height:1px;max-height:0px;max-width:0px;opacity:0;overflow:hidden;">We want to keep you informed! Here's a list of our new members and a breakdown of all the recent activity at the Eclipse Foundation.  </div>


  
<!--[if gte mso 9]>
<v:background xmlns:v="urn:schemas-microsoft-com:vml" fill="t">

  <v:fill type="tile" size="100%,100%" color="#f2f2f2"/>

</v:background>
<![endif]-->


  <div class="hse-body-background" style="background-color:#f2f2f2" bgcolor="#f2f2f2">
    <table role="presentation" class="hse-body-wrapper-table" cellpadding="0" cellspacing="0" style="border-spacing:0 !important; border-collapse:collapse; mso-table-lspace:0pt; mso-table-rspace:0pt; margin:0; padding:0; width:100% !important; min-width:320px !important; height:100% !important" width="100%" height="100%">
      <tbody><tr>
        <td class="hse-body-wrapper-td" valign="top" style="border-collapse:collapse; mso-line-height-rule:exactly; font-family:Arial, sans-serif; font-size:15px; color:#444444; word-break:break-word; padding-top:20px">
          <div id="hs_cos_wrapper_main" class="hs_cos_wrapper hs_cos_wrapper_widget hs_cos_wrapper_type_dnd_area" style="color: inherit; font-size: inherit; line-height: inherit;" data-hs-cos-general-type="widget" data-hs-cos-type="dnd_area">  <div id="section_1618844097429" class="hse-section hse-section-first" style="padding-left:10px; padding-right:10px">

  
  
  <!--[if !((mso)|(IE))]><!-- -->
    <div class="hse-column-container" style="min-width:280px; max-width:600px; width:100%; Margin-left:auto; Margin-right:auto; border-collapse:collapse; border-spacing:0">
  <!--<![endif]-->
  
  <!--[if (mso)|(IE)]>
    <div class="hse-column-container" style="min-width:280px;max-width:600px;width:100%;Margin-left:auto;Margin-right:auto;border-collapse:collapse;border-spacing:0;">
    <table align="center" style="border-collapse:collapse;mso-table-lspace:0pt;mso-table-rspace:0pt;width:600px;" cellpadding="0" cellspacing="0" role="presentation">
    <tr>
  <![endif]-->

  <!--[if (mso)|(IE)]>
<td valign="top" style="width:598px;">
<![endif]-->
<!--[if gte mso 9]>
<table role="presentation" width="598" cellpadding="0" cellspacing="0" style="border-collapse:collapse;mso-table-lspace:0pt;mso-table-rspace:0pt;width:598px">
<![endif]-->
<div id="column_1618844097429_0" class="hse-column hse-size-12">
<div id="hs_cos_wrapper_module_161884409742841" class="hs_cos_wrapper hs_cos_wrapper_widget hs_cos_wrapper_type_module" style="color: inherit; font-size: inherit; line-height: inherit;" data-hs-cos-general-type="widget" data-hs-cos-type="module">









<div style="overflow:hidden">
<table role="presentation" class="hse-pre-header hse-secondary" width="100%" cellpadding="0" cellspacing="0" style="border-spacing:0 !important; border-collapse:collapse; mso-table-lspace:0pt; mso-table-rspace:0pt; text-align:right; font-family:Arial, sans-serif; font-size:12px; line-height:135%; color:#23496d; margin-bottom:0; padding:0" align="right">
  <tbody>
      <tr>
          <td align="right" valign="top" style="border-collapse:collapse; mso-line-height-rule:exactly; color:#444444; word-break:break-word; text-align:right; font-family:Arial, sans-serif; font-size:12px; padding:10px 0; margin-bottom:0; line-height:135%">
              <a href="http://eclipse-5413615.hs-sites.com/eclipse-foundation-member-newsletter-april-2021?ecid=&amp;utm_campaign=April%202020&amp;utm_source=hs_email&amp;utm_medium=email&amp;_hsenc=p2ANqtz--iPJ_XUnwkdfU0wuFX1Rc_6vGB_Rm5LnqzBU2GJe-pCqpvN5yHEVVLJkVFCFDoy6dsQ3-m" style="mso-line-height-rule:exactly; color:#F79422; font-weight:normal; text-decoration:underline; font-style:normal" data-hs-link-id="0" target="_blank">View in browser</a>
          </td>
      </tr>
  </tbody>
</table>
</div>
</div>
</div>
<!--[if gte mso 9]></table><![endif]-->
<!--[if (mso)|(IE)]></td><![endif]-->


  <!--[if (mso)|(IE)]></tr></table><![endif]-->

  </div>
 
</div>

<div id="section_0" class="hse-section" style="padding-left:10px; padding-right:10px">

  
  
  <!--[if !((mso)|(IE))]><!-- -->
    <div class="hse-column-container hse-border hse-border-top" style="min-width:280px; max-width:600px; width:100%; Margin-left:auto; Margin-right:auto; border-collapse:collapse; border-spacing:0; border-left:1px solid #cccccc; border-right:1px solid #cccccc; box-sizing:border-box; border-top:1px solid #cccccc; background-color:#f79422" bgcolor="#f79422">
  <!--<![endif]-->
  
  <!--[if (mso)|(IE)]>
    <div class="hse-column-container" style="min-width:280px;max-width:600px;width:100%;Margin-left:auto;Margin-right:auto;border-collapse:collapse;border-spacing:0;">
    <table align="center" style="border-collapse:collapse;mso-table-lspace:0pt;mso-table-rspace:0pt;width:600px;border-left:1px solid #cccccc;border-right:1px solid #cccccc;border-top:1px solid #cccccc" cellpadding="0" cellspacing="0" role="presentation" class="hse-border hse-border-top" width="600" bgcolor="#f79422">
    <tr style="background-color:#f79422;">
  <![endif]-->

  <!--[if (mso)|(IE)]>
<td valign="top" style="width:598px;">
<![endif]-->
<!--[if gte mso 9]>
<table role="presentation" width="598" cellpadding="0" cellspacing="0" style="border-collapse:collapse;mso-table-lspace:0pt;mso-table-rspace:0pt;width:598px">
<![endif]-->
<div id="column_0_0" class="hse-column hse-size-12">
<div id="hs_cos_wrapper_module_1519314331610150" class="hs_cos_wrapper hs_cos_wrapper_widget hs_cos_wrapper_type_module" style="color: inherit; font-size: inherit; line-height: inherit;" data-hs-cos-general-type="widget" data-hs-cos-type="module">







<table class="hse-image-wrapper" role="presentation" width="100%" cellpadding="0" cellspacing="0" style="border-spacing:0 !important; border-collapse:collapse; mso-table-lspace:0pt; mso-table-rspace:0pt">
  <tbody>
      <tr>
          <td align="left" valign="top" style="border-collapse:collapse; mso-line-height-rule:exactly; font-family:Arial, sans-serif; color:#444444; word-break:break-word; text-align:left; padding:10px 20px; font-size:0px">
              
                  <a href="https://www.eclipse.org/?utm_campaign=April%202020&amp;utm_source=hs_email&amp;utm_medium=email&amp;_hsenc=p2ANqtz--iPJ_XUnwkdfU0wuFX1Rc_6vGB_Rm5LnqzBU2GJe-pCqpvN5yHEVVLJkVFCFDoy6dsQ3-m" target="_blank" style="color:#00a4bd; mso-line-height-rule:exactly" data-hs-link-id="0">
              
              <img alt="Member_Newsletter_Header_Template_(1)" src="https://hs-5413615.f.hubspotemail.net/hub/5413615/hubfs/April%202021%20Member%20Newsletter/Member_Newsletter_Header_Template_(1).png?upscale=true&amp;width=1116&amp;upscale=true&amp;name=Member_Newsletter_Header_Template_(1).png" style="outline:none; text-decoration:none; -ms-interpolation-mode:bicubic; border:none; max-width:100%; font-size:16px" width="558" align="middle" srcset="https://hs-5413615.f.hubspotemail.net/hub/5413615/hubfs/April%202021%20Member%20Newsletter/Member_Newsletter_Header_Template_(1).png?upscale=true&amp;width=1116&amp;upscale=true&amp;name=Member_Newsletter_Header_Template_(1).png 558w, https://hs-5413615.f.hubspotemail.net/hub/5413615/hubfs/April%202021%20Member%20Newsletter/Member_Newsletter_Header_Template_(1).png?upscale=true&amp;width=2232&amp;upscale=true&amp;name=Member_Newsletter_Header_Template_(1).png 1116w" sizes="(max-width: 558px) 100vw, 558px">
              
                  </a>
              
          </td>
      </tr>
  </tbody>
</table>
</div>
</div>
<!--[if gte mso 9]></table><![endif]-->
<!--[if (mso)|(IE)]></td><![endif]-->


  <!--[if (mso)|(IE)]></tr></table><![endif]-->

  </div>
 
</div>

<div id="section_2" class="hse-section" style="padding-left:10px; padding-right:10px">

  
  
  <!--[if !((mso)|(IE))]><!-- -->
    <div class="hse-column-container hse-border" style="min-width:280px; max-width:600px; width:100%; Margin-left:auto; Margin-right:auto; border-collapse:collapse; border-spacing:0; border-left:1px solid #cccccc; border-right:1px solid #cccccc; box-sizing:border-box; background-color:#ffffff" bgcolor="#ffffff">
  <!--<![endif]-->
  
  <!--[if (mso)|(IE)]>
    <div class="hse-column-container" style="min-width:280px;max-width:600px;width:100%;Margin-left:auto;Margin-right:auto;border-collapse:collapse;border-spacing:0;">
    <table align="center" style="border-collapse:collapse;mso-table-lspace:0pt;mso-table-rspace:0pt;width:600px;border-left:1px solid #cccccc;border-right:1px solid #cccccc" cellpadding="0" cellspacing="0" role="presentation" class="hse-border" width="600" bgcolor="#ffffff">
    <tr style="background-color:#ffffff;">
  <![endif]-->

  <!--[if (mso)|(IE)]>
<td valign="top" style="width:598px;">
<![endif]-->
<!--[if gte mso 9]>
<table role="presentation" width="598" cellpadding="0" cellspacing="0" style="border-collapse:collapse;mso-table-lspace:0pt;mso-table-rspace:0pt;width:598px">
<![endif]-->
<div id="column_2_0" class="hse-column hse-size-12">
<table role="presentation" cellpadding="0" cellspacing="0" width="100%" style="border-spacing:0 !important; border-collapse:collapse; mso-table-lspace:0pt; mso-table-rspace:0pt"><tbody><tr><td class="hs_padded" style="border-collapse:collapse; mso-line-height-rule:exactly; font-family:Arial, sans-serif; font-size:15px; color:#444444; word-break:break-word; padding:10px 20px"><div id="hs_cos_wrapper_module_1586291145041102" class="hs_cos_wrapper hs_cos_wrapper_widget hs_cos_wrapper_type_module" style="color: inherit; font-size: inherit; line-height: inherit;" data-hs-cos-general-type="widget" data-hs-cos-type="module"><div id="hs_cos_wrapper_module_1586291145041102_" class="hs_cos_wrapper hs_cos_wrapper_widget hs_cos_wrapper_type_rich_text" style="color: inherit; font-size: inherit; line-height: inherit;" data-hs-cos-general-type="widget" data-hs-cos-type="rich_text"><ul style="mso-line-height-rule:exactly; line-height:175%">
<li style="mso-line-height-rule:exactly"><span style="color: #444444;">EclipseCon 2021 Call for Proposals</span></li>
<li style="mso-line-height-rule:exactly"><span style="color: #444444;">Sponsoring EclipseCon 2021</span></li>
<li style="mso-line-height-rule:exactly"><span style="color: #444444;">Adoptium Working Group Established</span></li>
<li style="mso-line-height-rule:exactly"><span style="color: #444444;">Commitment to an Inclusive and Welcoming Community</span></li>
<li style="mso-line-height-rule:exactly"><span style="color: #444444;">Open VSX White Paper Released</span></li>
<li style="mso-line-height-rule:exactly"><span style="color: #444444;">Press Release Guidelines Updated</span></li>
</ul></div></div></td></tr></tbody></table>
</div>
<!--[if gte mso 9]></table><![endif]-->
<!--[if (mso)|(IE)]></td><![endif]-->


  <!--[if (mso)|(IE)]></tr></table><![endif]-->

  </div>
 
</div>

<div id="section_3" class="hse-section" style="padding-left:10px; padding-right:10px">

  
  
  <!--[if !((mso)|(IE))]><!-- -->
    <div class="hse-column-container hse-border" style="min-width:280px; max-width:600px; width:100%; Margin-left:auto; Margin-right:auto; border-collapse:collapse; border-spacing:0; border-left:1px solid #cccccc; border-right:1px solid #cccccc; box-sizing:border-box; background-color:#FFFFFF" bgcolor="#FFFFFF">
  <!--<![endif]-->
  
  <!--[if (mso)|(IE)]>
    <div class="hse-column-container" style="min-width:280px;max-width:600px;width:100%;Margin-left:auto;Margin-right:auto;border-collapse:collapse;border-spacing:0;">
    <table align="center" style="border-collapse:collapse;mso-table-lspace:0pt;mso-table-rspace:0pt;width:600px;border-left:1px solid #cccccc;border-right:1px solid #cccccc" cellpadding="0" cellspacing="0" role="presentation" class="hse-border" width="600" bgcolor="#FFFFFF">
    <tr style="background-color:#FFFFFF;">
  <![endif]-->

  <!--[if (mso)|(IE)]>
<td valign="top" style="width:598px;">
<![endif]-->
<!--[if gte mso 9]>
<table role="presentation" width="598" cellpadding="0" cellspacing="0" style="border-collapse:collapse;mso-table-lspace:0pt;mso-table-rspace:0pt;width:598px">
<![endif]-->
<div id="column_3_0" class="hse-column hse-size-12">
<table role="presentation" cellpadding="0" cellspacing="0" width="100%" style="border-spacing:0 !important; border-collapse:collapse; mso-table-lspace:0pt; mso-table-rspace:0pt"><tbody><tr><td class="hs_padded" style="border-collapse:collapse; mso-line-height-rule:exactly; font-family:Arial, sans-serif; font-size:15px; color:#444444; word-break:break-word; padding:0px 20px"><div id="hs_cos_wrapper_module_1519385550660107" class="hs_cos_wrapper hs_cos_wrapper_widget hs_cos_wrapper_type_module" style="color: inherit; font-size: inherit; line-height: inherit;" data-hs-cos-general-type="widget" data-hs-cos-type="module">









<!--[if gte mso 9]>
<v:rect xmlns:v="urn:schemas-microsoft-com:vml" fill="true" stroke="false" style="width:558px; height:2pt;" fillcolor="none">
<v:fill type="tile"/>
<v:textbox inset="0,0,0,0">

<div>

<![endif]-->
<table role="presentation" width="100%" align="left" border="0" style="position:relative; top:-1px; min-width:20px; width:100%; max-width:100%; border-spacing:0; mso-table-lspace:0pt; mso-table-rspace:0pt; border-collapse:collapse; font-size:1px">
<tbody><tr>
  
  
  
  <td width="100%" valign="middle" style="border-collapse:collapse; mso-line-height-rule:exactly; font-family:Arial, sans-serif; font-size:15px; color:#444444; word-break:break-word; line-height:0; border:transparent; border-bottom:1px solid #000000; mso-border-bottom-alt:1px solid #000000; border-bottom-width:1px">&nbsp;</td>
  
  
</tr>
</tbody></table>

<!--[if gte mso 9]></div></v:textbox></v:rect><![endif]-->
</div></td></tr></tbody></table>
<table role="presentation" cellpadding="0" cellspacing="0" width="100%" style="border-spacing:0 !important; border-collapse:collapse; mso-table-lspace:0pt; mso-table-rspace:0pt"><tbody><tr><td class="hs_padded" style="border-collapse:collapse; mso-line-height-rule:exactly; font-family:Arial, sans-serif; font-size:15px; color:#444444; word-break:break-word; padding:10px 20px"><div id="hs_cos_wrapper_module_16062366968383" class="hs_cos_wrapper hs_cos_wrapper_widget hs_cos_wrapper_type_module" style="color: inherit; font-size: inherit; line-height: inherit;" data-hs-cos-general-type="widget" data-hs-cos-type="module"><div id="hs_cos_wrapper_module_16062366968383_" class="hs_cos_wrapper hs_cos_wrapper_widget hs_cos_wrapper_type_rich_text" style="color: inherit; font-size: inherit; line-height: inherit;" data-hs-cos-general-type="widget" data-hs-cos-type="rich_text"><h1 style="margin:0; mso-line-height-rule:exactly; line-height:175%; font-family:Arial, sans-serif; font-size:24px; text-align:center" align="center">EclipseCon 2021 Call for Proposals</h1></div></div></td></tr></tbody></table>
<div id="hs_cos_wrapper_module_161583051054913" class="hs_cos_wrapper hs_cos_wrapper_widget hs_cos_wrapper_type_module" style="color: inherit; font-size: inherit; line-height: inherit;" data-hs-cos-general-type="widget" data-hs-cos-type="module">







<table class="hse-image-wrapper" role="presentation" width="100%" cellpadding="0" cellspacing="0" style="border-spacing:0 !important; border-collapse:collapse; mso-table-lspace:0pt; mso-table-rspace:0pt">
  <tbody>
      <tr>
          <td align="center" valign="top" style="border-collapse:collapse; mso-line-height-rule:exactly; font-family:Arial, sans-serif; color:#444444; word-break:break-word; text-align:center; padding:10px 20px; font-size:0px">
              
                  <a href="https://www.eclipsecon.org/2021/cfp?utm_campaign=April%202020&amp;utm_source=hs_email&amp;utm_medium=email&amp;_hsenc=p2ANqtz--iPJ_XUnwkdfU0wuFX1Rc_6vGB_Rm5LnqzBU2GJe-pCqpvN5yHEVVLJkVFCFDoy6dsQ3-m" target="_blank" style="color:#00a4bd; mso-line-height-rule:exactly" data-hs-link-id="0">
              
              <img alt="EclipseCon 2021" src="https://hs-5413615.f.hubspotemail.net/hub/5413615/hubfs/Member%20Newsletter%20-%20February%202021/EclipseCon%202021.png?upscale=true&amp;width=1116&amp;upscale=true&amp;name=EclipseCon%202021.png" style="outline:none; text-decoration:none; -ms-interpolation-mode:bicubic; border:none; max-width:100%; font-size:16px" width="558" align="middle" srcset="https://hs-5413615.f.hubspotemail.net/hub/5413615/hubfs/Member%20Newsletter%20-%20February%202021/EclipseCon%202021.png?upscale=true&amp;width=1116&amp;upscale=true&amp;name=EclipseCon%202021.png 558w, https://hs-5413615.f.hubspotemail.net/hub/5413615/hubfs/Member%20Newsletter%20-%20February%202021/EclipseCon%202021.png?upscale=true&amp;width=2232&amp;upscale=true&amp;name=EclipseCon%202021.png 1116w" sizes="(max-width: 558px) 100vw, 558px">
              
                  </a>
              
          </td>
      </tr>
  </tbody>
</table>
</div>
<table role="presentation" cellpadding="0" cellspacing="0" width="100%" style="border-spacing:0 !important; border-collapse:collapse; mso-table-lspace:0pt; mso-table-rspace:0pt"><tbody><tr><td class="hs_padded" style="border-collapse:collapse; mso-line-height-rule:exactly; font-family:Arial, sans-serif; font-size:15px; color:#444444; word-break:break-word; padding:10px 20px"><div id="hs_cos_wrapper_module_15193855506601072" class="hs_cos_wrapper hs_cos_wrapper_widget hs_cos_wrapper_type_module" style="color: inherit; font-size: inherit; line-height: inherit;" data-hs-cos-general-type="widget" data-hs-cos-type="module"><div id="hs_cos_wrapper_module_15193855506601072_" class="hs_cos_wrapper hs_cos_wrapper_widget hs_cos_wrapper_type_rich_text" style="color: inherit; font-size: inherit; line-height: inherit;" data-hs-cos-general-type="widget" data-hs-cos-type="rich_text"><div style="mso-line-height-rule:exactly; line-height:175%; text-align:center" align="center">
<p style="mso-line-height-rule:exactly; line-height:175%; text-align:left" align="left"><span style="color: #f79422;"><a href="https://www.eclipsecon.org/2021/?utm_campaign=April%202020&amp;utm_source=hs_email&amp;utm_medium=email&amp;_hsenc=p2ANqtz--iPJ_XUnwkdfU0wuFX1Rc_6vGB_Rm5LnqzBU2GJe-pCqpvN5yHEVVLJkVFCFDoy6dsQ3-m" style="mso-line-height-rule:exactly; color:#f79422" data-hs-link-id="0" target="_blank">EclipseCon 2021</a></span>, <span style="color: #444444;">our biggest event of the year, will be held October 25-28 and the call for conference talk proposals is now open!</span></p>
<p style="mso-line-height-rule:exactly; line-height:175%; text-align:left" align="left"><span style="color: #444444;">&nbsp;</span></p>
<p style="mso-line-height-rule:exactly; line-height:175%; text-align:left" align="left"><span style="color: #444444;">EclipseCon is the leading conference for developers, architects, and open source business leaders who want to learn about Eclipse technologies, share best practices, and more. The conference provides the Eclipse ecosystem and the industry’s leading minds an opportunity to explore common challenges and innovate together on open source runtimes, tools, and frameworks for cloud and edge applications, IoT, artificial intelligence, connected vehicles and transportation, digital ledger technologies, and much more.</span></p>
<p style="mso-line-height-rule:exactly; line-height:175%; text-align:left" align="left">&nbsp;</p>
<p style="mso-line-height-rule:exactly; line-height:175%; text-align:left" align="left"><span style="color: #f79422;"><a href="https://www.eclipsecon.org/2021/cfp?utm_campaign=April%202020&amp;utm_source=hs_email&amp;utm_medium=email&amp;_hsenc=p2ANqtz--iPJ_XUnwkdfU0wuFX1Rc_6vGB_Rm5LnqzBU2GJe-pCqpvN5yHEVVLJkVFCFDoy6dsQ3-m" style="mso-line-height-rule:exactly; color:#f79422" data-hs-link-id="1" target="_blank">Visit the CFP page</a></span> <span style="color: #444444;">to see the list of categories and submission details.</span></p>
<p style="mso-line-height-rule:exactly; line-height:175%; text-align:left" align="left">&nbsp;</p>
<p style="mso-line-height-rule:exactly; line-height:175%; text-align:left; font-weight:bold" align="left"><span style="color: #444444;">Important Dates</span></p>
<ul style="mso-line-height-rule:exactly; line-height:175%">
<li style="mso-line-height-rule:exactly; text-align:left" align="left"><strong>April 15:</strong> <span style="color: #444444;">CFP opened</span></li>
<li style="mso-line-height-rule:exactly; text-align:left" align="left"><strong>June 1:&nbsp;</strong><span style="color: #444444;">Early bird deadline</span></li>
<li style="mso-line-height-rule:exactly; text-align:left" align="left">
<p style="mso-line-height-rule:exactly; line-height:175%"><strong>June 15:&nbsp;</strong><span style="color: #444444;">Submissions close</span></p>
</li>
<li style="mso-line-height-rule:exactly; text-align:left" align="left"><strong>July 1:&nbsp;</strong><span style="color: #444444;">Speakers notified (date is approximate)</span></li>
</ul>
</div></div></div></td></tr></tbody></table>
</div>
<!--[if gte mso 9]></table><![endif]-->
<!--[if (mso)|(IE)]></td><![endif]-->


  <!--[if (mso)|(IE)]></tr></table><![endif]-->

  </div>
 
</div>

<div id="section_4" class="hse-section" style="padding-left:10px; padding-right:10px">

  
  
  <!--[if !((mso)|(IE))]><!-- -->
    <div class="hse-column-container hse-border" style="min-width:280px; max-width:600px; width:100%; Margin-left:auto; Margin-right:auto; border-collapse:collapse; border-spacing:0; border-left:1px solid #cccccc; border-right:1px solid #cccccc; box-sizing:border-box; background-color:#FFFFFF" bgcolor="#FFFFFF">
  <!--<![endif]-->
  
  <!--[if (mso)|(IE)]>
    <div class="hse-column-container" style="min-width:280px;max-width:600px;width:100%;Margin-left:auto;Margin-right:auto;border-collapse:collapse;border-spacing:0;">
    <table align="center" style="border-collapse:collapse;mso-table-lspace:0pt;mso-table-rspace:0pt;width:600px;border-left:1px solid #cccccc;border-right:1px solid #cccccc" cellpadding="0" cellspacing="0" role="presentation" class="hse-border" width="600" bgcolor="#FFFFFF">
    <tr style="background-color:#FFFFFF;">
  <![endif]-->

  <!--[if (mso)|(IE)]>
<td valign="top" style="width:598px;">
<![endif]-->
<!--[if gte mso 9]>
<table role="presentation" width="598" cellpadding="0" cellspacing="0" style="border-collapse:collapse;mso-table-lspace:0pt;mso-table-rspace:0pt;width:598px">
<![endif]-->
<div id="column_4_0" class="hse-column hse-size-12">
<table role="presentation" cellpadding="0" cellspacing="0" width="100%" style="border-spacing:0 !important; border-collapse:collapse; mso-table-lspace:0pt; mso-table-rspace:0pt"><tbody><tr><td class="hs_padded" style="border-collapse:collapse; mso-line-height-rule:exactly; font-family:Arial, sans-serif; font-size:15px; color:#444444; word-break:break-word; padding:0px 20px"><div id="hs_cos_wrapper_module_1519385551532115" class="hs_cos_wrapper hs_cos_wrapper_widget hs_cos_wrapper_type_module" style="color: inherit; font-size: inherit; line-height: inherit;" data-hs-cos-general-type="widget" data-hs-cos-type="module">









<!--[if gte mso 9]>
<v:rect xmlns:v="urn:schemas-microsoft-com:vml" fill="true" stroke="false" style="width:558px; height:2pt;" fillcolor="none">
<v:fill type="tile"/>
<v:textbox inset="0,0,0,0">

<div>

<![endif]-->
<table role="presentation" width="100%" align="center" border="0" style="position:relative; top:-1px; min-width:20px; width:100%; max-width:100%; border-spacing:0; mso-table-lspace:0pt; mso-table-rspace:0pt; border-collapse:collapse; font-size:1px">
<tbody><tr>
  
  
  
  <td width="100%" valign="middle" style="border-collapse:collapse; mso-line-height-rule:exactly; font-family:Arial, sans-serif; font-size:15px; color:#444444; word-break:break-word; line-height:0; border:transparent; border-bottom:1px solid #000000; mso-border-bottom-alt:1px solid #000000; border-bottom-width:1px">&nbsp;</td>
  
  
</tr>
</tbody></table>

<!--[if gte mso 9]></div></v:textbox></v:rect><![endif]-->
</div></td></tr></tbody></table>
<table role="presentation" cellpadding="0" cellspacing="0" width="100%" style="border-spacing:0 !important; border-collapse:collapse; mso-table-lspace:0pt; mso-table-rspace:0pt"><tbody><tr><td class="hs_padded" style="border-collapse:collapse; mso-line-height-rule:exactly; font-family:Arial, sans-serif; font-size:15px; color:#444444; word-break:break-word; padding:10px 20px"><div id="hs_cos_wrapper_module_16184984773151" class="hs_cos_wrapper hs_cos_wrapper_widget hs_cos_wrapper_type_module" style="color: inherit; font-size: inherit; line-height: inherit;" data-hs-cos-general-type="widget" data-hs-cos-type="module"><div id="hs_cos_wrapper_module_16184984773151_" class="hs_cos_wrapper hs_cos_wrapper_widget hs_cos_wrapper_type_rich_text" style="color: inherit; font-size: inherit; line-height: inherit;" data-hs-cos-general-type="widget" data-hs-cos-type="rich_text"><h1 style="margin:0; mso-line-height-rule:exactly; line-height:175%; font-family:Arial, sans-serif; font-size:24px; text-align:center" align="center">Sponsoring EclipseCon 2021</h1></div></div></td></tr></tbody></table>
<table role="presentation" cellpadding="0" cellspacing="0" width="100%" style="border-spacing:0 !important; border-collapse:collapse; mso-table-lspace:0pt; mso-table-rspace:0pt"><tbody><tr><td class="hs_padded" style="border-collapse:collapse; mso-line-height-rule:exactly; font-family:Arial, sans-serif; font-size:15px; color:#444444; word-break:break-word; padding:10px 20px"><div id="hs_cos_wrapper_module_15193855515321152" class="hs_cos_wrapper hs_cos_wrapper_widget hs_cos_wrapper_type_module" style="color: inherit; font-size: inherit; line-height: inherit;" data-hs-cos-general-type="widget" data-hs-cos-type="module"><div id="hs_cos_wrapper_module_15193855515321152_" class="hs_cos_wrapper hs_cos_wrapper_widget hs_cos_wrapper_type_rich_text" style="color: inherit; font-size: inherit; line-height: inherit;" data-hs-cos-general-type="widget" data-hs-cos-type="rich_text"><p style="mso-line-height-rule:exactly; line-height:175%"><a href="https://www.eclipsecon.org/2021/prospectus?utm_campaign=April%202020&amp;utm_source=hs_email&amp;utm_medium=email&amp;_hsenc=p2ANqtz--iPJ_XUnwkdfU0wuFX1Rc_6vGB_Rm5LnqzBU2GJe-pCqpvN5yHEVVLJkVFCFDoy6dsQ3-m" style="mso-line-height-rule:exactly; color:#f79422; text-decoration:none" rel="noopener" data-hs-link-id="0" target="_blank"><span style="color: #444444;">Eclipse member companies have a unique opportunity to connect with the open source community by sponsoring EclipseCon 2021. Huawei and IBM are excited to participate as Elite sponsors this year and have provided </span></a><a href="https://www.eclipsecon.org/2021/sponsor-testimonials?utm_campaign=April%202020&amp;utm_source=hs_email&amp;utm_medium=email&amp;_hsenc=p2ANqtz--iPJ_XUnwkdfU0wuFX1Rc_6vGB_Rm5LnqzBU2GJe-pCqpvN5yHEVVLJkVFCFDoy6dsQ3-m" style="mso-line-height-rule:exactly; color:#f79422" data-hs-link-id="0" target="_blank">video testimonials</a> to share their reasons for supporting the conference.</p>
<p style="mso-line-height-rule:exactly; line-height:175%">&nbsp;</p>
<p style="mso-line-height-rule:exactly; line-height:175%"><span style="color: #444444;">If you would like to join Huawei, IBM, EclipseSource, Bosch IO, and Obeo as an EclipseCon sponsor, email <span style="color: #f79422;"><a href="mailto:sponsors@eclipsecon.org" style="mso-line-height-rule:exactly; color:#f79422" rel="noopener" data-hs-link-id="0" target="_blank">sponsors@eclipsecon.org</a></span> or see the <a href="https://www.eclipsecon.org/2021/prospectus?utm_campaign=April%202020&amp;utm_source=hs_email&amp;utm_medium=email&amp;_hsenc=p2ANqtz--iPJ_XUnwkdfU0wuFX1Rc_6vGB_Rm5LnqzBU2GJe-pCqpvN5yHEVVLJkVFCFDoy6dsQ3-m" rel="noopener" style="mso-line-height-rule:exactly; color:#f79422" data-hs-link-id="1" target="_blank"><span style="text-decoration: underline; color: #f79422;">sponsorship prospectus</span></a>. <a href="https://www.eclipse.org/org/elections/?utm_campaign=April%202020&amp;utm_source=hs_email&amp;utm_medium=email&amp;_hsenc=p2ANqtz--iPJ_XUnwkdfU0wuFX1Rc_6vGB_Rm5LnqzBU2GJe-pCqpvN5yHEVVLJkVFCFDoy6dsQ3-m" style="mso-line-height-rule:exactly; text-decoration:none; color:#444444" data-hs-link-id="0" target="_blank"></a></span></p>
<p style="mso-line-height-rule:exactly; line-height:175%">&nbsp;</p>
<p style="mso-line-height-rule:exactly; line-height:175%"><span style="color: #444444;">For the latest news and announcements about EclipseCon 2021, follow <a href="https://twitter.com/EclipseCon?utm_campaign=April%202020&amp;utm_source=hs_email&amp;utm_medium=email&amp;_hsenc=p2ANqtz--iPJ_XUnwkdfU0wuFX1Rc_6vGB_Rm5LnqzBU2GJe-pCqpvN5yHEVVLJkVFCFDoy6dsQ3-m" style="mso-line-height-rule:exactly; color:#f79422" data-hs-link-id="0" target="_blank">@eclipsecon</a> on Twitter or visit <span style="color: #f79422;"><a href="https://www.eclipsecon.org/2021?utm_campaign=April%202020&amp;utm_source=hs_email&amp;utm_medium=email&amp;_hsenc=p2ANqtz--iPJ_XUnwkdfU0wuFX1Rc_6vGB_Rm5LnqzBU2GJe-pCqpvN5yHEVVLJkVFCFDoy6dsQ3-m" style="mso-line-height-rule:exactly; color:#f79422" data-hs-link-id="0" target="_blank">eclipsecon.org</a></span>.</span></p></div></div></td></tr></tbody></table>
</div>
<!--[if gte mso 9]></table><![endif]-->
<!--[if (mso)|(IE)]></td><![endif]-->


  <!--[if (mso)|(IE)]></tr></table><![endif]-->

  </div>
 
</div>

<div id="section_5" class="hse-section" style="padding-left:10px; padding-right:10px">

  
  
  <!--[if !((mso)|(IE))]><!-- -->
    <div class="hse-column-container hse-border" style="min-width:280px; max-width:600px; width:100%; Margin-left:auto; Margin-right:auto; border-collapse:collapse; border-spacing:0; border-left:1px solid #cccccc; border-right:1px solid #cccccc; box-sizing:border-box; background-color:#FFFFFF" bgcolor="#FFFFFF">
  <!--<![endif]-->
  
  <!--[if (mso)|(IE)]>
    <div class="hse-column-container" style="min-width:280px;max-width:600px;width:100%;Margin-left:auto;Margin-right:auto;border-collapse:collapse;border-spacing:0;">
    <table align="center" style="border-collapse:collapse;mso-table-lspace:0pt;mso-table-rspace:0pt;width:600px;border-left:1px solid #cccccc;border-right:1px solid #cccccc" cellpadding="0" cellspacing="0" role="presentation" class="hse-border" width="600" bgcolor="#FFFFFF">
    <tr style="background-color:#FFFFFF;">
  <![endif]-->

  <!--[if (mso)|(IE)]>
<td valign="top" style="width:598px;">
<![endif]-->
<!--[if gte mso 9]>
<table role="presentation" width="598" cellpadding="0" cellspacing="0" style="border-collapse:collapse;mso-table-lspace:0pt;mso-table-rspace:0pt;width:598px">
<![endif]-->
<div id="column_5_0" class="hse-column hse-size-12">
<table role="presentation" cellpadding="0" cellspacing="0" width="100%" style="border-spacing:0 !important; border-collapse:collapse; mso-table-lspace:0pt; mso-table-rspace:0pt"><tbody><tr><td class="hs_padded" style="border-collapse:collapse; mso-line-height-rule:exactly; font-family:Arial, sans-serif; font-size:15px; color:#444444; word-break:break-word; padding:0px 20px"><div id="hs_cos_wrapper_module_1519310315531203" class="hs_cos_wrapper hs_cos_wrapper_widget hs_cos_wrapper_type_module" style="color: inherit; font-size: inherit; line-height: inherit;" data-hs-cos-general-type="widget" data-hs-cos-type="module">









<!--[if gte mso 9]>
<v:rect xmlns:v="urn:schemas-microsoft-com:vml" fill="true" stroke="false" style="width:558px; height:2pt;" fillcolor="none">
<v:fill type="tile"/>
<v:textbox inset="0,0,0,0">

<div>

<![endif]-->
<table role="presentation" width="100%" align="center" border="0" style="position:relative; top:-1px; min-width:20px; width:100%; max-width:100%; border-spacing:0; mso-table-lspace:0pt; mso-table-rspace:0pt; border-collapse:collapse; font-size:1px">
<tbody><tr>
  
  
  
  <td width="100%" valign="middle" style="border-collapse:collapse; mso-line-height-rule:exactly; font-family:Arial, sans-serif; font-size:15px; color:#444444; word-break:break-word; line-height:0; border:transparent; border-bottom:1px solid #000000; mso-border-bottom-alt:1px solid #000000; border-bottom-width:1px">&nbsp;</td>
  
  
</tr>
</tbody></table>

<!--[if gte mso 9]></div></v:textbox></v:rect><![endif]-->
</div></td></tr></tbody></table>
<table role="presentation" cellpadding="0" cellspacing="0" width="100%" style="border-spacing:0 !important; border-collapse:collapse; mso-table-lspace:0pt; mso-table-rspace:0pt"><tbody><tr><td class="hs_padded" style="border-collapse:collapse; mso-line-height-rule:exactly; font-family:Arial, sans-serif; font-size:15px; color:#444444; word-break:break-word; padding:10px 20px"><div id="hs_cos_wrapper_module_16131416976173" class="hs_cos_wrapper hs_cos_wrapper_widget hs_cos_wrapper_type_module" style="color: inherit; font-size: inherit; line-height: inherit;" data-hs-cos-general-type="widget" data-hs-cos-type="module"><div id="hs_cos_wrapper_module_16131416976173_" class="hs_cos_wrapper hs_cos_wrapper_widget hs_cos_wrapper_type_rich_text" style="color: inherit; font-size: inherit; line-height: inherit;" data-hs-cos-general-type="widget" data-hs-cos-type="rich_text"><h1 style="margin:0; mso-line-height-rule:exactly; line-height:175%; font-family:Arial, sans-serif; font-size:24px; text-align:center" align="center">Adoptium Working Group Established</h1></div></div></td></tr></tbody></table>
<div id="hs_cos_wrapper_module_161849551303510" class="hs_cos_wrapper hs_cos_wrapper_widget hs_cos_wrapper_type_module" style="color: inherit; font-size: inherit; line-height: inherit;" data-hs-cos-general-type="widget" data-hs-cos-type="module">







<table class="hse-image-wrapper" role="presentation" width="100%" cellpadding="0" cellspacing="0" style="border-spacing:0 !important; border-collapse:collapse; mso-table-lspace:0pt; mso-table-rspace:0pt">
  <tbody>
      <tr>
          <td align="center" valign="top" style="border-collapse:collapse; mso-line-height-rule:exactly; font-family:Arial, sans-serif; color:#444444; word-break:break-word; text-align:center; padding:10px 20px; font-size:0px">
              
                  <a href="https://newsroom.eclipse.org/news/announcements/eclipse-foundation-launches-adoptium-working-group-multi-vendor-delivery-java?utm_campaign=April%202020&amp;utm_source=hs_email&amp;utm_medium=email&amp;_hsenc=p2ANqtz--iPJ_XUnwkdfU0wuFX1Rc_6vGB_Rm5LnqzBU2GJe-pCqpvN5yHEVVLJkVFCFDoy6dsQ3-m" target="_blank" style="color:#00a4bd; mso-line-height-rule:exactly" data-hs-link-id="0">
              
              <img alt="23" src="https://hs-5413615.f.hubspotemail.net/hub/5413615/hubfs/Member%20Newsletter%20-%20April%202020/23.png?upscale=true&amp;width=1116&amp;upscale=true&amp;name=23.png" style="outline:none; text-decoration:none; -ms-interpolation-mode:bicubic; border:none; max-width:100%; font-size:16px" width="558" align="middle" srcset="https://hs-5413615.f.hubspotemail.net/hub/5413615/hubfs/Member%20Newsletter%20-%20April%202020/23.png?upscale=true&amp;width=1116&amp;upscale=true&amp;name=23.png 558w, https://hs-5413615.f.hubspotemail.net/hub/5413615/hubfs/Member%20Newsletter%20-%20April%202020/23.png?upscale=true&amp;width=2232&amp;upscale=true&amp;name=23.png 1116w" sizes="(max-width: 558px) 100vw, 558px">
              
                  </a>
              
          </td>
      </tr>
  </tbody>
</table>
</div>
<table role="presentation" cellpadding="0" cellspacing="0" width="100%" style="border-spacing:0 !important; border-collapse:collapse; mso-table-lspace:0pt; mso-table-rspace:0pt"><tbody><tr><td class="hs_padded" style="border-collapse:collapse; mso-line-height-rule:exactly; font-family:Arial, sans-serif; font-size:15px; color:#444444; word-break:break-word; padding:10px 20px"><div id="hs_cos_wrapper_module_161583048544912" class="hs_cos_wrapper hs_cos_wrapper_widget hs_cos_wrapper_type_module" style="color: inherit; font-size: inherit; line-height: inherit;" data-hs-cos-general-type="widget" data-hs-cos-type="module"><div id="hs_cos_wrapper_module_161583048544912_" class="hs_cos_wrapper hs_cos_wrapper_widget hs_cos_wrapper_type_rich_text" style="color: inherit; font-size: inherit; line-height: inherit;" data-hs-cos-general-type="widget" data-hs-cos-type="rich_text"><p style="mso-line-height-rule:exactly; line-height:175%">On March 23, 2021, the Eclipse Foundation announced the <span style="color: #f79422;"><a href="https://newsroom.eclipse.org/news/announcements/eclipse-foundation-launches-adoptium-working-group-multi-vendor-delivery-java?utm_campaign=April%202020&amp;utm_source=hs_email&amp;utm_medium=email&amp;_hsenc=p2ANqtz--iPJ_XUnwkdfU0wuFX1Rc_6vGB_Rm5LnqzBU2GJe-pCqpvN5yHEVVLJkVFCFDoy6dsQ3-m" style="mso-line-height-rule:exactly; color:#f79422" data-hs-link-id="1" target="_blank">establishment of the Adoptium Working Group</a></span> in collaboration with the AdoptOpenJDK Technical Steering Committee.</p>
<p style="mso-line-height-rule:exactly; line-height:175%">&nbsp;</p>
<p style="mso-line-height-rule:exactly; line-height:175%">Adoptium was founded by multiple participants, including many Java developers and vendors such as Alibaba Cloud, Huawei, IBM, iJUG, Karakun AG, Microsoft, New Relic, and Red Hat. The Adoptium Working Group will provide the Java ecosystem with fully compatible, high-quality distributions of Java runtimes based on OpenJDK source code.</p>
<p style="mso-line-height-rule:exactly; line-height:175%">&nbsp;</p>
<p style="mso-line-height-rule:exactly; line-height:175%">The Adoptium Working Group complements the <span style="color: #f79422;"><a href="https://projects.eclipse.org/projects/adoptium?utm_campaign=April%202020&amp;utm_source=hs_email&amp;utm_medium=email&amp;_hsenc=p2ANqtz--iPJ_XUnwkdfU0wuFX1Rc_6vGB_Rm5LnqzBU2GJe-pCqpvN5yHEVVLJkVFCFDoy6dsQ3-m" style="mso-line-height-rule:exactly; color:#f79422" data-hs-link-id="0" target="_blank">Eclipse Adoptium project</a></span>, which provides a trusted location where developers and enterprises can download compatible binaries of OpenJDK builds. The goal of the Adoptium Working Group is to provide the infrastructure, marketing, community building, and developer advocacy work needed to continue to ensure timely releases to the community and further the adoption of Eclipse Adoptium.</p>
<p style="mso-line-height-rule:exactly; line-height:175%">&nbsp;</p>
<p style="mso-line-height-rule:exactly; line-height:175%">All members are welcome to participate in the working group. Please reach out to&nbsp;<a href="mailto:membership@eclipse.org" target="_blank" rel="noopener" style="mso-line-height-rule:exactly; color:#f79422" data-hs-link-id="0">membership@eclipse.org</a> to find out more.</p></div></div></td></tr></tbody></table>
</div>
<!--[if gte mso 9]></table><![endif]-->
<!--[if (mso)|(IE)]></td><![endif]-->


  <!--[if (mso)|(IE)]></tr></table><![endif]-->

  </div>
 
</div>

<div id="section_6" class="hse-section" style="padding-left:10px; padding-right:10px">

  
  
  <!--[if !((mso)|(IE))]><!-- -->
    <div class="hse-column-container hse-border" style="min-width:280px; max-width:600px; width:100%; Margin-left:auto; Margin-right:auto; border-collapse:collapse; border-spacing:0; border-left:1px solid #cccccc; border-right:1px solid #cccccc; box-sizing:border-box; background-color:#FFFFFF" bgcolor="#FFFFFF">
  <!--<![endif]-->
  
  <!--[if (mso)|(IE)]>
    <div class="hse-column-container" style="min-width:280px;max-width:600px;width:100%;Margin-left:auto;Margin-right:auto;border-collapse:collapse;border-spacing:0;">
    <table align="center" style="border-collapse:collapse;mso-table-lspace:0pt;mso-table-rspace:0pt;width:600px;border-left:1px solid #cccccc;border-right:1px solid #cccccc" cellpadding="0" cellspacing="0" role="presentation" class="hse-border" width="600" bgcolor="#FFFFFF">
    <tr style="background-color:#FFFFFF;">
  <![endif]-->

  <!--[if (mso)|(IE)]>
<td valign="top" style="width:598px;">
<![endif]-->
<!--[if gte mso 9]>
<table role="presentation" width="598" cellpadding="0" cellspacing="0" style="border-collapse:collapse;mso-table-lspace:0pt;mso-table-rspace:0pt;width:598px">
<![endif]-->
<div id="column_6_0" class="hse-column hse-size-12">
<table role="presentation" cellpadding="0" cellspacing="0" width="100%" style="border-spacing:0 !important; border-collapse:collapse; mso-table-lspace:0pt; mso-table-rspace:0pt"><tbody><tr><td class="hs_padded" style="border-collapse:collapse; mso-line-height-rule:exactly; font-family:Arial, sans-serif; font-size:15px; color:#444444; word-break:break-word; padding:0px 20px"><div id="hs_cos_wrapper_module_1594734810783259" class="hs_cos_wrapper hs_cos_wrapper_widget hs_cos_wrapper_type_module" style="color: inherit; font-size: inherit; line-height: inherit;" data-hs-cos-general-type="widget" data-hs-cos-type="module">









<!--[if gte mso 9]>
<v:rect xmlns:v="urn:schemas-microsoft-com:vml" fill="true" stroke="false" style="width:558px; height:2pt;" fillcolor="none">
<v:fill type="tile"/>
<v:textbox inset="0,0,0,0">

<div>

<![endif]-->
<table role="presentation" width="100%" align="center" border="0" style="position:relative; top:-1px; min-width:20px; width:100%; max-width:100%; border-spacing:0; mso-table-lspace:0pt; mso-table-rspace:0pt; border-collapse:collapse; font-size:1px">
<tbody><tr>
  
  
  
  <td width="100%" valign="middle" style="border-collapse:collapse; mso-line-height-rule:exactly; font-family:Arial, sans-serif; font-size:15px; color:#444444; word-break:break-word; line-height:0; border:transparent; border-bottom:1px solid #000000; mso-border-bottom-alt:1px solid #000000; border-bottom-width:1px">&nbsp;</td>
  
  
</tr>
</tbody></table>

<!--[if gte mso 9]></div></v:textbox></v:rect><![endif]-->
</div></td></tr></tbody></table>
<table role="presentation" cellpadding="0" cellspacing="0" width="100%" style="border-spacing:0 !important; border-collapse:collapse; mso-table-lspace:0pt; mso-table-rspace:0pt"><tbody><tr><td class="hs_padded" style="border-collapse:collapse; mso-line-height-rule:exactly; font-family:Arial, sans-serif; font-size:15px; color:#444444; word-break:break-word; padding:10px 20px"><div id="hs_cos_wrapper_module_16184948533082" class="hs_cos_wrapper hs_cos_wrapper_widget hs_cos_wrapper_type_module" style="color: inherit; font-size: inherit; line-height: inherit;" data-hs-cos-general-type="widget" data-hs-cos-type="module"><div id="hs_cos_wrapper_module_16184948533082_" class="hs_cos_wrapper hs_cos_wrapper_widget hs_cos_wrapper_type_rich_text" style="color: inherit; font-size: inherit; line-height: inherit;" data-hs-cos-general-type="widget" data-hs-cos-type="rich_text"><h1 style="margin:0; mso-line-height-rule:exactly; line-height:175%; font-family:Arial, sans-serif; font-size:24px; text-align:center" align="center">Commitment to an Inclusive<br>and Welcoming Community</h1></div></div></td></tr></tbody></table>
<table role="presentation" cellpadding="0" cellspacing="0" width="100%" style="border-spacing:0 !important; border-collapse:collapse; mso-table-lspace:0pt; mso-table-rspace:0pt"><tbody><tr><td class="hs_padded" style="border-collapse:collapse; mso-line-height-rule:exactly; font-family:Arial, sans-serif; font-size:15px; color:#444444; word-break:break-word; padding:10px 20px"><div id="hs_cos_wrapper_module_15947348107832592" class="hs_cos_wrapper hs_cos_wrapper_widget hs_cos_wrapper_type_module" style="color: inherit; font-size: inherit; line-height: inherit;" data-hs-cos-general-type="widget" data-hs-cos-type="module"><div id="hs_cos_wrapper_module_15947348107832592_" class="hs_cos_wrapper hs_cos_wrapper_widget hs_cos_wrapper_type_rich_text" style="color: inherit; font-size: inherit; line-height: inherit;" data-hs-cos-general-type="widget" data-hs-cos-type="rich_text"><p style="mso-line-height-rule:exactly; line-height:175%">As described further in our <a href="https://www.eclipse.org/org/documents/Community_Code_of_Conduct.php?utm_campaign=April%202020&amp;utm_source=hs_email&amp;utm_medium=email&amp;_hsenc=p2ANqtz--iPJ_XUnwkdfU0wuFX1Rc_6vGB_Rm5LnqzBU2GJe-pCqpvN5yHEVVLJkVFCFDoy6dsQ3-m" rel="noopener" style="mso-line-height-rule:exactly; color:#f79422" data-hs-link-id="0" target="_blank">Code of Conduct</a>, we are committed to creating a welcoming and inclusive environment in the Eclipse community. It is paramount that each member of the community is treated with trust, empathy, and respect.&nbsp;</p>
<p style="mso-line-height-rule:exactly; line-height:175%">&nbsp;</p>
<p style="mso-line-height-rule:exactly; line-height:175%">In light of the recent violent attacks on people of Asian descent, Mike Milinkovich, <span style="font-weight: normal;">the Eclipse Foundation Executive Director,</span> condemned these actions and the bigotry that has driven them in a <span style="color: #f79422;"><a href="https://blogs.eclipse.org/post/mike-milinkovich/support-asian-communities-eclipse-foundation?utm_campaign=April%202020&amp;utm_source=hs_email&amp;utm_medium=email&amp;_hsenc=p2ANqtz--iPJ_XUnwkdfU0wuFX1Rc_6vGB_Rm5LnqzBU2GJe-pCqpvN5yHEVVLJkVFCFDoy6dsQ3-m" style="mso-line-height-rule:exactly; color:#f79422" data-hs-link-id="0" target="_blank">blog post</a></span>. We welcome any and all suggestions on how we can become a more inclusive and welcoming place for everyone.</p></div></div></td></tr></tbody></table>
</div>
<!--[if gte mso 9]></table><![endif]-->
<!--[if (mso)|(IE)]></td><![endif]-->


  <!--[if (mso)|(IE)]></tr></table><![endif]-->

  </div>
 
</div>

<div id="section_7" class="hse-section" style="padding-left:10px; padding-right:10px">

  
  
  <!--[if !((mso)|(IE))]><!-- -->
    <div class="hse-column-container hse-border" style="min-width:280px; max-width:600px; width:100%; Margin-left:auto; Margin-right:auto; border-collapse:collapse; border-spacing:0; border-left:1px solid #cccccc; border-right:1px solid #cccccc; box-sizing:border-box; background-color:#FFFFFF" bgcolor="#FFFFFF">
  <!--<![endif]-->
  
  <!--[if (mso)|(IE)]>
    <div class="hse-column-container" style="min-width:280px;max-width:600px;width:100%;Margin-left:auto;Margin-right:auto;border-collapse:collapse;border-spacing:0;">
    <table align="center" style="border-collapse:collapse;mso-table-lspace:0pt;mso-table-rspace:0pt;width:600px;border-left:1px solid #cccccc;border-right:1px solid #cccccc" cellpadding="0" cellspacing="0" role="presentation" class="hse-border" width="600" bgcolor="#FFFFFF">
    <tr style="background-color:#FFFFFF;">
  <![endif]-->

  <!--[if (mso)|(IE)]>
<td valign="top" style="width:598px;">
<![endif]-->
<!--[if gte mso 9]>
<table role="presentation" width="598" cellpadding="0" cellspacing="0" style="border-collapse:collapse;mso-table-lspace:0pt;mso-table-rspace:0pt;width:598px">
<![endif]-->
<div id="column_7_0" class="hse-column hse-size-12">
<table role="presentation" cellpadding="0" cellspacing="0" width="100%" style="border-spacing:0 !important; border-collapse:collapse; mso-table-lspace:0pt; mso-table-rspace:0pt"><tbody><tr><td class="hs_padded" style="border-collapse:collapse; mso-line-height-rule:exactly; font-family:Arial, sans-serif; font-size:15px; color:#444444; word-break:break-word; padding:0px 20px"><div id="hs_cos_wrapper_module_1598385152620211" class="hs_cos_wrapper hs_cos_wrapper_widget hs_cos_wrapper_type_module" style="color: inherit; font-size: inherit; line-height: inherit;" data-hs-cos-general-type="widget" data-hs-cos-type="module">









<!--[if gte mso 9]>
<v:rect xmlns:v="urn:schemas-microsoft-com:vml" fill="true" stroke="false" style="width:558px; height:2pt;" fillcolor="none">
<v:fill type="tile"/>
<v:textbox inset="0,0,0,0">

<div>

<![endif]-->
<table role="presentation" width="100%" align="center" border="0" style="position:relative; top:-1px; min-width:20px; width:100%; max-width:100%; border-spacing:0; mso-table-lspace:0pt; mso-table-rspace:0pt; border-collapse:collapse; font-size:1px">
<tbody><tr>
  
  
  
  <td width="100%" valign="middle" style="border-collapse:collapse; mso-line-height-rule:exactly; font-family:Arial, sans-serif; font-size:15px; color:#444444; word-break:break-word; line-height:0; border:transparent; border-bottom:1px solid #000000; mso-border-bottom-alt:1px solid #000000; border-bottom-width:1px">&nbsp;</td>
  
  
</tr>
</tbody></table>

<!--[if gte mso 9]></div></v:textbox></v:rect><![endif]-->
</div></td></tr></tbody></table>
<table role="presentation" cellpadding="0" cellspacing="0" width="100%" style="border-spacing:0 !important; border-collapse:collapse; mso-table-lspace:0pt; mso-table-rspace:0pt"><tbody><tr><td class="hs_padded" style="border-collapse:collapse; mso-line-height-rule:exactly; font-family:Arial, sans-serif; font-size:15px; color:#444444; word-break:break-word; padding:10px 20px"><div id="hs_cos_wrapper_module_16184986970321" class="hs_cos_wrapper hs_cos_wrapper_widget hs_cos_wrapper_type_module" style="color: inherit; font-size: inherit; line-height: inherit;" data-hs-cos-general-type="widget" data-hs-cos-type="module"><div id="hs_cos_wrapper_module_16184986970321_" class="hs_cos_wrapper hs_cos_wrapper_widget hs_cos_wrapper_type_rich_text" style="color: inherit; font-size: inherit; line-height: inherit;" data-hs-cos-general-type="widget" data-hs-cos-type="rich_text"><h1 style="margin:0; mso-line-height-rule:exactly; line-height:175%; font-family:Arial, sans-serif; font-size:24px; text-align:center" align="center">Open VSX White Paper Released</h1></div></div></td></tr></tbody></table>
<div id="hs_cos_wrapper_module_16184953665324" class="hs_cos_wrapper hs_cos_wrapper_widget hs_cos_wrapper_type_module" style="color: inherit; font-size: inherit; line-height: inherit;" data-hs-cos-general-type="widget" data-hs-cos-type="module">







<table class="hse-image-wrapper" role="presentation" width="100%" cellpadding="0" cellspacing="0" style="border-spacing:0 !important; border-collapse:collapse; mso-table-lspace:0pt; mso-table-rspace:0pt">
  <tbody>
      <tr>
          <td align="center" valign="top" style="border-collapse:collapse; mso-line-height-rule:exactly; font-family:Arial, sans-serif; color:#444444; word-break:break-word; text-align:center; padding:10px 20px; font-size:0px">
              
                  <a href="https://outreach.eclipse.foundation/openvsx?utm_campaign=April%202020&amp;utm_source=hs_email&amp;utm_medium=email&amp;_hsenc=p2ANqtz--iPJ_XUnwkdfU0wuFX1Rc_6vGB_Rm5LnqzBU2GJe-pCqpvN5yHEVVLJkVFCFDoy6dsQ3-m" target="_blank" style="color:#00a4bd; mso-line-height-rule:exactly" data-hs-link-id="0">
              
              <img alt="24" src="https://hs-5413615.f.hubspotemail.net/hub/5413615/hubfs/Member%20Newsletter%20-%20April%202020/24.png?upscale=true&amp;width=1116&amp;upscale=true&amp;name=24.png" style="outline:none; text-decoration:none; -ms-interpolation-mode:bicubic; border:none; max-width:100%; font-size:16px" width="558" align="middle" srcset="https://hs-5413615.f.hubspotemail.net/hub/5413615/hubfs/Member%20Newsletter%20-%20April%202020/24.png?upscale=true&amp;width=1116&amp;upscale=true&amp;name=24.png 558w, https://hs-5413615.f.hubspotemail.net/hub/5413615/hubfs/Member%20Newsletter%20-%20April%202020/24.png?upscale=true&amp;width=2232&amp;upscale=true&amp;name=24.png 1116w" sizes="(max-width: 558px) 100vw, 558px">
              
                  </a>
              
          </td>
      </tr>
  </tbody>
</table>
</div>
<table role="presentation" cellpadding="0" cellspacing="0" width="100%" style="border-spacing:0 !important; border-collapse:collapse; mso-table-lspace:0pt; mso-table-rspace:0pt"><tbody><tr><td class="hs_padded" style="border-collapse:collapse; mso-line-height-rule:exactly; font-family:Arial, sans-serif; font-size:15px; color:#444444; word-break:break-word; padding:10px 20px"><div id="hs_cos_wrapper_module_15983851526202113" class="hs_cos_wrapper hs_cos_wrapper_widget hs_cos_wrapper_type_module" style="color: inherit; font-size: inherit; line-height: inherit;" data-hs-cos-general-type="widget" data-hs-cos-type="module"><div id="hs_cos_wrapper_module_15983851526202113_" class="hs_cos_wrapper hs_cos_wrapper_widget hs_cos_wrapper_type_rich_text" style="color: inherit; font-size: inherit; line-height: inherit;" data-hs-cos-general-type="widget" data-hs-cos-type="rich_text"><p style="mso-line-height-rule:exactly; line-height:175%">With the transition of the Open VSX Registry from TypeFox to the Eclipse Foundation, the industry now has a vendor-neutral and publicly hosted open source alternative to the Microsoft Visual Studio Marketplace for VS Code extensions. The move increases transparency and flexibility for extension users, extension publishers, and tool developers.</p>
<p style="mso-line-height-rule:exactly; line-height:175%">&nbsp;</p>
<p style="mso-line-height-rule:exactly; line-height:175%">To mark this exciting development in the Eclipse Cloud DevTools community, we’ve released a new white paper that explores why the industry needs a more flexible and open approach to VS Code extensions and marketplace technologies.</p>
<p style="mso-line-height-rule:exactly; line-height:175%">&nbsp;</p>
<p style="mso-line-height-rule:exactly; line-height:175%"><span style="color: #000000;"><span style="color: #f79422;"><a href="https://outreach.eclipse.foundation/openvsx?utm_campaign=April%202020&amp;utm_source=hs_email&amp;utm_medium=email&amp;_hsenc=p2ANqtz--iPJ_XUnwkdfU0wuFX1Rc_6vGB_Rm5LnqzBU2GJe-pCqpvN5yHEVVLJkVFCFDoy6dsQ3-m" style="mso-line-height-rule:exactly; color:#f79422" rel="noopener" data-hs-link-id="1" target="_blank">Read the white paper here</a></span><a href="https://outreach.eclipse.foundation/openvsx?utm_campaign=April%202020&amp;utm_source=hs_email&amp;utm_medium=email&amp;_hsenc=p2ANqtz--iPJ_XUnwkdfU0wuFX1Rc_6vGB_Rm5LnqzBU2GJe-pCqpvN5yHEVVLJkVFCFDoy6dsQ3-m" style="mso-line-height-rule:exactly; text-decoration:none; color:#000000" data-hs-link-id="2" target="_blank">.</a></span></p></div></div></td></tr></tbody></table>
<table role="presentation" cellpadding="0" cellspacing="0" width="100%" style="border-spacing:0 !important; border-collapse:collapse; mso-table-lspace:0pt; mso-table-rspace:0pt"><tbody><tr><td class="hs_padded" style="border-collapse:collapse; mso-line-height-rule:exactly; font-family:Arial, sans-serif; font-size:15px; color:#444444; word-break:break-word; padding:0px 20px"><div id="hs_cos_wrapper_module_16158290929903" class="hs_cos_wrapper hs_cos_wrapper_widget hs_cos_wrapper_type_module" style="color: inherit; font-size: inherit; line-height: inherit;" data-hs-cos-general-type="widget" data-hs-cos-type="module">









<!--[if gte mso 9]>
<v:rect xmlns:v="urn:schemas-microsoft-com:vml" fill="true" stroke="false" style="width:558px; height:2pt;" fillcolor="none">
<v:fill type="tile"/>
<v:textbox inset="0,0,0,0">

<div>

<![endif]-->
<table role="presentation" width="100%" align="center" border="0" style="position:relative; top:-1px; min-width:20px; width:100%; max-width:100%; border-spacing:0; mso-table-lspace:0pt; mso-table-rspace:0pt; border-collapse:collapse; font-size:1px">
<tbody><tr>
  
  
  
  <td width="100%" valign="middle" style="border-collapse:collapse; mso-line-height-rule:exactly; font-family:Arial, sans-serif; font-size:15px; color:#444444; word-break:break-word; line-height:0; border:transparent; border-bottom:1px solid #000000; mso-border-bottom-alt:1px solid #000000; border-bottom-width:1px">&nbsp;</td>
  
  
</tr>
</tbody></table>

<!--[if gte mso 9]></div></v:textbox></v:rect><![endif]-->
</div></td></tr></tbody></table>
<table role="presentation" cellpadding="0" cellspacing="0" width="100%" style="border-spacing:0 !important; border-collapse:collapse; mso-table-lspace:0pt; mso-table-rspace:0pt"><tbody><tr><td class="hs_padded" style="border-collapse:collapse; mso-line-height-rule:exactly; font-family:Arial, sans-serif; font-size:15px; color:#444444; word-break:break-word; padding:10px 20px"><div id="hs_cos_wrapper_module_16184952078023" class="hs_cos_wrapper hs_cos_wrapper_widget hs_cos_wrapper_type_module" style="color: inherit; font-size: inherit; line-height: inherit;" data-hs-cos-general-type="widget" data-hs-cos-type="module"><div id="hs_cos_wrapper_module_16184952078023_" class="hs_cos_wrapper hs_cos_wrapper_widget hs_cos_wrapper_type_rich_text" style="color: inherit; font-size: inherit; line-height: inherit;" data-hs-cos-general-type="widget" data-hs-cos-type="rich_text"><h1 style="margin:0; mso-line-height-rule:exactly; line-height:175%; font-family:Arial, sans-serif; font-size:24px; text-align:center" align="center">Press Release Guidelines Updated</h1></div></div></td></tr></tbody></table>
<table role="presentation" cellpadding="0" cellspacing="0" width="100%" style="border-spacing:0 !important; border-collapse:collapse; mso-table-lspace:0pt; mso-table-rspace:0pt"><tbody><tr><td class="hs_padded" style="border-collapse:collapse; mso-line-height-rule:exactly; font-family:Arial, sans-serif; font-size:15px; color:#444444; word-break:break-word; padding:10px 20px"><div id="hs_cos_wrapper_module_16158291138816" class="hs_cos_wrapper hs_cos_wrapper_widget hs_cos_wrapper_type_module" style="color: inherit; font-size: inherit; line-height: inherit;" data-hs-cos-general-type="widget" data-hs-cos-type="module"><div id="hs_cos_wrapper_module_16158291138816_" class="hs_cos_wrapper hs_cos_wrapper_widget hs_cos_wrapper_type_rich_text" style="color: inherit; font-size: inherit; line-height: inherit;" data-hs-cos-general-type="widget" data-hs-cos-type="rich_text"><p style="mso-line-height-rule:exactly; line-height:175%">The Eclipse community works together to achieve great things, and it’s important to share this progress with the greater open source community through the media.</p>
<p style="mso-line-height-rule:exactly; line-height:175%">&nbsp;</p>
<p style="mso-line-height-rule:exactly; line-height:175%">With that in mind, the Eclipse Foundation marketing team has recently updated our <span style="color: #f79422;"><a href="https://www.eclipse.org/org/press-release/pressrelease_guidelines.php?utm_campaign=April%202020&amp;utm_source=hs_email&amp;utm_medium=email&amp;_hsenc=p2ANqtz--iPJ_XUnwkdfU0wuFX1Rc_6vGB_Rm5LnqzBU2GJe-pCqpvN5yHEVVLJkVFCFDoy6dsQ3-m" style="mso-line-height-rule:exactly; color:#f79422" data-hs-link-id="0" target="_blank">Press Release Guidelines</a> </span>to outline our press release process. We also recently published a blog that explains how you can <span style="color: #f79422;"><a href="https://blogs.eclipse.org/post/shanda-giacomoni/share-your-news-eclipse-foundation-press-release-0?utm_campaign=April%202020&amp;utm_source=hs_email&amp;utm_medium=email&amp;_hsenc=p2ANqtz--iPJ_XUnwkdfU0wuFX1Rc_6vGB_Rm5LnqzBU2GJe-pCqpvN5yHEVVLJkVFCFDoy6dsQ3-m" style="mso-line-height-rule:exactly; color:#f79422" rel="noopener" data-hs-link-id="0" target="_blank">share your news with an Eclipse Foundation press release</a></span>.</p></div></div></td></tr></tbody></table>
</div>
<!--[if gte mso 9]></table><![endif]-->
<!--[if (mso)|(IE)]></td><![endif]-->


  <!--[if (mso)|(IE)]></tr></table><![endif]-->

  </div>
 
</div>

<div id="section_8" class="hse-section" style="padding-left:10px; padding-right:10px">

  
  
  <!--[if !((mso)|(IE))]><!-- -->
    <div class="hse-column-container hse-border" style="min-width:280px; max-width:600px; width:100%; Margin-left:auto; Margin-right:auto; border-collapse:collapse; border-spacing:0; border-left:1px solid #cccccc; border-right:1px solid #cccccc; box-sizing:border-box; background-color:#f79422" bgcolor="#f79422">
  <!--<![endif]-->
  
  <!--[if (mso)|(IE)]>
    <div class="hse-column-container" style="min-width:280px;max-width:600px;width:100%;Margin-left:auto;Margin-right:auto;border-collapse:collapse;border-spacing:0;">
    <table align="center" style="border-collapse:collapse;mso-table-lspace:0pt;mso-table-rspace:0pt;width:600px;border-left:1px solid #cccccc;border-right:1px solid #cccccc" cellpadding="0" cellspacing="0" role="presentation" class="hse-border" width="600" bgcolor="#f79422">
    <tr style="background-color:#f79422;">
  <![endif]-->

  <!--[if (mso)|(IE)]>
<td valign="top" style="width:598px;">
<![endif]-->
<!--[if gte mso 9]>
<table role="presentation" width="598" cellpadding="0" cellspacing="0" style="border-collapse:collapse;mso-table-lspace:0pt;mso-table-rspace:0pt;width:598px">
<![endif]-->
<div id="column_8_0" class="hse-column hse-size-12">
<table role="presentation" cellpadding="0" cellspacing="0" width="100%" style="border-spacing:0 !important; border-collapse:collapse; mso-table-lspace:0pt; mso-table-rspace:0pt"><tbody><tr><td class="hs_padded" style="border-collapse:collapse; mso-line-height-rule:exactly; font-family:Arial, sans-serif; font-size:15px; color:#444444; word-break:break-word; padding:10px 20px"><div id="hs_cos_wrapper_module_1586443203069146" class="hs_cos_wrapper hs_cos_wrapper_widget hs_cos_wrapper_type_module" style="color: inherit; font-size: inherit; line-height: inherit;" data-hs-cos-general-type="widget" data-hs-cos-type="module"><div id="hs_cos_wrapper_module_1586443203069146_" class="hs_cos_wrapper hs_cos_wrapper_widget hs_cos_wrapper_type_rich_text" style="color: inherit; font-size: inherit; line-height: inherit;" data-hs-cos-general-type="widget" data-hs-cos-type="rich_text"><p style="mso-line-height-rule:exactly; line-height:175%; text-align:center" align="center"><span style="color:#ffffff;font-size:24px;"><strong>Upcoming Virtual Events</strong></span></p></div></div></td></tr></tbody></table>
</div>
<!--[if gte mso 9]></table><![endif]-->
<!--[if (mso)|(IE)]></td><![endif]-->


  <!--[if (mso)|(IE)]></tr></table><![endif]-->

  </div>
 
</div>

<div id="section_9" class="hse-section" style="padding-left:10px; padding-right:10px">

  
  
  <!--[if !((mso)|(IE))]><!-- -->
    <div class="hse-column-container hse-border" style="min-width:280px; max-width:600px; width:100%; Margin-left:auto; Margin-right:auto; border-collapse:collapse; border-spacing:0; border-left:1px solid #cccccc; border-right:1px solid #cccccc; box-sizing:border-box; background-color:#ffffff" bgcolor="#ffffff">
  <!--<![endif]-->
  
  <!--[if (mso)|(IE)]>
    <div class="hse-column-container" style="min-width:280px;max-width:600px;width:100%;Margin-left:auto;Margin-right:auto;border-collapse:collapse;border-spacing:0;">
    <table align="center" style="border-collapse:collapse;mso-table-lspace:0pt;mso-table-rspace:0pt;width:600px;border-left:1px solid #cccccc;border-right:1px solid #cccccc" cellpadding="0" cellspacing="0" role="presentation" class="hse-border" width="600" bgcolor="#ffffff">
    <tr style="background-color:#ffffff;">
  <![endif]-->

  <!--[if (mso)|(IE)]>
<td valign="top" style="width:598px;">
<![endif]-->
<!--[if gte mso 9]>
<table role="presentation" width="598" cellpadding="0" cellspacing="0" style="border-collapse:collapse;mso-table-lspace:0pt;mso-table-rspace:0pt;width:598px">
<![endif]-->
<div id="column_9_0" class="hse-column hse-size-12">
<table role="presentation" cellpadding="0" cellspacing="0" width="100%" style="border-spacing:0 !important; border-collapse:collapse; mso-table-lspace:0pt; mso-table-rspace:0pt"><tbody><tr><td class="hs_padded" style="border-collapse:collapse; mso-line-height-rule:exactly; font-family:Arial, sans-serif; font-size:15px; color:#444444; word-break:break-word; padding:10px 20px"><div id="hs_cos_wrapper_module_1586443203069148" class="hs_cos_wrapper hs_cos_wrapper_widget hs_cos_wrapper_type_module" style="color: inherit; font-size: inherit; line-height: inherit;" data-hs-cos-general-type="widget" data-hs-cos-type="module"><div id="hs_cos_wrapper_module_1586443203069148_" class="hs_cos_wrapper hs_cos_wrapper_widget hs_cos_wrapper_type_rich_text" style="color: inherit; font-size: inherit; line-height: inherit;" data-hs-cos-general-type="widget" data-hs-cos-type="rich_text"><div style="mso-line-height-rule:exactly; font-size:15px; line-height:150%"><span style="color: #444444;"><span style="color: #f79422;"><a href="https://www.crowdcast.io/e/cloudtooltime_apr20_21?utm_campaign=April%202020&amp;utm_source=hs_email&amp;utm_medium=email&amp;_hsenc=p2ANqtz--iPJ_XUnwkdfU0wuFX1Rc_6vGB_Rm5LnqzBU2GJe-pCqpvN5yHEVVLJkVFCFDoy6dsQ3-m" style="mso-line-height-rule:exactly; color:#f79422" rel="noopener" data-hs-link-id="0" target="_blank">Diagram editors in Theia and VSCode with ECLIPSE GLSP</a></span> | Cloud Tool Time | <br>April 20</span></div>
<div style="mso-line-height-rule:exactly; font-size:15px; line-height:150%">&nbsp;</div>
<div style="mso-line-height-rule:exactly; font-size:15px; line-height:150%"><span style="color: #444444;"><span style="color: #f79422;"><a href="https://www.crowdcast.io/e/edgeofthings_apr27_21?utm_campaign=April%202020&amp;utm_source=hs_email&amp;utm_medium=email&amp;_hsenc=p2ANqtz--iPJ_XUnwkdfU0wuFX1Rc_6vGB_Rm5LnqzBU2GJe-pCqpvN5yHEVVLJkVFCFDoy6dsQ3-m" style="mso-line-height-rule:exactly; color:#f79422" rel="noopener" data-hs-link-id="0" target="_blank">IoT and Edge Device Security</a></span> | The Edge of Things | April 27</span></div>
<div style="mso-line-height-rule:exactly; font-size:15px; line-height:150%">&nbsp;</div>
<div style="mso-line-height-rule:exactly; font-size:15px; line-height:150%"><span style="color: #444444;"><span style="color: #f79422;"><a href="https://tmt.knect365.com/embedded-iot-world/?utm_campaign=April%202020&amp;utm_source=hs_email&amp;utm_medium=email&amp;_hsenc=p2ANqtz--iPJ_XUnwkdfU0wuFX1Rc_6vGB_Rm5LnqzBU2GJe-pCqpvN5yHEVVLJkVFCFDoy6dsQ3-m" style="mso-line-height-rule:exactly; color:#f79422" rel="noopener" data-hs-link-id="0" target="_blank">Embedded IoT World</a></span> | April 28-29</span></div>
<div style="mso-line-height-rule:exactly; font-size:15px; line-height:150%">&nbsp;</div>
<div style="mso-line-height-rule:exactly; font-size:15px; line-height:150%"><span style="color: #444444;"><span style="color: #f79422;"><a href="https://www.crowdcast.io/e/jakarta_tech_talk_apr29_2?utm_campaign=April%202020&amp;utm_source=hs_email&amp;utm_medium=email&amp;_hsenc=p2ANqtz--iPJ_XUnwkdfU0wuFX1Rc_6vGB_Rm5LnqzBU2GJe-pCqpvN5yHEVVLJkVFCFDoy6dsQ3-m" style="mso-line-height-rule:exactly; color:#f79422" rel="noopener" data-hs-link-id="0" target="_blank">Building a cloud-friendly application</a></span> | Jakarta Tech Talks | April 29</span></div>
<div style="mso-line-height-rule:exactly; font-size:15px; line-height:150%">&nbsp;</div>
<div style="mso-line-height-rule:exactly; font-size:15px; line-height:150%"><span style="color: #444444;"><span style="color: #f79422;"><a href="https://www.crowdcast.io/e/jakarta_tech_talk_may10_2?utm_campaign=April%202020&amp;utm_source=hs_email&amp;utm_medium=email&amp;_hsenc=p2ANqtz--iPJ_XUnwkdfU0wuFX1Rc_6vGB_Rm5LnqzBU2GJe-pCqpvN5yHEVVLJkVFCFDoy6dsQ3-m" style="mso-line-height-rule:exactly; color:#f79422" rel="noopener" data-hs-link-id="0" target="_blank">JPAstreamer: Expressing Hibernate/JPA queries with Java streams</a></span> | </span></div>
<div style="mso-line-height-rule:exactly; font-size:15px; line-height:150%"><span style="color: #444444;">Jakarta Tech Talks | May 10</span></div>
<div style="mso-line-height-rule:exactly; font-size:15px; line-height:150%">&nbsp;</div>
<div style="mso-line-height-rule:exactly; font-size:15px; line-height:150%"><span style="color: #444444;"><span style="color: #f79422;"><a href="https://www.crowdcast.io/e/cloudtooltime_may11_21?utm_campaign=April%202020&amp;utm_source=hs_email&amp;utm_medium=email&amp;_hsenc=p2ANqtz--iPJ_XUnwkdfU0wuFX1Rc_6vGB_Rm5LnqzBU2GJe-pCqpvN5yHEVVLJkVFCFDoy6dsQ3-m" style="mso-line-height-rule:exactly; color:#f79422" rel="noopener" data-hs-link-id="0" target="_blank">Eclipse Che &amp; Git-Hub Codespaces</a></span> | Cloud Tool Time | May 11</span></div>
<div style="mso-line-height-rule:exactly; font-size:15px; line-height:150%">&nbsp;</div>
<div style="mso-line-height-rule:exactly; font-size:15px; line-height:150%"><span style="color: #444444;"><span style="color: #f79422;"><a href="https://www.crowdcast.io/e/jakarta_tech_talk_may18_2?utm_campaign=April%202020&amp;utm_source=hs_email&amp;utm_medium=email&amp;_hsenc=p2ANqtz--iPJ_XUnwkdfU0wuFX1Rc_6vGB_Rm5LnqzBU2GJe-pCqpvN5yHEVVLJkVFCFDoy6dsQ3-m" style="mso-line-height-rule:exactly; color:#f79422" rel="noopener" data-hs-link-id="0" target="_blank">Why Jakarta EE Matters</a></span> | Jakarta Tech Talks | May 18</span></div>
<div style="mso-line-height-rule:exactly; font-size:15px; line-height:150%">&nbsp;</div>
<div style="mso-line-height-rule:exactly; font-size:15px; line-height:150%"><span style="color: #444444;"><span style="color: #f79422;"><a href="https://ecdtools.eclipse.org/events/idesummit/2021/?utm_campaign=April%202020&amp;utm_source=hs_email&amp;utm_medium=email&amp;_hsenc=p2ANqtz--iPJ_XUnwkdfU0wuFX1Rc_6vGB_Rm5LnqzBU2GJe-pCqpvN5yHEVVLJkVFCFDoy6dsQ3-m" style="mso-line-height-rule:exactly; color:#f79422" rel="noopener" data-hs-link-id="0" target="_blank">Cloud IDE Day 2021</a></span> | May 19</span></div>
<div style="mso-line-height-rule:exactly; font-size:15px; line-height:150%">&nbsp;</div>
<div style="mso-line-height-rule:exactly; font-size:15px; line-height:150%"><span style="color: #444444;"><span style="color: #f79422;"><a href="https://www.crowdcast.io/e/virtualiotandedgeday2021?utm_campaign=April%202020&amp;utm_source=hs_email&amp;utm_medium=email&amp;_hsenc=p2ANqtz--iPJ_XUnwkdfU0wuFX1Rc_6vGB_Rm5LnqzBU2GJe-pCqpvN5yHEVVLJkVFCFDoy6dsQ3-m" style="mso-line-height-rule:exactly; color:#f79422" rel="noopener" data-hs-link-id="0" target="_blank">Virtual IoT and Edge Day 2021</a></span> | May 27</span></div>
<div style="mso-line-height-rule:exactly; font-size:15px; line-height:150%">&nbsp;</div>
<div style="mso-line-height-rule:exactly; font-size:15px; line-height:150%"><span style="color: #444444;"><a href="https://events.eclipse.org/2021/saam-mobility/?utm_campaign=April%202020&amp;utm_source=hs_email&amp;utm_medium=email&amp;_hsenc=p2ANqtz--iPJ_XUnwkdfU0wuFX1Rc_6vGB_Rm5LnqzBU2GJe-pCqpvN5yHEVVLJkVFCFDoy6dsQ3-m" rel="noopener" style="mso-line-height-rule:exactly; color:#f79422" data-hs-link-id="0" target="_blank">Eclipse SAAM Mobility 2021</a> | June 15-16</span></div>
<div style="mso-line-height-rule:exactly; font-size:15px; line-height:150%">&nbsp;</div>
<div style="mso-line-height-rule:exactly; font-size:15px; line-height:150%">
<p style="mso-line-height-rule:exactly; line-height:175%; margin-top:0cm; margin-right:0cm; margin-bottom:0cm; padding-left:0cm"><span style="color: #1d1c1d; background-color: white;">Visit </span><span style="color: #f79422;"><a href="https://events.eclipse.org/?utm_campaign=April%202020&amp;utm_source=hs_email&amp;utm_medium=email&amp;_hsenc=p2ANqtz--iPJ_XUnwkdfU0wuFX1Rc_6vGB_Rm5LnqzBU2GJe-pCqpvN5yHEVVLJkVFCFDoy6dsQ3-m" style="mso-line-height-rule:exactly; color:#f79422" data-hs-link-id="0" target="_blank"><span style="background-color: white;">events.eclipse.org</span></a></span><span style="color: #1d1c1d; background-color: white;"> to keep track of all Eclipse Foundation events, events we are attending, and other community events of interest, and to submit your event.</span></p>
</div>
<div style="mso-line-height-rule:exactly; margin-top:0cm; margin-right:0cm; margin-bottom:0cm; padding-left:0cm; font-size:15px; line-height:150%">
<p style="mso-line-height-rule:exactly; font-size:15px; line-height:150%">&nbsp;</p>
</div></div></div></td></tr></tbody></table>
</div>
<!--[if gte mso 9]></table><![endif]-->
<!--[if (mso)|(IE)]></td><![endif]-->


  <!--[if (mso)|(IE)]></tr></table><![endif]-->

  </div>
 
</div>

<div id="section_10" class="hse-section" style="padding-left:10px; padding-right:10px">

  
  
  <!--[if !((mso)|(IE))]><!-- -->
    <div class="hse-column-container hse-border" style="min-width:280px; max-width:600px; width:100%; Margin-left:auto; Margin-right:auto; border-collapse:collapse; border-spacing:0; border-left:1px solid #cccccc; border-right:1px solid #cccccc; box-sizing:border-box; background-color:#f79422" bgcolor="#f79422">
  <!--<![endif]-->
  
  <!--[if (mso)|(IE)]>
    <div class="hse-column-container" style="min-width:280px;max-width:600px;width:100%;Margin-left:auto;Margin-right:auto;border-collapse:collapse;border-spacing:0;">
    <table align="center" style="border-collapse:collapse;mso-table-lspace:0pt;mso-table-rspace:0pt;width:600px;border-left:1px solid #cccccc;border-right:1px solid #cccccc" cellpadding="0" cellspacing="0" role="presentation" class="hse-border" width="600" bgcolor="#f79422">
    <tr style="background-color:#f79422;">
  <![endif]-->

  <!--[if (mso)|(IE)]>
<td valign="top" style="width:598px;">
<![endif]-->
<!--[if gte mso 9]>
<table role="presentation" width="598" cellpadding="0" cellspacing="0" style="border-collapse:collapse;mso-table-lspace:0pt;mso-table-rspace:0pt;width:598px">
<![endif]-->
<div id="column_10_0" class="hse-column hse-size-12">
<table role="presentation" cellpadding="0" cellspacing="0" width="100%" style="border-spacing:0 !important; border-collapse:collapse; mso-table-lspace:0pt; mso-table-rspace:0pt"><tbody><tr><td class="hs_padded" style="border-collapse:collapse; mso-line-height-rule:exactly; font-family:Arial, sans-serif; font-size:15px; color:#444444; word-break:break-word; padding:10px 20px"><div id="hs_cos_wrapper_module_1573062770099374" class="hs_cos_wrapper hs_cos_wrapper_widget hs_cos_wrapper_type_module" style="color: inherit; font-size: inherit; line-height: inherit;" data-hs-cos-general-type="widget" data-hs-cos-type="module"><div id="hs_cos_wrapper_module_1573062770099374_" class="hs_cos_wrapper hs_cos_wrapper_widget hs_cos_wrapper_type_rich_text" style="color: inherit; font-size: inherit; line-height: inherit;" data-hs-cos-general-type="widget" data-hs-cos-type="rich_text"><p style="mso-line-height-rule:exactly; line-height:175%; text-align:center" align="center"><span style="font-size:24px;"><strong><span style="color: #ffffff;">New Members &amp; Working Group Participants</span></strong></span></p></div></div></td></tr></tbody></table>
</div>
<!--[if gte mso 9]></table><![endif]-->
<!--[if (mso)|(IE)]></td><![endif]-->


  <!--[if (mso)|(IE)]></tr></table><![endif]-->

  </div>
 
</div>

<div id="section_1608144436883" class="hse-section" style="padding-left:10px; padding-right:10px">

  
  
  <!--[if !((mso)|(IE))]><!-- -->
    <div class="hse-column-container hse-border" style="min-width:280px; max-width:600px; width:100%; Margin-left:auto; Margin-right:auto; border-collapse:collapse; border-spacing:0; border-left:1px solid #cccccc; border-right:1px solid #cccccc; box-sizing:border-box; background-color:#ffffff" bgcolor="#ffffff">
  <!--<![endif]-->
  
  <!--[if (mso)|(IE)]>
    <div class="hse-column-container" style="min-width:280px;max-width:600px;width:100%;Margin-left:auto;Margin-right:auto;border-collapse:collapse;border-spacing:0;">
    <table align="center" style="border-collapse:collapse;mso-table-lspace:0pt;mso-table-rspace:0pt;width:600px;border-left:1px solid #cccccc;border-right:1px solid #cccccc" cellpadding="0" cellspacing="0" role="presentation" class="hse-border" width="600" bgcolor="#ffffff">
    <tr style="background-color:#ffffff;">
  <![endif]-->

  <!--[if (mso)|(IE)]>
<td valign="top" style="width:598px;">
<![endif]-->
<!--[if gte mso 9]>
<table role="presentation" width="598" cellpadding="0" cellspacing="0" style="border-collapse:collapse;mso-table-lspace:0pt;mso-table-rspace:0pt;width:598px">
<![endif]-->
<div id="column_1608144436884_0" class="hse-column hse-size-12">
<table role="presentation" cellpadding="0" cellspacing="0" width="100%" style="border-spacing:0 !important; border-collapse:collapse; mso-table-lspace:0pt; mso-table-rspace:0pt"><tbody><tr><td class="hs_padded" style="border-collapse:collapse; mso-line-height-rule:exactly; font-family:Arial, sans-serif; font-size:15px; color:#444444; word-break:break-word; padding:10px 20px"><div id="hs_cos_wrapper_module_16081444414732" class="hs_cos_wrapper hs_cos_wrapper_widget hs_cos_wrapper_type_module" style="color: inherit; font-size: inherit; line-height: inherit;" data-hs-cos-general-type="widget" data-hs-cos-type="module"><div id="hs_cos_wrapper_module_16081444414732_" class="hs_cos_wrapper hs_cos_wrapper_widget hs_cos_wrapper_type_rich_text" style="color: inherit; font-size: inherit; line-height: inherit;" data-hs-cos-general-type="widget" data-hs-cos-type="rich_text"><p style="mso-line-height-rule:exactly; line-height:175%; text-align:center" align="center">For the month of March 2021</p></div></div></td></tr></tbody></table>
<table role="presentation" cellpadding="0" cellspacing="0" width="100%" style="border-spacing:0 !important; border-collapse:collapse; mso-table-lspace:0pt; mso-table-rspace:0pt"><tbody><tr><td class="hs_padded" style="border-collapse:collapse; mso-line-height-rule:exactly; font-family:Arial, sans-serif; font-size:15px; color:#444444; word-break:break-word; padding:10px 20px"><div id="hs_cos_wrapper_module_1573063318466527" class="hs_cos_wrapper hs_cos_wrapper_widget hs_cos_wrapper_type_module" style="color: inherit; font-size: inherit; line-height: inherit;" data-hs-cos-general-type="widget" data-hs-cos-type="module"><div id="hs_cos_wrapper_module_1573063318466527_" class="hs_cos_wrapper hs_cos_wrapper_widget hs_cos_wrapper_type_rich_text" style="color: inherit; font-size: inherit; line-height: inherit;" data-hs-cos-general-type="widget" data-hs-cos-type="rich_text"><div style="mso-line-height-rule:exactly; line-height:1.15; text-align:center" align="center"><span style="font-size: 18px;"><strong>Contributing Members</strong></span></div>
<div style="mso-line-height-rule:exactly; line-height:1.15; text-align:center" align="center">&nbsp;</div>
<div style="mso-line-height-rule:exactly; line-height:1.15; text-align:center" align="center">
<p style="mso-line-height-rule:exactly; line-height:125%"><span style="color: #f79422;"><a href="https://www.arcadsoftware.com/?utm_campaign=April%202020&amp;utm_source=hs_email&amp;utm_medium=email&amp;_hsenc=p2ANqtz--iPJ_XUnwkdfU0wuFX1Rc_6vGB_Rm5LnqzBU2GJe-pCqpvN5yHEVVLJkVFCFDoy6dsQ3-m" style="mso-line-height-rule:exactly; color:#f79422" rel="noopener" data-hs-link-id="0" target="_blank"><span style="text-decoration: underline;">ARCAD Software</span></a></span></p>
<p style="mso-line-height-rule:exactly; line-height:125%">&nbsp;</p>
<p style="mso-line-height-rule:exactly; line-height:125%"><span style="color: #f79422;"><a href="https://www.imaginationtech.com/?utm_campaign=April%202020&amp;utm_source=hs_email&amp;utm_medium=email&amp;_hsenc=p2ANqtz--iPJ_XUnwkdfU0wuFX1Rc_6vGB_Rm5LnqzBU2GJe-pCqpvN5yHEVVLJkVFCFDoy6dsQ3-m" style="mso-line-height-rule:exactly; color:#f79422" rel="noopener" data-hs-link-id="0" target="_blank"><span style="text-decoration: underline;">Information Technologies Limited</span></a></span></p>
<p style="mso-line-height-rule:exactly; line-height:125%">&nbsp;</p>
<p style="mso-line-height-rule:exactly; line-height:125%"><span style="color: #f79422;"><a href="https://www.opcoach.com/en/?utm_campaign=April%202020&amp;utm_source=hs_email&amp;utm_medium=email&amp;_hsenc=p2ANqtz--iPJ_XUnwkdfU0wuFX1Rc_6vGB_Rm5LnqzBU2GJe-pCqpvN5yHEVVLJkVFCFDoy6dsQ3-m" style="mso-line-height-rule:exactly; color:#f79422" rel="noopener" data-hs-link-id="0" target="_blank"><span style="text-decoration: underline;">OPCoach</span></a></span></p>
<p style="mso-line-height-rule:exactly; margin-top:0cm; margin-right:0cm; margin-bottom:0cm; padding-left:0cm; font-size:15px; line-height:125%">&nbsp;</p>
<p style="mso-line-height-rule:exactly; line-height:175%"><span style="font-size: 18px;"><strong>Working Groups</strong></span></p>
</div></div></div></td></tr></tbody></table>
</div>
<!--[if gte mso 9]></table><![endif]-->
<!--[if (mso)|(IE)]></td><![endif]-->


  <!--[if (mso)|(IE)]></tr></table><![endif]-->

  </div>
 
</div>

<div id="section_11" class="hse-section" style="padding-left:10px; padding-right:10px">

  
  
  <!--[if !((mso)|(IE))]><!-- -->
    <div class="hse-column-container hse-border" style="min-width:280px; max-width:600px; width:100%; Margin-left:auto; Margin-right:auto; border-collapse:collapse; border-spacing:0; border-left:1px solid #cccccc; border-right:1px solid #cccccc; box-sizing:border-box; background-color:#ffffff" bgcolor="#ffffff">
  <!--<![endif]-->
  
  <!--[if (mso)|(IE)]>
    <div class="hse-column-container" style="min-width:280px;max-width:600px;width:100%;Margin-left:auto;Margin-right:auto;border-collapse:collapse;border-spacing:0;">
    <table align="center" style="border-collapse:collapse;mso-table-lspace:0pt;mso-table-rspace:0pt;width:600px;border-left:1px solid #cccccc;border-right:1px solid #cccccc" cellpadding="0" cellspacing="0" role="presentation" class="hse-border" width="600" bgcolor="#ffffff">
    <tr style="background-color:#ffffff;">
  <![endif]-->

  <!--[if (mso)|(IE)]>
<td valign="top" style="width:299px;">
<![endif]-->
<!--[if gte mso 9]>
<table role="presentation" width="299" cellpadding="0" cellspacing="0" style="border-collapse:collapse;mso-table-lspace:0pt;mso-table-rspace:0pt;width:299px">
<![endif]-->
<div id="column_11_0" class="hse-column hse-size-6">
<table role="presentation" cellpadding="0" cellspacing="0" width="100%" style="border-spacing:0 !important; border-collapse:collapse; mso-table-lspace:0pt; mso-table-rspace:0pt"><tbody><tr><td class="hs_padded" style="border-collapse:collapse; mso-line-height-rule:exactly; font-family:Arial, sans-serif; font-size:15px; color:#444444; word-break:break-word; padding:10px 20px"><div id="hs_cos_wrapper_module_1573062147161181" class="hs_cos_wrapper hs_cos_wrapper_widget hs_cos_wrapper_type_module" style="color: inherit; font-size: inherit; line-height: inherit;" data-hs-cos-general-type="widget" data-hs-cos-type="module"><div id="hs_cos_wrapper_module_1573062147161181_" class="hs_cos_wrapper hs_cos_wrapper_widget hs_cos_wrapper_type_rich_text" style="color: inherit; font-size: inherit; line-height: inherit;" data-hs-cos-general-type="widget" data-hs-cos-type="rich_text"><p style="mso-line-height-rule:exactly; line-height:175%; margin-top:0cm; margin-right:0cm; margin-bottom:0cm; padding-left:0cm; text-align:center" align="center"><span style="color: #444444;"><strong>Adoptium Working Group</strong></span></p>
<p style="mso-line-height-rule:exactly; line-height:200%; text-align:center" align="center"><span style="color: #f79422;"><a href="https://www.ibm.com/ca-en?utm_campaign=April%202020&amp;utm_source=hs_email&amp;utm_medium=email&amp;_hsenc=p2ANqtz--iPJ_XUnwkdfU0wuFX1Rc_6vGB_Rm5LnqzBU2GJe-pCqpvN5yHEVVLJkVFCFDoy6dsQ3-m" style="mso-line-height-rule:exactly; color:#f79422" rel="noopener" data-hs-link-id="0" target="_blank">IBM</a></span></p>
<p style="mso-line-height-rule:exactly; line-height:200%; text-align:center" align="center"><span style="color: #f79422;"><a href="https://www.ijug.eu/en/home/?utm_campaign=April%202020&amp;utm_source=hs_email&amp;utm_medium=email&amp;_hsenc=p2ANqtz--iPJ_XUnwkdfU0wuFX1Rc_6vGB_Rm5LnqzBU2GJe-pCqpvN5yHEVVLJkVFCFDoy6dsQ3-m" style="mso-line-height-rule:exactly; color:#f79422" rel="noopener" data-hs-link-id="0" target="_blank">iJUG</a></span></p>
<p style="mso-line-height-rule:exactly; line-height:200%; text-align:center" align="center"><span style="color: #f79422;"><a href="https://newrelic.com/?utm_campaign=April%202020&amp;utm_source=hs_email&amp;utm_medium=email&amp;_hsenc=p2ANqtz--iPJ_XUnwkdfU0wuFX1Rc_6vGB_Rm5LnqzBU2GJe-pCqpvN5yHEVVLJkVFCFDoy6dsQ3-m" style="mso-line-height-rule:exactly; color:#f79422" rel="noopener" data-hs-link-id="0" target="_blank"><span style="text-decoration: underline;">New Relic</span></a></span></p>
<p style="mso-line-height-rule:exactly; margin-top:0cm; margin-right:0cm; margin-bottom:0cm; padding-left:0cm; line-height:115%">&nbsp;</p>
<p style="mso-line-height-rule:exactly; line-height:175%; margin-top:0cm; margin-right:0cm; margin-bottom:0cm; padding-left:0cm; text-align:center" align="center"><strong>Eclipse IDE Working Group</strong></p>
<p style="mso-line-height-rule:exactly; line-height:175%; margin-top:0cm; margin-right:0cm; margin-bottom:0cm; padding-left:0cm; text-align:center" align="center"><span style="color: #f79422;"><a href="https://eclipsesource.com/?utm_campaign=April%202020&amp;utm_source=hs_email&amp;utm_medium=email&amp;_hsenc=p2ANqtz--iPJ_XUnwkdfU0wuFX1Rc_6vGB_Rm5LnqzBU2GJe-pCqpvN5yHEVVLJkVFCFDoy6dsQ3-m" style="mso-line-height-rule:exactly; color:#f79422" rel="noopener" data-hs-link-id="0" target="_blank"><span style="text-decoration: underline;">EclipseSource</span></a></span></p>
<p style="mso-line-height-rule:exactly; line-height:200%; text-align:center" align="center"><span style="color: #f79422;"><a href="https://kichwacoders.com/?utm_campaign=April%202020&amp;utm_source=hs_email&amp;utm_medium=email&amp;_hsenc=p2ANqtz--iPJ_XUnwkdfU0wuFX1Rc_6vGB_Rm5LnqzBU2GJe-pCqpvN5yHEVVLJkVFCFDoy6dsQ3-m" style="mso-line-height-rule:exactly; color:#f79422" rel="noopener" data-hs-link-id="0" target="_blank"><span style="text-decoration: underline;">Kichwa Coders Canada</span></a></span></p>
<p style="mso-line-height-rule:exactly; line-height:200%; text-align:center" align="center"><span style="color: #f79422;"><a href="https://www.sap.com/index.html?utm_campaign=April%202020&amp;utm_source=hs_email&amp;utm_medium=email&amp;_hsenc=p2ANqtz--iPJ_XUnwkdfU0wuFX1Rc_6vGB_Rm5LnqzBU2GJe-pCqpvN5yHEVVLJkVFCFDoy6dsQ3-m" style="mso-line-height-rule:exactly; color:#f79422" rel="noopener" data-hs-link-id="0" target="_blank"><span style="text-decoration: underline;">SAP</span></a></span></p></div></div></td></tr></tbody></table>
</div>
<!--[if gte mso 9]></table><![endif]-->
<!--[if (mso)|(IE)]></td><![endif]-->

<!--[if (mso)|(IE)]>
<td valign="top" style="width:299px;">
<![endif]-->
<!--[if gte mso 9]>
<table role="presentation" width="299" cellpadding="0" cellspacing="0" style="border-collapse:collapse;mso-table-lspace:0pt;mso-table-rspace:0pt;width:299px">
<![endif]-->
<div id="column_11_1" class="hse-column hse-size-6">
<table role="presentation" cellpadding="0" cellspacing="0" width="100%" style="border-spacing:0 !important; border-collapse:collapse; mso-table-lspace:0pt; mso-table-rspace:0pt"><tbody><tr><td class="hs_padded" style="border-collapse:collapse; mso-line-height-rule:exactly; font-family:Arial, sans-serif; font-size:15px; color:#444444; word-break:break-word; padding:10px 20px"><div id="hs_cos_wrapper_module_16185095480621" class="hs_cos_wrapper hs_cos_wrapper_widget hs_cos_wrapper_type_module" style="color: inherit; font-size: inherit; line-height: inherit;" data-hs-cos-general-type="widget" data-hs-cos-type="module"><div id="hs_cos_wrapper_module_16185095480621_" class="hs_cos_wrapper hs_cos_wrapper_widget hs_cos_wrapper_type_rich_text" style="color: inherit; font-size: inherit; line-height: inherit;" data-hs-cos-general-type="widget" data-hs-cos-type="rich_text"><div style="mso-line-height-rule:exactly; line-height:1.15; text-align:center" align="center"><strong>Jakarta EE Working Group&nbsp;</strong></div>
<div style="mso-line-height-rule:exactly; line-height:175%; text-align:center" align="center">
<p style="mso-line-height-rule:exactly; line-height:175%; margin-top:0cm; margin-right:0cm; margin-bottom:0cm; padding-left:0cm"><span style="color: #f79422;"><a href="https://www.ijug.eu/en/home/?utm_campaign=April%202020&amp;utm_source=hs_email&amp;utm_medium=email&amp;_hsenc=p2ANqtz--iPJ_XUnwkdfU0wuFX1Rc_6vGB_Rm5LnqzBU2GJe-pCqpvN5yHEVVLJkVFCFDoy6dsQ3-m" style="mso-line-height-rule:exactly; color:#f79422" rel="noopener" data-hs-link-id="1" target="_blank">iJUG</a></span></p>
<p style="mso-line-height-rule:exactly; line-height:200%; text-align:center" align="center"><span style="color: #f79422;"><a href="https://istanbul-jug.org/?utm_campaign=April%202020&amp;utm_source=hs_email&amp;utm_medium=email&amp;_hsenc=p2ANqtz--iPJ_XUnwkdfU0wuFX1Rc_6vGB_Rm5LnqzBU2GJe-pCqpvN5yHEVVLJkVFCFDoy6dsQ3-m" style="mso-line-height-rule:exactly; color:#f79422" rel="noopener" data-hs-link-id="0" target="_blank">Istanbul JUG</a></span></p>
<p style="mso-line-height-rule:exactly; line-height:175%; margin-top:0cm; margin-right:0cm; margin-bottom:0cm; padding-left:0cm">&nbsp;</p>
<p style="mso-line-height-rule:exactly; line-height:175%; margin-top:0cm; margin-right:0cm; margin-bottom:0cm; padding-left:0cm"><span style="color: #444444;"><strong>MicroProfile Working Group&nbsp;</strong></span></p>
<p style="mso-line-height-rule:exactly; line-height:175%; margin-top:0cm; margin-right:0cm; margin-bottom:0cm; padding-left:0cm"><span style="color: #f79422;"><a href="https://www.fujitsu.com/global/?utm_campaign=April%202020&amp;utm_source=hs_email&amp;utm_medium=email&amp;_hsenc=p2ANqtz--iPJ_XUnwkdfU0wuFX1Rc_6vGB_Rm5LnqzBU2GJe-pCqpvN5yHEVVLJkVFCFDoy6dsQ3-m" style="mso-line-height-rule:exactly; color:#f79422" rel="noopener" data-hs-link-id="0" target="_blank"><span style="text-decoration: underline;">Fujitsu</span></a></span></p>
<p style="mso-line-height-rule:exactly; line-height:200%; text-align:center" align="center"><span style="color: #f79422;"><a href="https://www.ijug.eu/en/home/?utm_campaign=April%202020&amp;utm_source=hs_email&amp;utm_medium=email&amp;_hsenc=p2ANqtz--iPJ_XUnwkdfU0wuFX1Rc_6vGB_Rm5LnqzBU2GJe-pCqpvN5yHEVVLJkVFCFDoy6dsQ3-m" style="mso-line-height-rule:exactly; color:#f79422" rel="noopener" data-hs-link-id="2" target="_blank">iJUG</a></span></p>
<p style="mso-line-height-rule:exactly; line-height:175%; margin-top:0cm; margin-right:0cm; margin-bottom:0cm; padding-left:0cm">&nbsp;</p>
<p style="mso-line-height-rule:exactly; line-height:175%; margin-top:0cm; margin-right:0cm; margin-bottom:0cm; padding-left:0cm"><span style="color: #444444;"><strong>Eclipse Cloud Development Tools Working Group&nbsp;</strong></span></p>
<p style="mso-line-height-rule:exactly; line-height:175%; margin-top:0cm; margin-right:0cm; margin-bottom:0cm; padding-left:0cm"><span style="color: #f79422;"><a href="https://www.arm.com/?utm_campaign=April%202020&amp;utm_source=hs_email&amp;utm_medium=email&amp;_hsenc=p2ANqtz--iPJ_XUnwkdfU0wuFX1Rc_6vGB_Rm5LnqzBU2GJe-pCqpvN5yHEVVLJkVFCFDoy6dsQ3-m" style="mso-line-height-rule:exactly; color:#f79422" rel="noopener" data-hs-link-id="0" target="_blank"><span style="text-decoration: underline;">ARM Limited</span></a></span></p>
</div></div></div></td></tr></tbody></table>
</div>
<!--[if gte mso 9]></table><![endif]-->
<!--[if (mso)|(IE)]></td><![endif]-->


  <!--[if (mso)|(IE)]></tr></table><![endif]-->

  </div>
 
</div>

<div id="section_12" class="hse-section" style="padding-left:10px; padding-right:10px">

  
  
  <!--[if !((mso)|(IE))]><!-- -->
    <div class="hse-column-container hse-border" style="min-width:280px; max-width:600px; width:100%; Margin-left:auto; Margin-right:auto; border-collapse:collapse; border-spacing:0; border-left:1px solid #cccccc; border-right:1px solid #cccccc; box-sizing:border-box; background-color:#ffffff" bgcolor="#ffffff">
  <!--<![endif]-->
  
  <!--[if (mso)|(IE)]>
    <div class="hse-column-container" style="min-width:280px;max-width:600px;width:100%;Margin-left:auto;Margin-right:auto;border-collapse:collapse;border-spacing:0;">
    <table align="center" style="border-collapse:collapse;mso-table-lspace:0pt;mso-table-rspace:0pt;width:600px;border-left:1px solid #cccccc;border-right:1px solid #cccccc" cellpadding="0" cellspacing="0" role="presentation" class="hse-border" width="600" bgcolor="#ffffff">
    <tr style="background-color:#ffffff;">
  <![endif]-->

  <!--[if (mso)|(IE)]>
<td valign="top" style="width:598px;">
<![endif]-->
<!--[if gte mso 9]>
<table role="presentation" width="598" cellpadding="0" cellspacing="0" style="border-collapse:collapse;mso-table-lspace:0pt;mso-table-rspace:0pt;width:598px">
<![endif]-->
<div id="column_12_0" class="hse-column hse-size-12">
<table role="presentation" cellpadding="0" cellspacing="0" width="100%" style="border-spacing:0 !important; border-collapse:collapse; mso-table-lspace:0pt; mso-table-rspace:0pt"><tbody><tr><td class="hs_padded" style="border-collapse:collapse; mso-line-height-rule:exactly; font-family:Arial, sans-serif; font-size:15px; color:#444444; word-break:break-word; padding:10px 20px"><div id="hs_cos_wrapper_module_161849677878512" class="hs_cos_wrapper hs_cos_wrapper_widget hs_cos_wrapper_type_module" style="color: inherit; font-size: inherit; line-height: inherit;" data-hs-cos-general-type="widget" data-hs-cos-type="module">









<!--[if gte mso 9]>
<v:rect xmlns:v="urn:schemas-microsoft-com:vml" fill="true" stroke="false" style="width:558px; height:2pt;" fillcolor="none">
<v:fill type="tile"/>
<v:textbox inset="0,0,0,0">

<div>

<![endif]-->
<table role="presentation" width="100%" align="center" border="0" style="position:relative; top:-1px; min-width:20px; width:100%; max-width:100%; border-spacing:0; mso-table-lspace:0pt; mso-table-rspace:0pt; border-collapse:collapse; font-size:1px">
<tbody><tr>
  
  
  
  <td width="100%" valign="middle" style="border-collapse:collapse; mso-line-height-rule:exactly; font-family:Arial, sans-serif; font-size:15px; color:#444444; word-break:break-word; line-height:0; border:transparent; border-bottom:1px solid #000000; mso-border-bottom-alt:1px solid #000000; border-bottom-width:1px">&nbsp;</td>
  
  
</tr>
</tbody></table>

<!--[if gte mso 9]></div></v:textbox></v:rect><![endif]-->
</div></td></tr></tbody></table>
</div>
<!--[if gte mso 9]></table><![endif]-->
<!--[if (mso)|(IE)]></td><![endif]-->


  <!--[if (mso)|(IE)]></tr></table><![endif]-->

  </div>
 
</div>

<div id="section_13" class="hse-section" style="padding-left:10px; padding-right:10px">

  
  
  <!--[if !((mso)|(IE))]><!-- -->
    <div class="hse-column-container hse-border" style="min-width:280px; max-width:600px; width:100%; Margin-left:auto; Margin-right:auto; border-collapse:collapse; border-spacing:0; border-left:1px solid #cccccc; border-right:1px solid #cccccc; box-sizing:border-box; background-color:#ffffff" bgcolor="#ffffff">
  <!--<![endif]-->
  
  <!--[if (mso)|(IE)]>
    <div class="hse-column-container" style="min-width:280px;max-width:600px;width:100%;Margin-left:auto;Margin-right:auto;border-collapse:collapse;border-spacing:0;">
    <table align="center" style="border-collapse:collapse;mso-table-lspace:0pt;mso-table-rspace:0pt;width:600px;border-left:1px solid #cccccc;border-right:1px solid #cccccc" cellpadding="0" cellspacing="0" role="presentation" class="hse-border" width="600" bgcolor="#ffffff">
    <tr style="background-color:#ffffff;">
  <![endif]-->

  <!--[if (mso)|(IE)]>
<td valign="top" style="width:598px;">
<![endif]-->
<!--[if gte mso 9]>
<table role="presentation" width="598" cellpadding="0" cellspacing="0" style="border-collapse:collapse;mso-table-lspace:0pt;mso-table-rspace:0pt;width:598px">
<![endif]-->
<div id="column_13_0" class="hse-column hse-size-12">
<table role="presentation" cellpadding="0" cellspacing="0" width="100%" style="border-spacing:0 !important; border-collapse:collapse; mso-table-lspace:0pt; mso-table-rspace:0pt"><tbody><tr><td class="hs_padded" style="border-collapse:collapse; mso-line-height-rule:exactly; font-family:Arial, sans-serif; font-size:15px; color:#444444; word-break:break-word; padding:10px 20px"><div id="hs_cos_wrapper_module_1591621523496211" class="hs_cos_wrapper hs_cos_wrapper_widget hs_cos_wrapper_type_module" style="color: inherit; font-size: inherit; line-height: inherit;" data-hs-cos-general-type="widget" data-hs-cos-type="module">

<table role="presentation" align="center" style="border-spacing:0 !important; border-collapse:collapse; mso-table-lspace:0pt; mso-table-rspace:0pt; width:auto; text-align:center" class="hs_cos_wrapper_type_social_module" width="auto">
<tbody>
  <tr align="center">
    
    <td style="border-collapse:collapse; mso-line-height-rule:exactly; font-family:Arial, sans-serif; font-size:15px; color:#444444; word-break:break-word">
      <table role="presentation" align="center" style="border-spacing:0 !important; border-collapse:collapse; mso-table-lspace:0pt; mso-table-rspace:0pt; width:auto; text-align:center" class="hs_cos_wrapper_type_social_module_single" width="auto">
        <tbody>
          <tr align="center">
            
            <td class="display_block_on_small_screens" style="border-collapse:collapse; mso-line-height-rule:exactly; font-family:Arial, sans-serif; font-size:15px; color:#444444; word-break:break-word; padding:8px 5px; line-height:1; vertical-align:middle" valign="middle">
              <a href="http://www.facebook.com/share.php?u=&amp;utm_campaign=April%202020&amp;utm_source=hs_email&amp;utm_medium=email&amp;_hsenc=p2ANqtz--iPJ_XUnwkdfU0wuFX1Rc_6vGB_Rm5LnqzBU2GJe-pCqpvN5yHEVVLJkVFCFDoy6dsQ3-m" style="color:#00a4bd; mso-line-height-rule:exactly; text-decoration:none !important" data-hs-link-id="0" target="_blank">
                
                
                <img src="https://hs-5413615.f.hubspotemail.net/hs/hsstatic/TemplateAssets/static-1.24/img/hs_default_template_images/modules/Follow+Me+-+Email/facebook_square_color.png" alt="Facebook" height="25" style="outline:none; text-decoration:none; -ms-interpolation-mode:bicubic; border:none; width:auto!important; height:25px!important; vertical-align:middle" valign="middle">
                
              </a>
            </td>
            
            
        </tr>
      </tbody>
    </table>
    </td>
    
    <td style="border-collapse:collapse; mso-line-height-rule:exactly; font-family:Arial, sans-serif; font-size:15px; color:#444444; word-break:break-word">
      <table role="presentation" align="center" style="border-spacing:0 !important; border-collapse:collapse; mso-table-lspace:0pt; mso-table-rspace:0pt; width:auto; text-align:center" class="hs_cos_wrapper_type_social_module_single" width="auto">
        <tbody>
          <tr align="center">
            
            <td class="display_block_on_small_screens" style="border-collapse:collapse; mso-line-height-rule:exactly; font-family:Arial, sans-serif; font-size:15px; color:#444444; word-break:break-word; padding:8px 5px; line-height:1; vertical-align:middle" valign="middle">
              <a href="http://www.linkedin.com/shareArticle?mini=true&amp;url=&amp;utm_campaign=April%202020&amp;utm_source=hs_email&amp;utm_medium=email&amp;_hsenc=p2ANqtz--iPJ_XUnwkdfU0wuFX1Rc_6vGB_Rm5LnqzBU2GJe-pCqpvN5yHEVVLJkVFCFDoy6dsQ3-m" style="color:#00a4bd; mso-line-height-rule:exactly; text-decoration:none !important" data-hs-link-id="0" target="_blank">
                
                
                <img src="https://hs-5413615.f.hubspotemail.net/hs/hsstatic/TemplateAssets/static-1.24/img/hs_default_template_images/modules/Follow+Me+-+Email/linkedin_square_color.png" alt="LinkedIn" height="25" style="outline:none; text-decoration:none; -ms-interpolation-mode:bicubic; border:none; width:auto!important; height:25px!important; vertical-align:middle" valign="middle">
                
              </a>
            </td>
            
            
        </tr>
      </tbody>
    </table>
    </td>
    
    <td style="border-collapse:collapse; mso-line-height-rule:exactly; font-family:Arial, sans-serif; font-size:15px; color:#444444; word-break:break-word">
      <table role="presentation" align="center" style="border-spacing:0 !important; border-collapse:collapse; mso-table-lspace:0pt; mso-table-rspace:0pt; width:auto; text-align:center" class="hs_cos_wrapper_type_social_module_single" width="auto">
        <tbody>
          <tr align="center">
            
            <td class="display_block_on_small_screens" style="border-collapse:collapse; mso-line-height-rule:exactly; font-family:Arial, sans-serif; font-size:15px; color:#444444; word-break:break-word; padding:8px 5px; line-height:1; vertical-align:middle" valign="middle">
              <a href="https://twitter.com/intent/tweet?original_referer=&amp;url=&amp;source=tweetbutton&amp;text=&amp;utm_campaign=April%202020&amp;utm_source=hs_email&amp;utm_medium=email&amp;_hsenc=p2ANqtz--iPJ_XUnwkdfU0wuFX1Rc_6vGB_Rm5LnqzBU2GJe-pCqpvN5yHEVVLJkVFCFDoy6dsQ3-m" style="color:#00a4bd; mso-line-height-rule:exactly; text-decoration:none !important" data-hs-link-id="0" target="_blank">
                
                
                <img src="https://hs-5413615.f.hubspotemail.net/hs/hsstatic/TemplateAssets/static-1.24/img/hs_default_template_images/modules/Follow+Me+-+Email/twitter_square_color.png" alt="Twitter" height="25" style="outline:none; text-decoration:none; -ms-interpolation-mode:bicubic; border:none; width:auto!important; height:25px!important; vertical-align:middle" valign="middle">
                
              </a>
            </td>
            
            
        </tr>
      </tbody>
    </table>
    </td>
    
    <td style="border-collapse:collapse; mso-line-height-rule:exactly; font-family:Arial, sans-serif; font-size:15px; color:#444444; word-break:break-word">
      <table role="presentation" align="center" style="border-spacing:0 !important; border-collapse:collapse; mso-table-lspace:0pt; mso-table-rspace:0pt; width:auto; text-align:center" class="hs_cos_wrapper_type_social_module_single" width="auto">
        <tbody>
          <tr align="center">
            
            <td class="display_block_on_small_screens" style="border-collapse:collapse; mso-line-height-rule:exactly; font-family:Arial, sans-serif; font-size:15px; color:#444444; word-break:break-word; padding:8px 5px; line-height:1; vertical-align:middle" valign="middle">
              <a href="http://pinterest.com/pin/create/button/?url=&amp;media=&amp;utm_campaign=April%202020&amp;utm_source=hs_email&amp;utm_medium=email&amp;_hsenc=p2ANqtz--iPJ_XUnwkdfU0wuFX1Rc_6vGB_Rm5LnqzBU2GJe-pCqpvN5yHEVVLJkVFCFDoy6dsQ3-m" style="color:#00a4bd; mso-line-height-rule:exactly; text-decoration:none !important" data-hs-link-id="0" target="_blank">
                
                
                <img src="https://hs-5413615.f.hubspotemail.net/hs/hsstatic/TemplateAssets/static-1.24/img/hs_default_template_images/modules/Follow+Me+-+Email/pinterest_square_color.png" alt="Pinterest" height="25" style="outline:none; text-decoration:none; -ms-interpolation-mode:bicubic; border:none; width:auto!important; height:25px!important; vertical-align:middle" valign="middle">
                
              </a>
            </td>
            
            
        </tr>
      </tbody>
    </table>
    </td>
    
    <td style="border-collapse:collapse; mso-line-height-rule:exactly; font-family:Arial, sans-serif; font-size:15px; color:#444444; word-break:break-word">
      <table role="presentation" align="center" style="border-spacing:0 !important; border-collapse:collapse; mso-table-lspace:0pt; mso-table-rspace:0pt; width:auto; text-align:center" class="hs_cos_wrapper_type_social_module_single" width="auto">
        <tbody>
          <tr align="center">
            
            <td class="display_block_on_small_screens" style="border-collapse:collapse; mso-line-height-rule:exactly; font-family:Arial, sans-serif; font-size:15px; color:#444444; word-break:break-word; padding:8px 5px; line-height:1; vertical-align:middle" valign="middle">
              <a href="mailto:?subject=Check%20out%20%20&amp;body=Check%20out" style="color:#00a4bd; mso-line-height-rule:exactly; text-decoration:none !important" data-hs-link-id="0" target="_blank">
                
                
                <img src="https://hs-5413615.f.hubspotemail.net/hs/hsstatic/TemplateAssets/static-1.24/img/hs_default_template_images/modules/Follow+Me+-+Email/mail_square_color.png" alt="Email" height="25" style="outline:none; text-decoration:none; -ms-interpolation-mode:bicubic; border:none; width:auto!important; height:25px!important; vertical-align:middle" valign="middle">
                
              </a>
            </td>
            
            
        </tr>
      </tbody>
    </table>
    </td>
    
  </tr>
</tbody>
</table>
</div></td></tr></tbody></table>
</div>
<!--[if gte mso 9]></table><![endif]-->
<!--[if (mso)|(IE)]></td><![endif]-->


  <!--[if (mso)|(IE)]></tr></table><![endif]-->

  </div>
 
</div>

<div id="section_14" class="hse-section" style="padding-left:10px; padding-right:10px">

  
  
  <!--[if !((mso)|(IE))]><!-- -->
    <div class="hse-column-container hse-border-bottom hse-border" style="min-width:280px; max-width:600px; width:100%; Margin-left:auto; Margin-right:auto; border-collapse:collapse; border-spacing:0; border-left:1px solid #cccccc; border-right:1px solid #cccccc; box-sizing:border-box; border-bottom:1px solid #cccccc; background-color:#ffffff" bgcolor="#ffffff">
  <!--<![endif]-->
  
  <!--[if (mso)|(IE)]>
    <div class="hse-column-container" style="min-width:280px;max-width:600px;width:100%;Margin-left:auto;Margin-right:auto;border-collapse:collapse;border-spacing:0;">
    <table align="center" style="border-collapse:collapse;mso-table-lspace:0pt;mso-table-rspace:0pt;width:600px;border-bottom:1px solid #cccccc;border-left:1px solid #cccccc;border-right:1px solid #cccccc" cellpadding="0" cellspacing="0" role="presentation" class="hse-border-bottom hse-border" width="600" bgcolor="#ffffff">
    <tr style="background-color:#ffffff;">
  <![endif]-->

  <!--[if (mso)|(IE)]>
<td valign="top" style="width:598px;">
<![endif]-->
<!--[if gte mso 9]>
<table role="presentation" width="598" cellpadding="0" cellspacing="0" style="border-collapse:collapse;mso-table-lspace:0pt;mso-table-rspace:0pt;width:598px">
<![endif]-->
<div id="column_14_0" class="hse-column hse-size-12">
<table role="presentation" cellpadding="0" cellspacing="0" width="100%" style="border-spacing:0 !important; border-collapse:collapse; mso-table-lspace:0pt; mso-table-rspace:0pt"><tbody><tr><td class="hs_padded" style="border-collapse:collapse; mso-line-height-rule:exactly; font-family:Arial, sans-serif; font-size:15px; color:#444444; word-break:break-word; padding:10px 20px"><div id="hs_cos_wrapper_module_1519309286486146" class="hs_cos_wrapper hs_cos_wrapper_widget hs_cos_wrapper_type_module" style="color: inherit; font-size: inherit; line-height: inherit;" data-hs-cos-general-type="widget" data-hs-cos-type="module"><div id="hs_cos_wrapper_module_1519309286486146_" class="hs_cos_wrapper hs_cos_wrapper_widget hs_cos_wrapper_type_rich_text" style="color: inherit; font-size: inherit; line-height: inherit;" data-hs-cos-general-type="widget" data-hs-cos-type="rich_text"><h4 style="font-size:15px; margin:0; mso-line-height-rule:exactly; line-height:175%; text-align:center" align="center"><span style="color: #646c7a;">Copyright © 2021 Eclipse Foundation. All rights reserved.</span></h4></div></div></td></tr></tbody></table>
</div>
<!--[if gte mso 9]></table><![endif]-->
<!--[if (mso)|(IE)]></td><![endif]-->


  <!--[if (mso)|(IE)]></tr></table><![endif]-->

  </div>
 
</div>

<div id="section_15" class="hse-section hse-section-last" style="padding-left:10px; padding-right:10px; padding-bottom:20px">

  
  
  <!--[if !((mso)|(IE))]><!-- -->
    <div class="hse-column-container" style="min-width:280px; max-width:600px; width:100%; Margin-left:auto; Margin-right:auto; border-collapse:collapse; border-spacing:0; padding-bottom:10px; padding-top:10px">
  <!--<![endif]-->
  
  <!--[if (mso)|(IE)]>
    <div class="hse-column-container" style="min-width:280px;max-width:600px;width:100%;Margin-left:auto;Margin-right:auto;border-collapse:collapse;border-spacing:0;">
    <table align="center" style="border-collapse:collapse;mso-table-lspace:0pt;mso-table-rspace:0pt;width:600px;" cellpadding="0" cellspacing="0" role="presentation">
    <tr>
  <![endif]-->

  <!--[if (mso)|(IE)]>
<td valign="top" style="width:598px;padding-bottom:10px; padding-top:10px;">
<![endif]-->
<!--[if gte mso 9]>
<table role="presentation" width="598" cellpadding="0" cellspacing="0" style="border-collapse:collapse;mso-table-lspace:0pt;mso-table-rspace:0pt;width:598px">
<![endif]-->
<div id="column_15_0" class="hse-column hse-size-12">
<div id="hs_cos_wrapper_module_1477051461677107532" class="hs_cos_wrapper hs_cos_wrapper_widget hs_cos_wrapper_type_module" style="color: inherit; font-size: inherit; line-height: inherit;" data-hs-cos-general-type="widget" data-hs-cos-type="module">




































<table role="presentation" class="hse-footer hse-secondary" width="100%" cellpadding="0" cellspacing="0" style="border-spacing:0 !important; border-collapse:collapse; mso-table-lspace:0pt; mso-table-rspace:0pt; font-family:Arial, sans-serif; font-size:12px; line-height:135%; color:#23496d; margin-bottom:0; padding:0">
  <tbody>
      <tr>
          <td align="center" valign="top" style="border-collapse:collapse; mso-line-height-rule:exactly; font-family:Arial, sans-serif; font-size:15px; color:#444444; word-break:break-word; text-align:center; margin-bottom:0; line-height:135%; padding:10px 20px">
              <p style="mso-line-height-rule:exactly; font-family:arial, helvetica, sans-serif; font-size:12px; font-weight:normal; text-decoration:none; font-style:normal; color:#23496d; direction:lrt" dir="lrt">
                Eclipse Foundation, Suite 202, 2934 Baseline Rd, Ottawa, ON K2H 1B2, Canada
              </p>
              <p style="mso-line-height-rule:exactly">
                
                <a data-unsubscribe="true" href="#" style="mso-line-height-rule:exactly; font-family:helvetica; font-size:12px; color:#F79422; font-weight:normal; text-decoration:underline; font-style:normal" data-hs-link-id="0" target="_blank">Unsubscribe</a>
                
                <a data-unsubscribe="true" href="#" style="mso-line-height-rule:exactly; font-family:helvetica; font-size:12px; color:#F79422; font-weight:normal; text-decoration:underline; font-style:normal" data-hs-link-id="0" target="_blank">Manage preferences</a>
                
              </p>
          </td>
      </tr>
  </tbody>
</table>
</div>
</div>
<!--[if gte mso 9]></table><![endif]-->
<!--[if (mso)|(IE)]></td><![endif]-->


  <!--[if (mso)|(IE)]></tr></table><![endif]-->

  </div>
 
</div>
</div>
        </td>
      </tr>
    </tbody></table>
  </div>

</body></html>