
<!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 2023</title>
    <meta property="og:title" content="Eclipse Foundation Member Newsletter – April 2023">
    <meta name="twitter:title" content="Eclipse Foundation Member Newsletter – April 2023">
    
    
    
<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;} 
 .hse-body-wrapper-table {background-color: #f2f2f2}
</style>
<![endif]-->


    






      







    


  <meta name="generator" content="HubSpot"><meta property="og:url" content="http://eclipse-5413615.hs-sites.com/eclipse-foundation-member-newsletter-april-2023"><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-3{max-width:150px !important;width:150px !important}
.moz-text-html .hse-section .hse-size-6{max-width:300px !important;width:300px !important}
.moz-text-html .hse-section .hse-size-9{max-width:450px !important;width:450px !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-3{max-width:150px !important;width:150px !important}
[owa] .hse-section .hse-size-6{max-width:300px !important;width:300px !important}
[owa] .hse-section .hse-size-9{max-width:450px !important;width:450px !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-3{max-width:150px !important;width:150px !important}
.hse-section .hse-size-6{max-width:300px !important;width:300px !important}.hse-section .hse-size-9{max-width:450px !important;width:450px !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,.hs-stretch-cta .hs-cta-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}}@media screen and (max-width:639px){.social-network-cell{display:inline-block}
}</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;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="#ffffff"/>
  
</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_1647523498602" 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_1647523498602_0" class="hse-column hse-size-12">
  <div id="hs_cos_wrapper_module_164752349858541" 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-2023?ecid=&amp;utm_campaign=Member%20Newsletter&amp;utm_source=hs_email&amp;utm_medium=email&amp;_hsenc=p2ANqtz-9XrYBkCZA8PasxUe7lpjnqusmjXhv0gkoLGJc46vPSoOuUkMoDu1PXNjrtKt6rnDzW9hz_" 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_2" 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:#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;border-top:1px solid #cccccc" cellpadding="0" cellspacing="0" role="presentation" class="hse-border hse-border-top" 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">
  <div id="hs_cos_wrapper_module_16273954429038" 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">
                
                <img alt="Canva Design DAFi-SizPPc" src="https://hs-5413615.f.hubspotemail.net/hub/5413615/hubfs/Canva%20images/Canva%20Design%20DAFi-SizPPc.png?upscale=true&amp;width=1116&amp;upscale=true&amp;name=Canva%20Design%20DAFi-SizPPc.png" style="outline:none; text-decoration:none; -ms-interpolation-mode:bicubic; max-width:100%; font-size:16px" width="558" align="middle" srcset="https://hs-5413615.f.hubspotemail.net/hub/5413615/hubfs/Canva%20images/Canva%20Design%20DAFi-SizPPc.png?upscale=true&amp;width=1116&amp;upscale=true&amp;name=Canva%20Design%20DAFi-SizPPc.png 558w, https://hs-5413615.f.hubspotemail.net/hub/5413615/hubfs/Canva%20images/Canva%20Design%20DAFi-SizPPc.png?upscale=true&amp;width=2232&amp;upscale=true&amp;name=Canva%20Design%20DAFi-SizPPc.png 1116w" sizes="(max-width: 558px) 100vw, 558px">
                
            </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_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"><p style="mso-line-height-rule:exactly; line-height:175%">&nbsp;</p>
<ul style="mso-line-height-rule:exactly; line-height:175%">
<li style="mso-line-height-rule:exactly">Last chance to register: Automotive Open Source Summit</li>
<li style="mso-line-height-rule:exactly">OpenVSX Working Group Officially Launched</li>
<li style="mso-line-height-rule:exactly">EclipseCon 2023: Call for Proposals, Sponsorship and EMO Office Hours</li>
<li style="mso-line-height-rule:exactly">Did You Know: Login to the Member Portal</li>
<li style="mso-line-height-rule:exactly">2023 IoT &amp; Edge Developer and Adoption Survey</li>
<li style="mso-line-height-rule:exactly">Jakarta EE Developer Survey</li>
<li style="mso-line-height-rule:exactly">Featured Community: AsciiDoc</li>
<li style="mso-line-height-rule:exactly">New Members and Working Group Participants</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="module_1673968334569" 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="module_1673968334569_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_16814717782553" 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]>
<div style="line-height: 0; font-size: 0px">
  <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:2pt solid #000000; border-bottom-width:1px"><!--[if mso 16]>&nbsp;<![endif]--></td>
    
    
  </tr>
</tbody></table>


<!--[if gte mso 9]></div></v:textbox></v:rect></div><![endif]--></div></td></tr></tbody></table>
<div id="hs_cos_wrapper_module_16814719078014" 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://automotive-oss.org/2023/?utm_campaign=Member%20Newsletter&amp;utm_source=hs_email&amp;utm_medium=email&amp;_hsenc=p2ANqtz-9XrYBkCZA8PasxUe7lpjnqusmjXhv0gkoLGJc46vPSoOuUkMoDu1PXNjrtKt6rnDzW9hz_" target="_blank" style="color:#00a4bd; mso-line-height-rule:exactly" data-hs-link-id="0">
                
                <img alt="AOSS 2023 Social Card" src="https://hs-5413615.f.hubspotemail.net/hub/5413615/hubfs/AOSS%202023%20Social%20Card.jpg?upscale=true&amp;width=1116&amp;upscale=true&amp;name=AOSS%202023%20Social%20Card.jpg" 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/AOSS%202023%20Social%20Card.jpg?upscale=true&amp;width=1116&amp;upscale=true&amp;name=AOSS%202023%20Social%20Card.jpg 558w, https://hs-5413615.f.hubspotemail.net/hub/5413615/hubfs/AOSS%202023%20Social%20Card.jpg?upscale=true&amp;width=2232&amp;upscale=true&amp;name=AOSS%202023%20Social%20Card.jpg 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_16739683345243" 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_16739683345243_" 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"><h2 style="margin:0; mso-line-height-rule:exactly; font-size:22px; text-align:center; line-height:150%" align="center">Last chance to register:</h2>
<h2 style="margin:0; mso-line-height-rule:exactly; font-size:22px; text-align:center; line-height:150%" align="center">Automotive Open Source Summit</h2></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_16841436688204" 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_16841436688204_" 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%">This is your last chance to register for the first annual <span style="font-weight: bold;">Automotive Open Source Summit</span>! Don't miss out on the opportunity to network, learn, and contribute to the latest developments in automotive-grade open source software. Register now and join senior architects, innovators, and executives from around the world.</p>
<p style="mso-line-height-rule:exactly; line-height:175%">Don't miss out on the chance to be part of this exciting event! <a href="https://automotive-oss.org/2023/?utm_campaign=Member%20Newsletter&amp;utm_source=hs_email&amp;utm_medium=email&amp;_hsenc=p2ANqtz-9XrYBkCZA8PasxUe7lpjnqusmjXhv0gkoLGJc46vPSoOuUkMoDu1PXNjrtKt6rnDzW9hz_" rel="noopener" style="mso-line-height-rule:exactly; color:#f79422" data-hs-link-id="1" target="_blank">Register here</a></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_16762741173248" 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]>
<div style="line-height: 0; font-size: 0px">
  <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:2pt solid #000000; border-bottom-width:1px"><!--[if mso 16]>&nbsp;<![endif]--></td>
    
    
  </tr>
</tbody></table>


<!--[if gte mso 9]></div></v:textbox></v:rect></div><![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_16841436614163" 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_16841436614163_" 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"><h2 style="margin:0; mso-line-height-rule:exactly; font-size:22px; text-align:center; line-height:150%" align="center">OpenVSX Working Group Officially Launched</h2></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_16739683345244" 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_16739683345244_" 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 Foundation has officially launched the OpenVSX Working Group, founded by members interested in providing governance, guidance, and funding for the communities that support the implementation, deployment, maintenance and adoption of the Eclipse Foundation’s <a href="https://open-vsx.org/?utm_campaign=Member%20Newsletter&amp;utm_source=hs_email&amp;utm_medium=email&amp;_hsenc=p2ANqtz-9XrYBkCZA8PasxUe7lpjnqusmjXhv0gkoLGJc46vPSoOuUkMoDu1PXNjrtKt6rnDzW9hz_" style="mso-line-height-rule:exactly; color:#f79422" data-hs-link-id="0" target="_blank">Open VSX Registry</a>.&nbsp;</p>
<p style="mso-line-height-rule:exactly; line-height:175%">The OpenVSX Registry has been hosted by the Eclipse Foundation for more than two years as an<span style="font-weight: normal;"> open source alternative</span> to the Microsoft Visual Studio Marketplace for VS Code extensions. <span style="font-weight: normal;">The formation of this new working group is to&nbsp;ensure the continued sustainability, integrity, evolution and adoption of the Open VSX Registry.</span></p>
<p style="mso-line-height-rule:exactly; line-height:175%">Check out <a href="https://open-vsx.org/?utm_campaign=Member%20Newsletter&amp;utm_source=hs_email&amp;utm_medium=email&amp;_hsenc=p2ANqtz-9XrYBkCZA8PasxUe7lpjnqusmjXhv0gkoLGJc46vPSoOuUkMoDu1PXNjrtKt6rnDzW9hz_" style="mso-line-height-rule:exactly; color:#f79422" data-hs-link-id="1" target="_blank">open-vsx.org</a> for more information about the registry, or join the <a href="https://accounts.eclipse.org/mailing-list/openvsx?utm_campaign=Member%20Newsletter&amp;utm_source=hs_email&amp;utm_medium=email&amp;_hsenc=p2ANqtz-9XrYBkCZA8PasxUe7lpjnqusmjXhv0gkoLGJc46vPSoOuUkMoDu1PXNjrtKt6rnDzW9hz_" rel="noopener" style="mso-line-height-rule:exactly; color:#f79422" data-hs-link-id="0" target="_blank">OpenVSX mailing list</a> to find out more about how to participate in this initiative, and to show your support for this valuable developer resource.&nbsp;&nbsp;</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_16841436538052" 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]>
<div style="line-height: 0; font-size: 0px">
  <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:2pt solid #000000; border-bottom-width:1px"><!--[if mso 16]>&nbsp;<![endif]--></td>
    
    
  </tr>
</tbody></table>


<!--[if gte mso 9]></div></v:textbox></v:rect></div><![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_1684254304234" 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:#100f0f" bgcolor="#100f0f">
    <!--<![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="#100f0f">
      <tr style="background-color:#100f0f;">
    <![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_1684254304234_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_16842543084531" 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_16842543084531_" 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"><h2 style="margin:0; mso-line-height-rule:exactly; line-height:175%; font-size:22px; text-align:center" align="center"><span style="color: #ffffff;">&nbsp;EclipseCon 2023</span></h2></div></div></td></tr></tbody></table>
<div id="hs_cos_wrapper_module_16762722393274" 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:5px 20px 15px; font-size:0px">
                
                    <a href="https://www.eclipsecon.org/2023?utm_campaign=Member%20Newsletter&amp;utm_source=hs_email&amp;utm_medium=email&amp;_hsenc=p2ANqtz-9XrYBkCZA8PasxUe7lpjnqusmjXhv0gkoLGJc46vPSoOuUkMoDu1PXNjrtKt6rnDzW9hz_" target="_blank" style="color:#00a4bd; mso-line-height-rule:exactly" data-hs-link-id="0">
                
                <img alt="CALL FOR PROPOSALS" src="https://hs-5413615.f.hubspotemail.net/hub/5413615/hubfs/CALL%20FOR%20PROPOSALS.gif?upscale=true&amp;width=1116&amp;upscale=true&amp;name=CALL%20FOR%20PROPOSALS.gif" 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/CALL%20FOR%20PROPOSALS.gif?upscale=true&amp;width=1116&amp;upscale=true&amp;name=CALL%20FOR%20PROPOSALS.gif 558w, https://hs-5413615.f.hubspotemail.net/hub/5413615/hubfs/CALL%20FOR%20PROPOSALS.gif?upscale=true&amp;width=2232&amp;upscale=true&amp;name=CALL%20FOR%20PROPOSALS.gif 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_16762741173246" 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_16762741173246_" 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"><h2 style="margin:0; mso-line-height-rule:exactly; line-height:175%; font-size:22px; text-align:center" align="center"><span style="color: #ffffff;">&nbsp;Call for Proposals Closes June 16</span></h2></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_16762741173247" 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_16762741173247_" 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%"><span style="color: #ffffff;">Be sure to <span style="color: #f88d2b;"><a href="https://cfnx704.na1.hubspotlinks.com/Ctc/T+113/cFnx704/MWt1KcCJp7NW57xly38kYnGJW1CR2894ZC7JZN5t-nkr3q905V1-WJV7CgJ1dW16bytL6JM5XVMW1L1524kXLW5FsZm33pTS3kW1SKNyt7MYyCyVDzLhV3C5JhKW92g2Pd81W4gMW4vGZX64Q_BNLW7MLH1s5s25LlW6SF8W42PjN21W54yR1y6PZQwTW68Kwdm1s-GQnW7bXgCk92D6ygW6Kh7xd454QGmW3xKX2d2jTpN0W8YD2FC2-yqrXW4hsF622kTvMYW9g-vdN41RY80W3v-QT-4qvhrXW3RHwc65JKLS9VYJfss7ksL2cW2N_FCK5cY5-tW4Hkp4L3cQfSwW8bBp3N9kjSlRW43tqVD62rbyX3dVv1?utm_campaign=Member%20Newsletter&amp;utm_source=hs_email&amp;utm_medium=email&amp;_hsenc=p2ANqtz-9XrYBkCZA8PasxUe7lpjnqusmjXhv0gkoLGJc46vPSoOuUkMoDu1PXNjrtKt6rnDzW9hz_" style="mso-line-height-rule:exactly; color:#f88d2b" data-hs-link-id="0" target="_blank">submit your proposal</a></span> for <span style="color: #f88d2b;"><a href="https://cfnx704.na1.hubspotlinks.com/Ctc/T+113/cFnx704/MWt1KcCJp7NW57xly38kYnGJW1CR2894ZC7JZN5t-nkr3q905V1-WJV7CgB-zW5R8pJT8GR8-KN2G7ccKg9R2fW1PNjCD4pmGQZW6wwP8Y96rD7dVrn5dH4QDf5yW8DC9QN3v4MLCW4C_KmJ6n0CpHV72wy-4XH7FcW6y2jXl7qhJhhW3dVznV6fmgVfW4d3x4-3WcTbNW8cKr3J7YpCXqW7jznWb3nnGJqW3QF6Sq24mYLnW67W4zy7pSqfTN3b__flq5kh6W2T-zFK3yw6BtW6qq7JZ1vjvDrW1Zp45z5kRlGsV4GcQn9lcjqdVQVz636K_QR9W2vk24986qqjxW4Tz5ZN2f4_J-N13wqtyX6C9K3cSz1?utm_campaign=Member%20Newsletter&amp;utm_source=hs_email&amp;utm_medium=email&amp;_hsenc=p2ANqtz-9XrYBkCZA8PasxUe7lpjnqusmjXhv0gkoLGJc46vPSoOuUkMoDu1PXNjrtKt6rnDzW9hz_" style="mso-line-height-rule:exactly; color:#f88d2b" data-hs-link-id="0" target="_blank">EclipseCon 2023</a></span> soon! <span style="font-weight: bold;">Submit by June 2</span>, and you could have your talk accepted early and promoted to the community. The <span style="font-weight: bold;">final deadline</span> for all proposals is <span style="font-weight: bold;">June 16</span>.&nbsp;We have new tracks and new exciting changes this year; <span style="color: #f88d2b;"><a href="https://www.eclipsecon.org/2023/talk-proposal-topics?utm_campaign=Member%20Newsletter&amp;utm_source=hs_email&amp;utm_medium=email&amp;_hsenc=p2ANqtz-9XrYBkCZA8PasxUe7lpjnqusmjXhv0gkoLGJc46vPSoOuUkMoDu1PXNjrtKt6rnDzW9hz_" style="mso-line-height-rule:exactly; color:#f88d2b" data-hs-link-id="0" target="_blank">see the website</a></span> for more information. See you<span style="font-weight: bold;"> October 16-19</span>, <span style="font-weight: bold;">2023</span>, in <span style="font-weight: bold;">Ludwigsburg, Germany</span>.</span></p></div></div></td></tr></tbody></table>
<div id="hs_cos_wrapper_module_16841429746561" 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:5px 20px 15px; font-size:0px">
                
                    <a href="https://www.eclipsecon.org/2023/prospectus?utm_campaign=Member%20Newsletter&amp;utm_source=hs_email&amp;utm_medium=email&amp;_hsenc=p2ANqtz-9XrYBkCZA8PasxUe7lpjnqusmjXhv0gkoLGJc46vPSoOuUkMoDu1PXNjrtKt6rnDzW9hz_" target="_blank" style="color:#00a4bd; mso-line-height-rule:exactly" data-hs-link-id="0">
                
                <img alt="JOIN OTHER INDUSTRY LEADERS IN SPONSORING" src="https://hs-5413615.f.hubspotemail.net/hub/5413615/hubfs/JOIN%20OTHER%20INDUSTRY%20LEADERS%20IN%20SPONSORING.png?upscale=true&amp;width=1116&amp;upscale=true&amp;name=JOIN%20OTHER%20INDUSTRY%20LEADERS%20IN%20SPONSORING.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/JOIN%20OTHER%20INDUSTRY%20LEADERS%20IN%20SPONSORING.png?upscale=true&amp;width=1116&amp;upscale=true&amp;name=JOIN%20OTHER%20INDUSTRY%20LEADERS%20IN%20SPONSORING.png 558w, https://hs-5413615.f.hubspotemail.net/hub/5413615/hubfs/JOIN%20OTHER%20INDUSTRY%20LEADERS%20IN%20SPONSORING.png?upscale=true&amp;width=2232&amp;upscale=true&amp;name=JOIN%20OTHER%20INDUSTRY%20LEADERS%20IN%20SPONSORING.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_16814717629511" 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_16814717629511_" 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"><h2 style="margin:0; mso-line-height-rule:exactly; font-size:22px; text-align:center; line-height:150%" align="center"><span style="color: #ffffff;">Become an EclipseCon Sponsor</span></h2></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_16814717679432" 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_16814717679432_" 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; font-size:15px; line-height:175%"><span style="color: #ffffff;">Join us as a <span style="font-weight: bold;">sponsor</span> or<span style="font-weight: bold;"> exhibitor </span>and play a significant role in EclipseCon 2023. Your organization's participation demonstrates leadership within the Eclipse community, increases your brand recognition and awareness, and can help drive interest in the Eclipse projects that are important to your business. </span><span style="font-size: 15px;"><a href="https://www.eclipsecon.org/2023/prospectus?utm_campaign=Member%20Newsletter&amp;utm_source=hs_email&amp;utm_medium=email&amp;_hsenc=p2ANqtz-9XrYBkCZA8PasxUe7lpjnqusmjXhv0gkoLGJc46vPSoOuUkMoDu1PXNjrtKt6rnDzW9hz_" style="mso-line-height-rule:exactly; color:#f79422" data-hs-link-id="1" target="_blank">Learn more</a><span style="color: #000000;">.</span></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:10px 20px"><div id="hs_cos_wrapper_module_16814728491269" 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_16814728491269_" 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"><h2 style="margin:0; mso-line-height-rule:exactly; line-height:175%; font-size:22px; text-align:center" align="center"><span style="color: #ffffff;">EMO Office Hours at EclipseCon</span></h2></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_16663732123759" 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_16663732123759_" 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%"><span style="color: #ffffff;">Recently the Eclipse Foundation introduced virtual <span style="color: #ff9902;"><a href="https://newsroom.eclipse.org/eclipse-newsletter/2023/february/ask-emo-your-questions%C2%A0during-office-hours?utm_campaign=Member%20Newsletter&amp;utm_source=hs_email&amp;utm_medium=email&amp;_hsenc=p2ANqtz-9XrYBkCZA8PasxUe7lpjnqusmjXhv0gkoLGJc46vPSoOuUkMoDu1PXNjrtKt6rnDzW9hz_" style="mso-line-height-rule:exactly; color:#ff9902" data-hs-link-id="0" target="_blank">Office Hours</a></span>, where community members can ask questions about the Eclipse Foundation Development Process, IP policy, and due diligence process, and similar topics.</span></p>
<p style="mso-line-height-rule:exactly; line-height:175%"><span style="color: #ffffff;">We are bringing “live” Office Hours to EclipseCon this year. So on top of the other benefits of <span style="font-weight: bold;">learning</span> and <span style="font-weight: bold;">networking</span> at EclipseCon, attendees can now interact with the key EMO (Eclipse Management Organization) players, including marketing, project, IT, release engineering, and security teams to <span style="font-weight: bold;">ask questions</span> and share ideas.</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_16819142998653" 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]>
<div style="line-height: 0; font-size: 0px">
  <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 #FFFFFF; mso-border-bottom-alt:2pt solid #FFFFFF; border-bottom-width:1px"><!--[if mso 16]>&nbsp;<![endif]--></td>
    
    
  </tr>
</tbody></table>


<!--[if gte mso 9]></div></v:textbox></v:rect></div><![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="module_1666373212442" 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="module_1666373212442_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_16819142809531" 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_16819142809531_" 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"><h2 style="margin:0; mso-line-height-rule:exactly; font-size:22px; text-align:center; line-height:150%" align="center">Did You Know: Login to the Member Portal</h2></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_16819142890342" 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_16819142890342_" 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 Foundation revamped its <a href="https://membership.eclipse.org/portal/login?utm_campaign=Member%20Newsletter&amp;utm_source=hs_email&amp;utm_medium=email&amp;_hsenc=p2ANqtz-9XrYBkCZA8PasxUe7lpjnqusmjXhv0gkoLGJc46vPSoOuUkMoDu1PXNjrtKt6rnDzW9hz_" rel="noopener" style="mso-line-height-rule:exactly; color:#f79422" data-hs-link-id="0" target="_blank">Member Portal</a> late in 2022 to better assist our members. Key member contacts, namely, Member Representatives, Alternate Member Representatives, Marketing Representatives, and Delegates, can now login to the <a href="https://membership.eclipse.org/portal/login?utm_campaign=Member%20Newsletter&amp;utm_source=hs_email&amp;utm_medium=email&amp;_hsenc=p2ANqtz-9XrYBkCZA8PasxUe7lpjnqusmjXhv0gkoLGJc46vPSoOuUkMoDu1PXNjrtKt6rnDzW9hz_" style="mso-line-height-rule:exactly; color:#f79422" data-hs-link-id="1" target="_blank">member portal</a> using their Eclipse accounts.&nbsp;</p>
<p style="mso-line-height-rule:exactly; line-height:175%">The Member portal provides an overview of the information captured by the Foundation regarding your organization, including information on your committers, projects, and working groups that your organization is a part of, allotted resource packs, and your company's contact information. Additionally, representatives can now use the member portal to update company information, such as logos, links, and descriptions, and assign roles to other company contacts. &nbsp;</p>
<p style="mso-line-height-rule:exactly; line-height:175%">For more information or assistance, please contact <a href="mailto:membership.coordination@eclipse-foundation.org" style="mso-line-height-rule:exactly; color:#f79422" data-hs-link-id="0" target="_blank">membership.coordination@eclipse-foundation.org</a></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_16762735586475" 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 align="center" border="0" cellpadding="0" cellspacing="0" role="presentation" style="border-spacing:0 !important; mso-table-lspace:0pt; mso-table-rspace:0pt; border-collapse:separate!important">
    <tbody><tr>
        <!--[if mso]>
      <td align="center" valign="middle" bgcolor="#F88D2B" role="presentation"  valign="middle" style="border-radius:6px;cursor:auto;background-color:#F88D2B;padding:12px 18px;">
    <![endif]-->
    <!--[if !mso]><!-- -->
      <td align="center" valign="middle" bgcolor="#F88D2B" role="presentation" style="border-collapse:collapse; mso-line-height-rule:exactly; font-family:Arial, sans-serif; font-size:15px; color:#444444; word-break:break-word; border-radius:6px; cursor:auto; background-color:#F88D2B">
   <!--<![endif]-->
        <a href="https://membership.eclipse.org/portal/login?utm_campaign=Member%20Newsletter&amp;utm_source=hs_email&amp;utm_medium=email&amp;_hsenc=p2ANqtz-9XrYBkCZA8PasxUe7lpjnqusmjXhv0gkoLGJc46vPSoOuUkMoDu1PXNjrtKt6rnDzW9hz_" target="_blank" style="color:#00a4bd; mso-line-height-rule:exactly; font-size:16px; font-family:arial, helvetica, sans-serif; Margin:0; text-transform:none; text-decoration:none; padding:12px 18px; display:block" data-hs-link-id="2">
          <strong style="color:#ffffff;font-weight:normal;text-decoration:none;font-style:normal;">Login to the member portal</strong>
        </a>
      </td>
    </tr>
  </tbody></table>
</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_16764684311661" 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]>
<div style="line-height: 0; font-size: 0px">
  <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:2pt solid #000000; border-bottom-width:1px"><!--[if mso 16]>&nbsp;<![endif]--></td>
    
    
  </tr>
</tbody></table>


<!--[if gte mso 9]></div></v:textbox></v:rect></div><![endif]--></div></td></tr></tbody></table>
<div id="hs_cos_wrapper_module_16819079391971" 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:5px 20px 15px; font-size:0px">
                
                    <a href="https://www.surveymonkey.com/r/BXPP3KL?utm_campaign=Member%20Newsletter&amp;utm_source=hs_email&amp;utm_medium=email&amp;_hsenc=p2ANqtz-9XrYBkCZA8PasxUe7lpjnqusmjXhv0gkoLGJc46vPSoOuUkMoDu1PXNjrtKt6rnDzW9hz_" target="_blank" style="color:#00a4bd; mso-line-height-rule:exactly" data-hs-link-id="0">
                
                <img alt="IoT &amp; Edge Developer and Adoption Survey 2023" src="https://hs-5413615.f.hubspotemail.net/hub/5413615/hubfs/IoT%20%26%20Edge%20Developer%20and%20Adoption%20Survey%202023.png?upscale=true&amp;width=1090&amp;upscale=true&amp;name=IoT%20%26%20Edge%20Developer%20and%20Adoption%20Survey%202023.png" style="outline:none; text-decoration:none; -ms-interpolation-mode:bicubic; border:none; max-width:100%; font-size:16px" width="545" align="middle" srcset="https://hs-5413615.f.hubspotemail.net/hub/5413615/hubfs/IoT%20%26%20Edge%20Developer%20and%20Adoption%20Survey%202023.png?upscale=true&amp;width=1090&amp;upscale=true&amp;name=IoT%20%26%20Edge%20Developer%20and%20Adoption%20Survey%202023.png 545w, https://hs-5413615.f.hubspotemail.net/hub/5413615/hubfs/IoT%20%26%20Edge%20Developer%20and%20Adoption%20Survey%202023.png?upscale=true&amp;width=2180&amp;upscale=true&amp;name=IoT%20%26%20Edge%20Developer%20and%20Adoption%20Survey%202023.png 1090w" sizes="(max-width: 545px) 100vw, 545px">
                
                    </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_16687005398431" 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_16687005398431_" 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"><h2 style="margin:0; mso-line-height-rule:exactly; line-height:175%; font-size:22px; text-align:center" align="center">2023 IoT &amp; Edge Developer and Adoption Survey</h2></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_16245465754308" 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_16245465754308_" 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 <a href="https://www.surveymonkey.com/r/BXPP3KL?utm_campaign=Member%20Newsletter&amp;utm_source=hs_email&amp;utm_medium=email&amp;_hsenc=p2ANqtz-9XrYBkCZA8PasxUe7lpjnqusmjXhv0gkoLGJc46vPSoOuUkMoDu1PXNjrtKt6rnDzW9hz_" style="mso-line-height-rule:exactly; color:#f79422" data-hs-link-id="1" target="_blank">2023 IoT &amp; Edge Developer and Adoption Survey</a> is now open.</p>
<p style="mso-line-height-rule:exactly; line-height:175%">Your valuable input will help stakeholders in IoT and Edge computing better understand the needs and challenges of developers, thereby influencing how organizations address them. The <a href="https://www.surveymonkey.com/r/BXPP3KL?utm_campaign=Member%20Newsletter&amp;utm_source=hs_email&amp;utm_medium=email&amp;_hsenc=p2ANqtz-9XrYBkCZA8PasxUe7lpjnqusmjXhv0gkoLGJc46vPSoOuUkMoDu1PXNjrtKt6rnDzW9hz_" style="mso-line-height-rule:exactly; color:#f79422" data-hs-link-id="2" target="_blank">survey</a>&nbsp;closes on June 28, 2023, and takes about 15 minutes to complete.&nbsp;</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_16739502079197" 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]>
<div style="line-height: 0; font-size: 0px">
  <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:2pt solid #000000; border-bottom-width:1px"><!--[if mso 16]>&nbsp;<![endif]--></td>
    
    
  </tr>
</tbody></table>


<!--[if gte mso 9]></div></v:textbox></v:rect></div><![endif]--></div></td></tr></tbody></table>
<div id="hs_cos_wrapper_module_16788924744413" 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:5px 20px 15px; font-size:0px">
                
                    <a href="https://www.surveymonkey.com/r/6363YQ6?utm_campaign=Member%20Newsletter&amp;utm_source=hs_email&amp;utm_medium=email&amp;_hsenc=p2ANqtz-9XrYBkCZA8PasxUe7lpjnqusmjXhv0gkoLGJc46vPSoOuUkMoDu1PXNjrtKt6rnDzW9hz_" target="_blank" style="color:#00a4bd; mso-line-height-rule:exactly" data-hs-link-id="0">
                
                <img alt="Jakarta EE Survey" src="https://hs-5413615.f.hubspotemail.net/hub/5413615/hubfs/Copy%20of%20Member%20Newsletter_articleimages.png?upscale=true&amp;width=1116&amp;upscale=true&amp;name=Copy%20of%20Member%20Newsletter_articleimages.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/Copy%20of%20Member%20Newsletter_articleimages.png?upscale=true&amp;width=1116&amp;upscale=true&amp;name=Copy%20of%20Member%20Newsletter_articleimages.png 558w, https://hs-5413615.f.hubspotemail.net/hub/5413615/hubfs/Copy%20of%20Member%20Newsletter_articleimages.png?upscale=true&amp;width=2232&amp;upscale=true&amp;name=Copy%20of%20Member%20Newsletter_articleimages.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_16663732123758" 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_16663732123758_" 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"><h2 style="margin:0; mso-line-height-rule:exactly; line-height:175%; font-size:22px; text-align:center" align="center">Take the Jakarta EE survey</h2></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_168147285442210" 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_168147285442210_" 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%"><span style="font-weight: normal;">The 2023 Jakarta EE Developer Survey is closing very soon, so please make sure we have heard from your organization.</span> <a href="https://www.surveymonkey.com/r/6363YQ6?utm_campaign=Member%20Newsletter&amp;utm_source=hs_email&amp;utm_medium=email&amp;_hsenc=p2ANqtz-9XrYBkCZA8PasxUe7lpjnqusmjXhv0gkoLGJc46vPSoOuUkMoDu1PXNjrtKt6rnDzW9hz_" style="mso-line-height-rule:exactly; color:#f79422" data-hs-link-id="1" target="_blank">Take the survey</a></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_1645020379900" 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_1645020379900_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_16473587215094" 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]>
<div style="line-height: 0; font-size: 0px">
  <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:2pt solid #000000; border-bottom-width:1px"><!--[if mso 16]>&nbsp;<![endif]--></td>
    
    
  </tr>
</tbody></table>


<!--[if gte mso 9]></div></v:textbox></v:rect></div><![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="module_1673949977244" 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="module_1673949977244_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_16473590477546" 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_16473590477546_" 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"><h2 style="margin:0; mso-line-height-rule:exactly; line-height:175%; font-size:22px; text-align:center" align="center">Featured Community:</h2></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_16473590477547" 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_16473590477547_" 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; font-weight:bold; text-align:center; font-size:15px; line-height:175%" align="center">&nbsp;<span style="color: #434343;">Publish presentation-rich content from a concise and comprehensive authoring format.&nbsp;</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_1679067798590" 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:149px;">
<![endif]-->
<!--[if gte mso 9]>
  <table role="presentation" width="149" cellpadding="0" cellspacing="0" style="border-collapse:collapse;mso-table-lspace:0pt;mso-table-rspace:0pt;width:149px">
<![endif]-->
<div id="column_1681908236222_0" class="hse-column hse-size-3">
  <div id="hs_cos_wrapper_module_167040758352012" 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:0px; font-size:0px">
                
                <img alt="asciidoc-og" src="https://hs-5413615.f.hubspotemail.net/hub/5413615/hubfs/asciidoc-og.png?upscale=true&amp;width=298&amp;upscale=true&amp;name=asciidoc-og.png" style="outline:none; text-decoration:none; -ms-interpolation-mode:bicubic; max-width:100%; font-size:16px" width="149" align="middle" srcset="https://hs-5413615.f.hubspotemail.net/hub/5413615/hubfs/asciidoc-og.png?upscale=true&amp;width=298&amp;upscale=true&amp;name=asciidoc-og.png 149w, https://hs-5413615.f.hubspotemail.net/hub/5413615/hubfs/asciidoc-og.png?upscale=true&amp;width=596&amp;upscale=true&amp;name=asciidoc-og.png 298w" sizes="(max-width: 149px) 100vw, 149px">
                
            </td>
        </tr>
    </tbody>
</table></div>
</div>
<!--[if gte mso 9]></table><![endif]-->
<!--[if (mso)|(IE)]></td><![endif]-->

<!--[if (mso)|(IE)]>
  <td valign="top" style="width:448px;">
<![endif]-->
<!--[if gte mso 9]>
  <table role="presentation" width="448" cellpadding="0" cellspacing="0" style="border-collapse:collapse;mso-table-lspace:0pt;mso-table-rspace:0pt;width:448px">
<![endif]-->
<div id="column_1679067798590_0" class="hse-column hse-size-9">
  <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_16819082731042" 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_16819082731042_" 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 AsciiDoc Working Group drives the standardization, adoption, and evolution of AsciiDoc. The primary objective of this group is to develop specifications for the AsciiDoc language and APIs for processing it. This group encourages and shapes the open, collaborative development of the AsciiDoc language and its implementations.</p>
<p style="mso-line-height-rule:exactly; line-height:175%"><a href="https://asciidoc-wg.eclipse.org/?utm_campaign=Member%20Newsletter&amp;utm_source=hs_email&amp;utm_medium=email&amp;_hsenc=p2ANqtz-9XrYBkCZA8PasxUe7lpjnqusmjXhv0gkoLGJc46vPSoOuUkMoDu1PXNjrtKt6rnDzW9hz_" rel="noopener" style="mso-line-height-rule:exactly; color:#f79422" data-hs-link-id="0" target="_blank">&nbsp;Learn more</a></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_1679067812964" 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_1679067812965_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_16790677576451" 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_16790677576451_" 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%"><strong>Get Featured</strong></p>
<p style="mso-line-height-rule:exactly; line-height:175%">Each issue of the member newsletter will feature different working groups. Leaders of working groups wishing to be featured during a particular month should contact <a href="mailto:marketing@eclipse.org" style="mso-line-height-rule:exactly; color:#f79422" data-hs-link-id="0" target="_blank">marketing@eclipse.org</a>.</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 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%">
<p style="mso-line-height-rule:exactly; line-height:175%"><a href="https://conf.researchr.org/home/ict4s-2023?utm_campaign=Member%20Newsletter&amp;utm_source=hs_email&amp;utm_medium=email&amp;_hsenc=p2ANqtz-9XrYBkCZA8PasxUe7lpjnqusmjXhv0gkoLGJc46vPSoOuUkMoDu1PXNjrtKt6rnDzW9hz_" rel="noopener" style="mso-line-height-rule:exactly; color:#f79422" data-hs-link-id="0" target="_blank">ICT4S 2023</a> | June 5-10, 2023</p>
<p style="mso-line-height-rule:exactly; line-height:175%"><span style="color: #000000;"><a href="https://riscv-europe.org/?utm_campaign=Member%20Newsletter&amp;utm_source=hs_email&amp;utm_medium=email&amp;_hsenc=p2ANqtz-9XrYBkCZA8PasxUe7lpjnqusmjXhv0gkoLGJc46vPSoOuUkMoDu1PXNjrtKt6rnDzW9hz_" rel="noopener" style="mso-line-height-rule:exactly; color:#f79422" data-hs-link-id="0" target="_blank">RISC-V Europe Sum<span style="text-decoration: none;"><span style="color: #f88d2b;">mi</span></span></a><span style="text-decoration: none;"><span style="color: #f88d2b;">t</span></span> | June 5-10, 2023</span></p>
<p style="mso-line-height-rule:exactly; line-height:175%"><span style="color: #000000;"><a href="https://automotive-oss.org/2023/?utm_campaign=Member%20Newsletter&amp;utm_source=hs_email&amp;utm_medium=email&amp;_hsenc=p2ANqtz-9XrYBkCZA8PasxUe7lpjnqusmjXhv0gkoLGJc46vPSoOuUkMoDu1PXNjrtKt6rnDzW9hz_" rel="noopener" style="mso-line-height-rule:exactly; color:#f79422" data-hs-link-id="2" target="_blank">Automotive Open Source Summit</a> | June 6, 2023</span></p>
<p style="mso-line-height-rule:exactly; line-height:175%"><span style="color: #000000;"><a href="https://sdv.eclipse.org/sdv-community-day-july-2023/?utm_campaign=Member%20Newsletter&amp;utm_source=hs_email&amp;utm_medium=email&amp;_hsenc=p2ANqtz-9XrYBkCZA8PasxUe7lpjnqusmjXhv0gkoLGJc46vPSoOuUkMoDu1PXNjrtKt6rnDzW9hz_" rel="noopener" style="mso-line-height-rule:exactly; color:#f79422" data-hs-link-id="0" target="_blank">SDV Community Day</a> | July 6, 2023</span></p>
<p style="mso-line-height-rule:exactly; line-height:175%"><span style="color: #000000;"><a href="https://www.eclipsecon.org/2023?utm_campaign=Member%20Newsletter&amp;utm_source=hs_email&amp;utm_medium=email&amp;_hsenc=p2ANqtz-9XrYBkCZA8PasxUe7lpjnqusmjXhv0gkoLGJc46vPSoOuUkMoDu1PXNjrtKt6rnDzW9hz_" rel="noopener" style="mso-line-height-rule:exactly; color:#f79422" data-hs-link-id="1" target="_blank">EclipseCon</a> | October 16-19, 2023</span></p>
<p style="mso-line-height-rule:exactly; line-height:175%"><span style="color: #000000;"><a href="https://events.eclipse.org/2023/esaam2023/?utm_campaign=Member%20Newsletter&amp;utm_source=hs_email&amp;utm_medium=email&amp;_hsenc=p2ANqtz-9XrYBkCZA8PasxUe7lpjnqusmjXhv0gkoLGJc46vPSoOuUkMoDu1PXNjrtKt6rnDzW9hz_" rel="noopener" style="mso-line-height-rule:exactly; color:#f79422" data-hs-link-id="0" target="_blank">ESAAM 2023</a> | October 17, 2023</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_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 and 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="module_1662745371169" 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="module_1662745371169_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 0px"><div id="hs_cos_wrapper_module_16627453711395" 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_16627453711395_" 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 April 2023</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_1670408034911" 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_1670408034911_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_167040805346514" 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_167040805346514_" 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"><h2 style="margin:0; mso-line-height-rule:exactly; line-height:175%; font-size:22px">Contributing Members</h2>
<p style="mso-line-height-rule:exactly; line-height:175%"><a href="https://www.jasmineconseil.com/?utm_campaign=Member%20Newsletter&amp;utm_source=hs_email&amp;utm_medium=email&amp;_hsenc=p2ANqtz-9XrYBkCZA8PasxUe7lpjnqusmjXhv0gkoLGJc46vPSoOuUkMoDu1PXNjrtKt6rnDzW9hz_" rel="noopener" style="mso-line-height-rule:exactly; color:#f79422" data-hs-link-id="0" target="_blank">Jasmine Conseil SARL</a></p>
<p style="mso-line-height-rule:exactly; line-height:175%"><a href="https://swmansion.com/?utm_campaign=Member%20Newsletter&amp;utm_source=hs_email&amp;utm_medium=email&amp;_hsenc=p2ANqtz-9XrYBkCZA8PasxUe7lpjnqusmjXhv0gkoLGJc46vPSoOuUkMoDu1PXNjrtKt6rnDzW9hz_" rel="noopener" style="mso-line-height-rule:exactly; color:#f79422" data-hs-link-id="0" target="_blank">Software Mansion SA</a></p>
<p style="mso-line-height-rule:exactly; line-height:175%"><a href="https://www.synthara.ai/?utm_campaign=Member%20Newsletter&amp;utm_source=hs_email&amp;utm_medium=email&amp;_hsenc=p2ANqtz-9XrYBkCZA8PasxUe7lpjnqusmjXhv0gkoLGJc46vPSoOuUkMoDu1PXNjrtKt6rnDzW9hz_" rel="noopener" style="mso-line-height-rule:exactly; color:#f79422" data-hs-link-id="0" target="_blank">Synthara AG</a></p>
<p style="mso-line-height-rule:exactly; line-height:175%">&nbsp;</p>
<h2 style="margin:0; mso-line-height-rule:exactly; line-height:175%; font-size:22px">Associate Members</h2>
<p style="mso-line-height-rule:exactly; line-height:175%"><a href="https://openforumeurope.org/?utm_campaign=Member%20Newsletter&amp;utm_source=hs_email&amp;utm_medium=email&amp;_hsenc=p2ANqtz-9XrYBkCZA8PasxUe7lpjnqusmjXhv0gkoLGJc46vPSoOuUkMoDu1PXNjrtKt6rnDzW9hz_" rel="noopener" style="mso-line-height-rule:exactly; color:#f79422" data-hs-link-id="0" target="_blank">Open Forum Europe AISBL</a></p>
<p style="mso-line-height-rule:exactly; line-height:175%">&nbsp;</p>
<p style="mso-line-height-rule:exactly; line-height:175%">&nbsp;</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_1670408034911_2" 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_167040847416916" 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_167040847416916_" 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"><h2 style="margin:0; mso-line-height-rule:exactly; line-height:175%; font-size:22px">Working Groups</h2>
<p style="mso-line-height-rule:exactly; line-height:175%"><strong><span style="color: #000000;">IoT Working Group</span></strong></p>
<p style="mso-line-height-rule:exactly; line-height:175%"><a href="https://www.jasmineconseil.com/?utm_campaign=Member%20Newsletter&amp;utm_source=hs_email&amp;utm_medium=email&amp;_hsenc=p2ANqtz-9XrYBkCZA8PasxUe7lpjnqusmjXhv0gkoLGJc46vPSoOuUkMoDu1PXNjrtKt6rnDzW9hz_" rel="noopener" style="mso-line-height-rule:exactly; color:#f79422" data-hs-link-id="1" target="_blank">Jasmine Conseil SARL</a></p>
<p style="mso-line-height-rule:exactly; line-height:175%">&nbsp;</p>
<p style="mso-line-height-rule:exactly; line-height:175%"><strong><span style="color: #000000;">Oniro Working Group</span></strong></p>
<p style="mso-line-height-rule:exactly; line-height:175%"><a href="https://swmansion.com/?utm_campaign=Member%20Newsletter&amp;utm_source=hs_email&amp;utm_medium=email&amp;_hsenc=p2ANqtz-9XrYBkCZA8PasxUe7lpjnqusmjXhv0gkoLGJc46vPSoOuUkMoDu1PXNjrtKt6rnDzW9hz_" rel="noopener" style="mso-line-height-rule:exactly; color:#f79422" data-hs-link-id="1" target="_blank">Software Mansion SA</a></p>
<ul style="mso-line-height-rule:exactly; line-height:175%"></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_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 class="social-network-cell" 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=Member%20Newsletter&amp;utm_source=hs_email&amp;utm_medium=email&amp;_hsenc=p2ANqtz-9XrYBkCZA8PasxUe7lpjnqusmjXhv0gkoLGJc46vPSoOuUkMoDu1PXNjrtKt6rnDzW9hz_" 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.114/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 class="social-network-cell" 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=Member%20Newsletter&amp;utm_source=hs_email&amp;utm_medium=email&amp;_hsenc=p2ANqtz-9XrYBkCZA8PasxUe7lpjnqusmjXhv0gkoLGJc46vPSoOuUkMoDu1PXNjrtKt6rnDzW9hz_" 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.114/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 class="social-network-cell" 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=Member%20Newsletter&amp;utm_source=hs_email&amp;utm_medium=email&amp;_hsenc=p2ANqtz-9XrYBkCZA8PasxUe7lpjnqusmjXhv0gkoLGJc46vPSoOuUkMoDu1PXNjrtKt6rnDzW9hz_" 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.114/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 class="social-network-cell" 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=Member%20Newsletter&amp;utm_source=hs_email&amp;utm_medium=email&amp;_hsenc=p2ANqtz-9XrYBkCZA8PasxUe7lpjnqusmjXhv0gkoLGJc46vPSoOuUkMoDu1PXNjrtKt6rnDzW9hz_" 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.114/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 class="social-network-cell" 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.114/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 © 2023 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, Rond Point Robert Schuman, Brussels, Belgium 1040
                </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>
