
<!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 – March 2022</title>
    <meta property="og:title" content="Eclipse Foundation Member Newsletter – March 2022">
    <meta name="twitter:title" content="Eclipse Foundation Member Newsletter – March 2022">
    
    
    
<meta name="x-apple-disable-message-reformatting">
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">

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

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


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


    






      













    


  <meta name="generator" content="HubSpot"><meta property="og:url" content="http://eclipse-5413615.hs-sites.com/eclipse-foundation-member-newsletter-march-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-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-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-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}}</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}
@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}
}@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}
}</style></head>
  <body bgcolor="#f2f2f2" style="margin:0 !important; padding:0 !important; font-family:Arial, sans-serif; font-size:15px; color:#444444; word-break:break-word">
    


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


    
<!--[if gte mso 9]>
<v:background xmlns:v="urn:schemas-microsoft-com:vml" fill="t">
  
    <v:fill type="tile" size="100%,100%" color="#f2f2f2"/>
  
</v:background>
<![endif]-->


    <div class="hse-body-background" style="background-color:#f2f2f2" bgcolor="#f2f2f2">
      <table role="presentation" class="hse-body-wrapper-table" cellpadding="0" cellspacing="0" style="border-spacing:0 !important; border-collapse:collapse; mso-table-lspace:0pt; mso-table-rspace:0pt; margin:0; padding:0; width:100% !important; min-width:320px !important; height:100% !important" width="100%" height="100%">
        <tbody><tr>
          <td class="hse-body-wrapper-td" valign="top" style="border-collapse:collapse; mso-line-height-rule:exactly; font-family:Arial, sans-serif; font-size:15px; color:#444444; word-break:break-word; padding-top:20px">
            <div id="hs_cos_wrapper_main" class="hs_cos_wrapper hs_cos_wrapper_widget hs_cos_wrapper_type_dnd_area" style="color: inherit; font-size: inherit; line-height: inherit;" data-hs-cos-general-type="widget" data-hs-cos-type="dnd_area">  <div id="section_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-march-2023?ecid=&amp;utm_campaign=Member%20Newsletter&amp;utm_source=hs_email&amp;utm_medium=email&amp;_hsenc=p2ANqtz-9tjjplD6i39QptBw3VT7PARIVrwXFqQfEW1_jC_WJkZos5O4uaLbYr2nqxfZUTFWJKTcPJ" style="mso-line-height-rule:exactly; color:#F79422; font-weight:normal; text-decoration:none; 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="EF March Memeber Newsletter 1" src="https://hs-5413615.f.hubspotemail.net/hub/5413615/hubfs/EF%20March%20Memeber%20Newsletter%201.png?upscale=true&amp;width=1116&amp;upscale=true&amp;name=EF%20March%20Memeber%20Newsletter%201.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/EF%20March%20Memeber%20Newsletter%201.png?upscale=true&amp;width=1116&amp;upscale=true&amp;name=EF%20March%20Memeber%20Newsletter%201.png 558w, https://hs-5413615.f.hubspotemail.net/hub/5413615/hubfs/EF%20March%20Memeber%20Newsletter%201.png?upscale=true&amp;width=2232&amp;upscale=true&amp;name=EF%20March%20Memeber%20Newsletter%201.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_16062366968383" class="hs_cos_wrapper hs_cos_wrapper_widget hs_cos_wrapper_type_module" style="color: inherit; font-size: inherit; line-height: inherit;" data-hs-cos-general-type="widget" data-hs-cos-type="module"><div id="hs_cos_wrapper_module_16062366968383_" class="hs_cos_wrapper hs_cos_wrapper_widget hs_cos_wrapper_type_rich_text" style="color: inherit; font-size: inherit; line-height: inherit;" data-hs-cos-general-type="widget" data-hs-cos-type="rich_text"><h2 style="margin:0; mso-line-height-rule:exactly; line-height:175%; font-size:22px; text-align:center" align="center">March 2022</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_1586291145041102" class="hs_cos_wrapper hs_cos_wrapper_widget hs_cos_wrapper_type_module" style="color: inherit; font-size: inherit; line-height: inherit;" data-hs-cos-general-type="widget" data-hs-cos-type="module"><div id="hs_cos_wrapper_module_1586291145041102_" class="hs_cos_wrapper hs_cos_wrapper_widget hs_cos_wrapper_type_rich_text" style="color: inherit; font-size: inherit; line-height: inherit;" data-hs-cos-general-type="widget" data-hs-cos-type="rich_text"><ul style="mso-line-height-rule:exactly; line-height:175%">
<li style="mso-line-height-rule:exactly">Executive Director’s Report</li>
<li style="mso-line-height-rule:exactly">New Board of Directors Representatives Elected</li>
<li style="mso-line-height-rule:exactly">Software-Defined Vehicle Working Group Officially Launched</li>
<li style="mso-line-height-rule:exactly">EclipseCon Returning to Ludwigsburg</li>
<li style="mso-line-height-rule:exactly">Jakarta EE 2022 Developer Survey Now Open</li>
<li style="mso-line-height-rule:exactly">Featured Working Group: Cloud DevTools</li>
</ul></div></div></td></tr></tbody></table>
</div>
<!--[if gte mso 9]></table><![endif]-->
<!--[if (mso)|(IE)]></td><![endif]-->


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

    </div>
   
  </div>

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

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

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









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

<div>

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

<!--[if gte mso 9]></div></v:textbox></v:rect><![endif]--></div></td></tr></tbody></table>
<table role="presentation" cellpadding="0" cellspacing="0" width="100%" style="border-spacing:0 !important; border-collapse:collapse; mso-table-lspace:0pt; mso-table-rspace:0pt"><tbody><tr><td class="hs_padded" style="border-collapse:collapse; mso-line-height-rule:exactly; font-family:Arial, sans-serif; font-size:15px; color:#444444; word-break:break-word; padding:10px 20px"><div id="hs_cos_wrapper_module_16473787195011" 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_16473787195011_" 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">Executive Director’s Report</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_163726221923914" 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_163726221923914_" class="hs_cos_wrapper hs_cos_wrapper_widget hs_cos_wrapper_type_rich_text" style="color: inherit; font-size: inherit; line-height: inherit;" data-hs-cos-general-type="widget" data-hs-cos-type="rich_text"><div style="mso-line-height-rule:exactly; line-height:175%; text-align:center" align="center">
<p style="mso-line-height-rule:exactly; line-height:175%; text-align:left" align="left">I hope this newsletter finds you and yours safe and well. I have mixed emotions in writing this quarter’s report: After several challenging years, 2022 is shaping up to be another one for the history books.&nbsp;&nbsp;</p>
<p style="mso-line-height-rule:exactly; line-height:175%; text-align:left" align="left">&nbsp;</p>
<p style="mso-line-height-rule:exactly; line-height:175%; text-align:left" align="left">I would be remiss if I ignored the significant challenges affecting so many in our community. Of note, this includes the ongoing pandemic, which continues to wreak havoc with the lives of so many, as well as the attack on Ukraine. As I wrote <a href="https://eclipse-foundation.blog/2022/03/01/the-eclipse-foundation-standwithukraine/?utm_campaign=Member%20Newsletter&amp;utm_source=hs_email&amp;utm_medium=email&amp;_hsenc=p2ANqtz-9tjjplD6i39QptBw3VT7PARIVrwXFqQfEW1_jC_WJkZos5O4uaLbYr2nqxfZUTFWJKTcPJ" style="mso-line-height-rule:exactly; color:#f79422" data-hs-link-id="0" target="_blank">in my blog</a> recently, our thoughts go out, especially to our committers and contributors based in Ukraine.</p>
<p style="mso-line-height-rule:exactly; line-height:175%; text-align:left" align="left">&nbsp;</p>
<p style="mso-line-height-rule:exactly; line-height:175%; text-align:left" align="left">On a positive note, I am very pleased to report that the state of the Eclipse Foundation and its community is strong. Major new initiatives are underway, including the recent launch of the <a href="https://sdv.eclipse.org/?utm_campaign=Member%20Newsletter&amp;utm_source=hs_email&amp;utm_medium=email&amp;_hsenc=p2ANqtz-9tjjplD6i39QptBw3VT7PARIVrwXFqQfEW1_jC_WJkZos5O4uaLbYr2nqxfZUTFWJKTcPJ" style="mso-line-height-rule:exactly; color:#f79422" data-hs-link-id="0" target="_blank">Software-Defined Vehicle Working Group</a>, which is described later in this issue, and significant releases are either planned or already underway with so many of our existing projects.&nbsp;</p>
<p style="mso-line-height-rule:exactly; line-height:175%; text-align:left" align="left">&nbsp;</p>
<p style="mso-line-height-rule:exactly; line-height:175%; text-align:left" align="left">As noted in this newsletter, elections for the representatives for Contributing and Committer Members of the Board were just completed. These roles are incredibly valuable to the Eclipse Foundation, as the elected representatives provide valuable insights and perspectives on many of the issues the Board will be dealing with in the coming year. I wish to personally thank all those who stood for election. I also wish to thank Chris Aniszczyk and Kevin Sutter who are leaving the Board at the end of March - your contributions and your wisdom will be missed.&nbsp;</p>
<p style="mso-line-height-rule:exactly; line-height:175%; text-align:left" align="left">&nbsp;</p>
<p style="mso-line-height-rule:exactly; line-height:175%; text-align:left" align="left">I am pleased to report that our membership remains strong. As of February 28, we have 324 Corporate Members and 1,780 Committers.</p>
<p style="mso-line-height-rule:exactly; line-height:175%; text-align:left" align="left">&nbsp;</p>
<p style="mso-line-height-rule:exactly; line-height:175%; text-align:left" align="left">The Eclipse Foundation’s finances are on target. We ended 2021 ahead of budget, and 2022’s budget – approved by the Board in December 2021 – includes significant growth for the Eclipse Foundation. This growth is based on a few of the major initiatives, and the continued solid engagement with many of our projects.</p>
<p style="mso-line-height-rule:exactly; line-height:175%; text-align:left" align="left">&nbsp;</p>
<p style="mso-line-height-rule:exactly; line-height:175%; text-align:left" align="left">As part of our transition to a Europe-based foundation, we will be reporting all financial information in Euros rather than USD as of this year. See the chart below.</p>
</div></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:22px 0px 22px 40px"><div id="hs_cos_wrapper_module_16473673670791" 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"><style type="text/css">
.tg  {border-collapse:collapse;border-spacing:0;}
.tg td{border-color:black;border-style:solid;border-width:1px;font-family:Arial, sans-serif;font-size:14px;
  overflow:hidden;padding:10px 5px;word-break:normal;}
.tg th{border-color:black;border-style:solid;border-width:1px;font-family:Arial, sans-serif;font-size:14px;
  font-weight:normal;overflow:hidden;padding:10px 5px;word-break:normal;}
.tg .tg-c3ow{border-color:inherit;text-align:center;vertical-align:top}
.tg .tg-0pky{border-color:inherit;text-align:left;vertical-align:top}
.tg .tg-7btt{border-color:inherit;font-weight:bold;text-align:center;vertical-align:top}
</style>
<table class="tg" style="border-spacing:0 !important; border-collapse:collapse; mso-table-lspace:0pt; mso-table-rspace:0pt">
<thead>
  <tr>
    <th class="tg-0pky"></th>
    <th class="tg-7btt">2020 Actual (USD)</th>
    <th class="tg-7btt">2021 Actual (USD)</th>
    <th class="tg-7btt">2022 Forecast (EUR)</th>
  </tr>
</thead>
<tbody>
  <tr>
    <td class="tg-7btt" style="border-collapse:collapse; mso-line-height-rule:exactly; font-family:Arial, sans-serif; font-size:15px; color:#444444; word-break:break-word">Revenue</td>
    <td class="tg-c3ow" style="border-collapse:collapse; mso-line-height-rule:exactly; font-family:Arial, sans-serif; font-size:15px; color:#444444; word-break:break-word">6.7</td>
    <td class="tg-c3ow" style="border-collapse:collapse; mso-line-height-rule:exactly; font-family:Arial, sans-serif; font-size:15px; color:#444444; word-break:break-word">7.6</td>
    <td class="tg-c3ow" style="border-collapse:collapse; mso-line-height-rule:exactly; font-family:Arial, sans-serif; font-size:15px; color:#444444; word-break:break-word">8.7</td>
  </tr>
  <tr>
    <td class="tg-7btt" style="border-collapse:collapse; mso-line-height-rule:exactly; font-family:Arial, sans-serif; font-size:15px; color:#444444; word-break:break-word">Expenses</td>
    <td class="tg-c3ow" style="border-collapse:collapse; mso-line-height-rule:exactly; font-family:Arial, sans-serif; font-size:15px; color:#444444; word-break:break-word">6.6</td>
    <td class="tg-c3ow" style="border-collapse:collapse; mso-line-height-rule:exactly; font-family:Arial, sans-serif; font-size:15px; color:#444444; word-break:break-word">7.4</td>
    <td class="tg-c3ow" style="border-collapse:collapse; mso-line-height-rule:exactly; font-family:Arial, sans-serif; font-size:15px; color:#444444; word-break:break-word">9.0</td>
  </tr>
  <tr>
    <td class="tg-7btt" style="border-collapse:collapse; mso-line-height-rule:exactly; font-family:Arial, sans-serif; font-size:15px; color:#444444; word-break:break-word">Net Income</td>
    <td class="tg-c3ow" style="border-collapse:collapse; mso-line-height-rule:exactly; font-family:Arial, sans-serif; font-size:15px; color:#444444; word-break:break-word">0.1</td>
    <td class="tg-c3ow" style="border-collapse:collapse; mso-line-height-rule:exactly; font-family:Arial, sans-serif; font-size:15px; color:#444444; word-break:break-word">0.2</td>
    <td class="tg-c3ow" style="border-collapse:collapse; mso-line-height-rule:exactly; font-family:Arial, sans-serif; font-size:15px; color:#444444; word-break:break-word">(0.3)</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:10px 20px"><div id="hs_cos_wrapper_module_16473752655271" 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_16473752655271_" 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%">Finally, I wish to acknowledge the recent passing of Kit Lo. Kit was a long-time committer at the Eclipse Foundation, and co-lead of the Eclipse Babel project. On behalf of the entire Eclipse Foundation staff and community, I extend my condolences to Kit’s family and colleagues.</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_163726231639415" class="hs_cos_wrapper hs_cos_wrapper_widget hs_cos_wrapper_type_module" style="color: inherit; font-size: inherit; line-height: inherit;" data-hs-cos-general-type="widget" data-hs-cos-type="module">









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

<div>

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

<!--[if gte mso 9]></div></v:textbox></v:rect><![endif]--></div></td></tr></tbody></table>
<table role="presentation" cellpadding="0" cellspacing="0" width="100%" style="border-spacing:0 !important; border-collapse:collapse; mso-table-lspace:0pt; mso-table-rspace:0pt"><tbody><tr><td class="hs_padded" style="border-collapse:collapse; mso-line-height-rule:exactly; font-family:Arial, sans-serif; font-size:15px; color:#444444; word-break:break-word; padding:10px 20px"><div id="hs_cos_wrapper_module_163726215836313" 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_163726215836313_" 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">New Board of Directors Representatives Elected</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 2022 elections for the Eclipse Foundation Board of Directors are complete. Congratulations to the newly elected representatives.</p>
<p style="mso-line-height-rule:exactly; line-height:175%">&nbsp;</p>
<p style="mso-line-height-rule:exactly; line-height:175%">Committer representatives:</p>
<ul style="mso-line-height-rule:exactly; line-height:175%">
<li style="mso-line-height-rule:exactly">Matthew Khouzam</li>
<li style="mso-line-height-rule:exactly">Shelley Lambert</li>
<li style="mso-line-height-rule:exactly">Ed Merks</li>
</ul>
<p style="mso-line-height-rule:exactly; line-height:175%">Contributing Member representatives:</p>
<ul style="mso-line-height-rule:exactly; line-height:175%">
<li style="mso-line-height-rule:exactly">Farah Papaioannou</li>
<li style="mso-line-height-rule:exactly">Torkild Ulvøy Resheim</li>
<li style="mso-line-height-rule:exactly">Gunnar WagenKnecht</li>
</ul>
<p style="mso-line-height-rule:exactly; line-height:175%">Thanks to everyone who participated by running, nominating, or voting in this year’s <a href="https://www.eclipse.org/org/elections/?utm_campaign=Member%20Newsletter&amp;utm_source=hs_email&amp;utm_medium=email&amp;_hsenc=p2ANqtz-9tjjplD6i39QptBw3VT7PARIVrwXFqQfEW1_jC_WJkZos5O4uaLbYr2nqxfZUTFWJKTcPJ" style="mso-line-height-rule:exactly; color:#f79422" data-hs-link-id="0" target="_blank">election process</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_4" class="hse-section" style="padding-left:10px; padding-right:10px">

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

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









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

<div>

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

<!--[if gte mso 9]></div></v:textbox></v:rect><![endif]--></div></td></tr></tbody></table>
<table role="presentation" cellpadding="0" cellspacing="0" width="100%" style="border-spacing:0 !important; border-collapse:collapse; mso-table-lspace:0pt; mso-table-rspace:0pt"><tbody><tr><td class="hs_padded" style="border-collapse:collapse; mso-line-height-rule:exactly; font-family:Arial, sans-serif; font-size:15px; color:#444444; word-break:break-word; padding:10px 20px"><div id="hs_cos_wrapper_module_16420923539392" 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_16420923539392_" 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; line-height:175%; text-align:center" align="center">Software-Defined Vehicle <br>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_15193855515321152" class="hs_cos_wrapper hs_cos_wrapper_widget hs_cos_wrapper_type_module" style="color: inherit; font-size: inherit; line-height: inherit;" data-hs-cos-general-type="widget" data-hs-cos-type="module"><div id="hs_cos_wrapper_module_15193855515321152_" class="hs_cos_wrapper hs_cos_wrapper_widget hs_cos_wrapper_type_rich_text" style="color: inherit; font-size: inherit; line-height: inherit;" data-hs-cos-general-type="widget" data-hs-cos-type="rich_text"><p style="mso-line-height-rule:exactly; line-height:175%">The Eclipse Foundation has officially launched the Software-Defined Working Group, which is focused on delivering source code for in-vehicle software that can be used across vehicle models, product lines, brands, and organizations.</p>
<p style="mso-line-height-rule:exactly; line-height:175%">&nbsp;</p>
<p style="mso-line-height-rule:exactly; line-height:175%">With 13 members already on board, the Software-Defined Working Group is creating an open ecosystem for deploying, configuring, and monitoring automotive software in a secure and safe way.</p>
<p style="mso-line-height-rule:exactly; line-height:175%">&nbsp;</p>
<p style="mso-line-height-rule:exactly; line-height:175%">Read the <a href="https://newsroom.eclipse.org/news/announcements/eclipse-foundation-announces-new-working-group-building-automotive-industry%E2%80%99s?utm_campaign=Member%20Newsletter&amp;utm_source=hs_email&amp;utm_medium=email&amp;_hsenc=p2ANqtz-9tjjplD6i39QptBw3VT7PARIVrwXFqQfEW1_jC_WJkZos5O4uaLbYr2nqxfZUTFWJKTcPJ" style="mso-line-height-rule:exactly; color:#f79422" data-hs-link-id="0" target="_blank">announcement</a> and check out <a href="https://sdv.eclipse.org/?utm_campaign=Member%20Newsletter&amp;utm_source=hs_email&amp;utm_medium=email&amp;_hsenc=p2ANqtz-9tjjplD6i39QptBw3VT7PARIVrwXFqQfEW1_jC_WJkZos5O4uaLbYr2nqxfZUTFWJKTcPJ" style="mso-line-height-rule:exactly; color:#f79422" data-hs-link-id="1" target="_blank">sdv.eclipse.org</a> for more information.</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)]></tr></table><![endif]-->

    </div>
   
  </div>

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

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

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









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

<div>

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

<!--[if gte mso 9]></div></v:textbox></v:rect><![endif]--></div></td></tr></tbody></table>
</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">
  <div id="hs_cos_wrapper_module_16421669806655" 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">
                
                <img alt="EF March Memeber Newsletter 2" src="https://hs-5413615.f.hubspotemail.net/hub/5413615/hubfs/EF%20March%20Memeber%20Newsletter%202.png?upscale=true&amp;width=1116&amp;upscale=true&amp;name=EF%20March%20Memeber%20Newsletter%202.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/EF%20March%20Memeber%20Newsletter%202.png?upscale=true&amp;width=1116&amp;upscale=true&amp;name=EF%20March%20Memeber%20Newsletter%202.png 558w, https://hs-5413615.f.hubspotemail.net/hub/5413615/hubfs/EF%20March%20Memeber%20Newsletter%202.png?upscale=true&amp;width=2232&amp;upscale=true&amp;name=EF%20March%20Memeber%20Newsletter%202.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_16372593591623" 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_16372593591623_" 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">EclipseCon Returning to Ludwigsburg</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_16449499884592" 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_16449499884592_" 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%">We are excited to be planning a face-to-face event for EclipseCon 2022! Plan to join us in Ludwigsburg, Germany, October 24-27.</p>
<p style="mso-line-height-rule:exactly; line-height:175%">&nbsp;</p>
<p style="mso-line-height-rule:exactly; line-height:175%">EclipseCon is a great opportunity for member companies to connect with community members. Book early to get your first choice of booths. For details, download the <a href="https://drive.google.com/file/d/1knirisEDprJaAFvPwfNs1f0AYZ8VUcK0/view?usp=sharing&amp;utm_campaign=Member%20Newsletter&amp;utm_source=hs_email&amp;utm_medium=email&amp;_hsenc=p2ANqtz-9tjjplD6i39QptBw3VT7PARIVrwXFqQfEW1_jC_WJkZos5O4uaLbYr2nqxfZUTFWJKTcPJ" style="mso-line-height-rule:exactly; color:#f79422" data-hs-link-id="0" target="_blank">EclipseCon 2022 Sponsorship Prospectus</a> or email us at <a href="mailto:sponsors@eclipsecon.org" style="mso-line-height-rule:exactly; color:#f79422" data-hs-link-id="0" target="_blank">sponsors@eclipsecon.org</a>.</p>
<p style="mso-line-height-rule:exactly; line-height:175%">&nbsp;</p>
<p style="mso-line-height-rule:exactly; line-height:175%">Important dates:</p>
<ul style="mso-line-height-rule:exactly; line-height:175%">
<li style="mso-line-height-rule:exactly">April 18: Call for proposals opens</li>
<li style="mso-line-height-rule:exactly">June 1: Early-bird submission deadline</li>
<li style="mso-line-height-rule:exactly">June 15: Final submission deadline</li>
</ul>
<p style="mso-line-height-rule:exactly; line-height:175%">Be sure to mark your calendar for October 24-27, 2022. For the latest news, <a href="https://twitter.com/eclipsecon?utm_campaign=Member%20Newsletter&amp;utm_source=hs_email&amp;utm_medium=email&amp;_hsenc=p2ANqtz-9tjjplD6i39QptBw3VT7PARIVrwXFqQfEW1_jC_WJkZos5O4uaLbYr2nqxfZUTFWJKTcPJ" style="mso-line-height-rule:exactly; color:#f79422" data-hs-link-id="0" target="_blank">follow us on Twitter</a>. We look forward to meeting you there!</p>
<p style="mso-line-height-rule:exactly; line-height:175%">&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_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]>
<v:rect xmlns:v="urn:schemas-microsoft-com:vml" fill="true" stroke="false" style="width:558px; height:2pt;" fillcolor="none">
<v:fill type="tile"/>
<v:textbox inset="0,0,0,0">

<div>

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

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


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

    </div>
   
  </div>

  <div id="section_1644950092822" 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_1644950092822_0" class="hse-column hse-size-12">
  <div id="hs_cos_wrapper_module_16473585101581" 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">
                
                <img alt="Member News letter 03 2022" src="https://hs-5413615.f.hubspotemail.net/hub/5413615/hubfs/Member%20News%20letter%2003%202022.png?upscale=true&amp;width=1116&amp;upscale=true&amp;name=Member%20News%20letter%2003%202022.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/Member%20News%20letter%2003%202022.png?upscale=true&amp;width=1116&amp;upscale=true&amp;name=Member%20News%20letter%2003%202022.png 558w, https://hs-5413615.f.hubspotemail.net/hub/5413615/hubfs/Member%20News%20letter%2003%202022.png?upscale=true&amp;width=2232&amp;upscale=true&amp;name=Member%20News%20letter%2003%202022.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_16473585640622" 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_16473585640622_" 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">Jakarta EE 2022 Developer Survey Now Open</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_15983851526202113" class="hs_cos_wrapper hs_cos_wrapper_widget hs_cos_wrapper_type_module" style="color: inherit; font-size: inherit; line-height: inherit;" data-hs-cos-general-type="widget" data-hs-cos-type="module"><div id="hs_cos_wrapper_module_15983851526202113_" class="hs_cos_wrapper hs_cos_wrapper_widget hs_cos_wrapper_type_rich_text" style="color: inherit; font-size: inherit; line-height: inherit;" data-hs-cos-general-type="widget" data-hs-cos-type="rich_text"><p style="mso-line-height-rule:exactly; line-height:175%">Take a few minutes to share your thoughts about cloud native Java with the <a href="https://www.surveymonkey.com/r/9NTFM6D?utm_campaign=Member%20Newsletter&amp;utm_source=hs_email&amp;utm_medium=email&amp;_hsenc=p2ANqtz-9tjjplD6i39QptBw3VT7PARIVrwXFqQfEW1_jC_WJkZos5O4uaLbYr2nqxfZUTFWJKTcPJ" rel="noopener" style="mso-line-height-rule:exactly; color:#f79422" data-hs-link-id="0" target="_blank">2022 Jakarta EE Developer Survey</a>. The survey takes less than six minutes to complete and is already seeing a high number of replies.</p>
<p style="mso-line-height-rule:exactly; line-height:175%">&nbsp;</p>
<p style="mso-line-height-rule:exactly; line-height:175%">Since it was first launched in 2018, thousands of software developers, architects, and decision-makers from around the world have completed the annual Jakarta EE Developer Survey. Participation allows members of the Java community to:</p>
<ul style="mso-line-height-rule:exactly; line-height:175%">
<li style="mso-line-height-rule:exactly">Build awareness around their development focus area</li>
<li style="mso-line-height-rule:exactly">Share their perceptions of the cloud native Java industry with the broader ecosystem</li>
<li style="mso-line-height-rule:exactly">Identify their preferences and priorities for cloud native Java architectures, technologies, and tools</li>
</ul>
<p style="mso-line-height-rule:exactly; line-height:175%">Enter your responses here: <a href="https://www.surveymonkey.com/r/9NTFM6D?utm_campaign=Member%20Newsletter&amp;utm_source=hs_email&amp;utm_medium=email&amp;_hsenc=p2ANqtz-9tjjplD6i39QptBw3VT7PARIVrwXFqQfEW1_jC_WJkZos5O4uaLbYr2nqxfZUTFWJKTcPJ" style="mso-line-height-rule:exactly; color:#f79422" data-hs-link-id="1" target="_blank">Jakarta EE Developer Survey</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_16473590665208" class="hs_cos_wrapper hs_cos_wrapper_widget hs_cos_wrapper_type_module" style="color: inherit; font-size: inherit; line-height: inherit;" data-hs-cos-general-type="widget" data-hs-cos-type="module">









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

<div>

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

<!--[if gte mso 9]></div></v:textbox></v:rect><![endif]--></div></td></tr></tbody></table>
<table role="presentation" cellpadding="0" cellspacing="0" width="100%" style="border-spacing:0 !important; border-collapse:collapse; mso-table-lspace:0pt; mso-table-rspace:0pt"><tbody><tr><td class="hs_padded" style="border-collapse:collapse; mso-line-height-rule:exactly; font-family:Arial, sans-serif; font-size:15px; color:#444444; word-break:break-word; padding:10px 20px"><div id="hs_cos_wrapper_module_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 Working Group: Cloud DevTools</h2></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_1647359047768" 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_1647457543341_0" class="hse-column hse-size-12">
  <div id="hs_cos_wrapper_module_16473590477545" 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 20px; font-size:0px">
                
                <img alt="ECD-Logo-Horz-Full_Color-TM copy 2" src="https://hs-5413615.f.hubspotemail.net/hub/5413615/hubfs/ECD-Logo-Horz-Full_Color-TM%20copy%202.png?upscale=true&amp;width=600&amp;upscale=true&amp;name=ECD-Logo-Horz-Full_Color-TM%20copy%202.png" style="outline:none; text-decoration:none; -ms-interpolation-mode:bicubic; max-width:100%; font-size:16px" width="300" align="middle" srcset="https://hs-5413615.f.hubspotemail.net/hub/5413615/hubfs/ECD-Logo-Horz-Full_Color-TM%20copy%202.png?upscale=true&amp;width=600&amp;upscale=true&amp;name=ECD-Logo-Horz-Full_Color-TM%20copy%202.png 300w, https://hs-5413615.f.hubspotemail.net/hub/5413615/hubfs/ECD-Logo-Horz-Full_Color-TM%20copy%202.png?upscale=true&amp;width=1200&amp;upscale=true&amp;name=ECD-Logo-Horz-Full_Color-TM%20copy%202.png 600w" sizes="(max-width: 300px) 100vw, 300px">
                
            </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_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; line-height:175%">The mission of the Eclipse Cloud DevTools Working Group is twofold:</p>
<ul style="mso-line-height-rule:exactly; line-height:175%">
<li style="mso-line-height-rule:exactly">Define and build an ecosystem of best-in-class, open source web and cloud-based development tools</li>
<li style="mso-line-height-rule:exactly">Promote and drive the broad adoption of these tools</li>
</ul>
<p style="mso-line-height-rule:exactly; line-height:175%">A recent initiative of the Working Group was the formation of an Embedded Special Interest Group (SIG). This is an open collaboration of embedded vendors and service providers, created to strengthen the open source ecosystem for building web- and cloud-based tools used for embedded development. The SIG provides the structure for participants to coordinate efforts, share insights, and collaborate on technical initiatives and standards. SIG members include Arm, EclipseSource, Ericsson, Renesas, and STMicroelectronics.</p>
<p style="mso-line-height-rule:exactly; line-height:175%">&nbsp;</p>
<p style="mso-line-height-rule:exactly; line-height:175%">Learn more about the <a href="https://ecdtools.eclipse.org/?utm_campaign=Member%20Newsletter&amp;utm_source=hs_email&amp;utm_medium=email&amp;_hsenc=p2ANqtz-9tjjplD6i39QptBw3VT7PARIVrwXFqQfEW1_jC_WJkZos5O4uaLbYr2nqxfZUTFWJKTcPJ" style="mso-line-height-rule:exactly; color:#f79422" data-hs-link-id="0" target="_blank">Cloud DevTools Working Group</a> and <a href="https://ecdtools.eclipse.org/resources/blogs/2021-11-02-embedded/?utm_campaign=Member%20Newsletter&amp;utm_source=hs_email&amp;utm_medium=email&amp;_hsenc=p2ANqtz-9tjjplD6i39QptBw3VT7PARIVrwXFqQfEW1_jC_WJkZos5O4uaLbYr2nqxfZUTFWJKTcPJ" style="mso-line-height-rule:exactly; color:#f79422" data-hs-link-id="0" target="_blank">the Embedded SIG</a>.</p>
<p style="mso-line-height-rule:exactly; line-height:175%"><strong>&nbsp;</strong></p>
<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>
<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)]></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%">&nbsp;</p>
<p style="mso-line-height-rule:exactly; line-height:175%"><a href="https://pnnl.cventevents.com/event/263dff6c-48d6-4003-bcf9-7d3f519e8f02/summary?utm_campaign=Member%20Newsletter&amp;utm_source=hs_email&amp;utm_medium=email&amp;_hsenc=p2ANqtz-9tjjplD6i39QptBw3VT7PARIVrwXFqQfEW1_jC_WJkZos5O4uaLbYr2nqxfZUTFWJKTcPJ" style="mso-line-height-rule:exactly; color:#f79422" data-hs-link-id="0" target="_blank">VOLTTRON Quarterly Meeting</a> | March 17, 2022</p>
<p style="mso-line-height-rule:exactly; line-height:175%">&nbsp;</p>
<p style="mso-line-height-rule:exactly; line-height:175%"><a href="https://www.date-conference.com/workshop/w04?utm_campaign=Member%20Newsletter&amp;utm_source=hs_email&amp;utm_medium=email&amp;_hsenc=p2ANqtz-9tjjplD6i39QptBw3VT7PARIVrwXFqQfEW1_jC_WJkZos5O4uaLbYr2nqxfZUTFWJKTcPJ" style="mso-line-height-rule:exactly; color:#f79422" data-hs-link-id="0" target="_blank">DATE 2022 OSHEAN (Open Source Hardware European Alliances Network)</a> | March 18, 2022</p>
<p style="mso-line-height-rule:exactly; line-height:175%">&nbsp;</p>
<p style="mso-line-height-rule:exactly; line-height:175%"><a href="https://foss-backstage.de/?utm_campaign=Member%20Newsletter&amp;utm_source=hs_email&amp;utm_medium=email&amp;_hsenc=p2ANqtz-9tjjplD6i39QptBw3VT7PARIVrwXFqQfEW1_jC_WJkZos5O4uaLbYr2nqxfZUTFWJKTcPJ" style="mso-line-height-rule:exactly; color:#f79422" data-hs-link-id="0" target="_blank">Foss Backstage</a>&nbsp; |&nbsp; March 18, 2022</p>
<p style="mso-line-height-rule:exactly; font-size:15px; line-height:175%">&nbsp;</p>
<p style="mso-line-height-rule:exactly; line-height:175%"><a href="https://www.crowdcast.io/e/jakarta-tech-talk--march30/register?utm_campaign=Member%20Newsletter&amp;utm_source=hs_email&amp;utm_medium=email&amp;_hsenc=p2ANqtz-9tjjplD6i39QptBw3VT7PARIVrwXFqQfEW1_jC_WJkZos5O4uaLbYr2nqxfZUTFWJKTcPJ" style="mso-line-height-rule:exactly; color:#f79422" data-hs-link-id="0" target="_blank">Jakarta EE &amp; MicroProfile - Piranha Cloud (Tech Talk) </a>&nbsp;| March 30, 2022</p>
<p style="mso-line-height-rule:exactly; line-height:175%">&nbsp;</p>
<p style="mso-line-height-rule:exactly; line-height:175%"><a href="https://www.crowdcast.io/e/virtual-iot-april5/register?utm_campaign=Member%20Newsletter&amp;utm_source=hs_email&amp;utm_medium=email&amp;_hsenc=p2ANqtz-9tjjplD6i39QptBw3VT7PARIVrwXFqQfEW1_jC_WJkZos5O4uaLbYr2nqxfZUTFWJKTcPJ" style="mso-line-height-rule:exactly; color:#f79422" data-hs-link-id="0" target="_blank">Virtual IoT Meetups - (Benefits Of MQTT for IoT Apps and Beyond)</a>&nbsp; | April 5, 2022</p>
<p style="mso-line-height-rule:exactly; line-height:175%">&nbsp;</p>
<p style="mso-line-height-rule:exactly; line-height:175%"><a href="https://www.crowdcast.io/e/jakarta-tech-talk--april12/register?utm_campaign=Member%20Newsletter&amp;utm_source=hs_email&amp;utm_medium=email&amp;_hsenc=p2ANqtz-9tjjplD6i39QptBw3VT7PARIVrwXFqQfEW1_jC_WJkZos5O4uaLbYr2nqxfZUTFWJKTcPJ" style="mso-line-height-rule:exactly; color:#f79422" data-hs-link-id="0" target="_blank">Jakarta Tech Talk - (Implementing Servlet 6.0 in Jetty)</a>&nbsp; | April 12, 2022</p>
<p style="mso-line-height-rule:exactly; line-height:175%">&nbsp;</p>
<p style="mso-line-height-rule:exactly; line-height:175%"><a href="https://ecdtools.eclipse.org/events/cloudideday2022/?utm_campaign=Member%20Newsletter&amp;utm_source=hs_email&amp;utm_medium=email&amp;_hsenc=p2ANqtz-9tjjplD6i39QptBw3VT7PARIVrwXFqQfEW1_jC_WJkZos5O4uaLbYr2nqxfZUTFWJKTcPJ" style="mso-line-height-rule:exactly; color:#f79422" data-hs-link-id="0" target="_blank">Cloud IDE Days 2022</a> | April 27, 2022</p>
<p style="mso-line-height-rule:exactly; line-height:175%">&nbsp;</p>
<p style="mso-line-height-rule:exactly; line-height:175%"><a href="https://www.hipeac.net/2022/budapest/?utm_campaign=Member%20Newsletter&amp;utm_source=hs_email&amp;utm_medium=email&amp;_hsenc=p2ANqtz-9tjjplD6i39QptBw3VT7PARIVrwXFqQfEW1_jC_WJkZos5O4uaLbYr2nqxfZUTFWJKTcPJ#/" style="mso-line-height-rule:exactly; color:#f79422" data-hs-link-id="0" target="_blank">HiPEAC Conference</a> | June 20-22, 2022</p>
<p style="mso-line-height-rule:exactly; font-size:15px; line-height:175%">&nbsp;</p>
</div></div></div></td></tr></tbody></table>
</div>
<!--[if gte mso 9]></table><![endif]-->
<!--[if (mso)|(IE)]></td><![endif]-->


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

    </div>
   
  </div>

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

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

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

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

    <!--[if (mso)|(IE)]>
  <td valign="top" style="width:598px;">
<![endif]-->
<!--[if gte mso 9]>
  <table role="presentation" width="598" cellpadding="0" cellspacing="0" style="border-collapse:collapse;mso-table-lspace:0pt;mso-table-rspace:0pt;width:598px">
<![endif]-->
<div id="column_1608144436884_0" class="hse-column hse-size-12">
  <table role="presentation" cellpadding="0" cellspacing="0" width="100%" style="border-spacing:0 !important; border-collapse:collapse; mso-table-lspace:0pt; mso-table-rspace:0pt"><tbody><tr><td class="hs_padded" style="border-collapse:collapse; mso-line-height-rule:exactly; font-family:Arial, sans-serif; font-size:15px; color:#444444; word-break:break-word; padding:10px 20px 0px"><div id="hs_cos_wrapper_module_16081444414732" class="hs_cos_wrapper hs_cos_wrapper_widget hs_cos_wrapper_type_module" style="color: inherit; font-size: inherit; line-height: inherit;" data-hs-cos-general-type="widget" data-hs-cos-type="module"><div id="hs_cos_wrapper_module_16081444414732_" class="hs_cos_wrapper hs_cos_wrapper_widget hs_cos_wrapper_type_rich_text" style="color: inherit; font-size: inherit; line-height: inherit;" data-hs-cos-general-type="widget" data-hs-cos-type="rich_text"><p style="mso-line-height-rule:exactly; line-height:175%; text-align:center" align="center">For the month of February 2022</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 10px"><div id="hs_cos_wrapper_module_16245439528584" 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_16245439528584_" 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; margin-top:16pt; margin-right:0cm; margin-bottom:4pt; padding-left:0cm; text-align:center; font-size:18px; line-height:175%" align="center"><strong><span style="color: #434343;">Contributing </span></strong><span style="color: #434343;">&nbsp;</span></p>
<div style="mso-line-height-rule:exactly; line-height:1.15; text-align:center" align="center">
<p style="mso-line-height-rule:exactly; line-height:175%"><a href="https://www.accenture.com/ca-en?utm_campaign=Member%20Newsletter&amp;utm_source=hs_email&amp;utm_medium=email&amp;_hsenc=p2ANqtz-9tjjplD6i39QptBw3VT7PARIVrwXFqQfEW1_jC_WJkZos5O4uaLbYr2nqxfZUTFWJKTcPJ" rel="noopener" style="mso-line-height-rule:exactly; color:#f79422" data-hs-link-id="0" target="_blank">Accenture GmbH</a></p>
<p style="mso-line-height-rule:exactly; line-height:175%">&nbsp;</p>
<p style="mso-line-height-rule:exactly; line-height:175%"><a href="https://www.capgemini.com/de-de/?utm_campaign=Member%20Newsletter&amp;utm_source=hs_email&amp;utm_medium=email&amp;_hsenc=p2ANqtz-9tjjplD6i39QptBw3VT7PARIVrwXFqQfEW1_jC_WJkZos5O4uaLbYr2nqxfZUTFWJKTcPJ" rel="noopener" style="mso-line-height-rule:exactly; color:#f79422" data-hs-link-id="0" target="_blank">Capgemini Deutschland GmbH</a></p>
<p style="mso-line-height-rule:exactly; line-height:175%">&nbsp;</p>
<p style="mso-line-height-rule:exactly; line-height:175%"><a href="https://www.continental-automotive.com/?utm_campaign=Member%20Newsletter&amp;utm_source=hs_email&amp;utm_medium=email&amp;_hsenc=p2ANqtz-9tjjplD6i39QptBw3VT7PARIVrwXFqQfEW1_jC_WJkZos5O4uaLbYr2nqxfZUTFWJKTcPJ" rel="noopener" style="mso-line-height-rule:exactly; color:#f79422" data-hs-link-id="0" target="_blank">Continental Automotive GmbH</a></p>
<p style="mso-line-height-rule:exactly; line-height:175%">&nbsp;</p>
<p style="mso-line-height-rule:exactly; line-height:175%"><a href="https://dminc.com/?utm_campaign=Member%20Newsletter&amp;utm_source=hs_email&amp;utm_medium=email&amp;_hsenc=p2ANqtz-9tjjplD6i39QptBw3VT7PARIVrwXFqQfEW1_jC_WJkZos5O4uaLbYr2nqxfZUTFWJKTcPJ" rel="noopener" style="mso-line-height-rule:exactly; color:#f79422" data-hs-link-id="0" target="_blank">Digital Mobile Innovations, LLC</a></p>
<p style="mso-line-height-rule:exactly; line-height:175%">&nbsp;</p>
<p style="mso-line-height-rule:exactly; line-height:175%"><a href="http://english.ict.cas.cn/?utm_campaign=Member%20Newsletter&amp;utm_source=hs_email&amp;utm_medium=email&amp;_hsenc=p2ANqtz-9tjjplD6i39QptBw3VT7PARIVrwXFqQfEW1_jC_WJkZos5O4uaLbYr2nqxfZUTFWJKTcPJ" rel="noopener" style="mso-line-height-rule:exactly; color:#f79422" data-hs-link-id="0" target="_blank">ICT CAS</a></p>
<p style="mso-line-height-rule:exactly; line-height:175%">&nbsp;</p>
<p style="mso-line-height-rule:exactly; line-height:175%"><a href="https://www.reycom.swiss/?utm_campaign=Member%20Newsletter&amp;utm_source=hs_email&amp;utm_medium=email&amp;_hsenc=p2ANqtz-9tjjplD6i39QptBw3VT7PARIVrwXFqQfEW1_jC_WJkZos5O4uaLbYr2nqxfZUTFWJKTcPJ" rel="noopener" style="mso-line-height-rule:exactly; color:#f79422" data-hs-link-id="0" target="_blank">Reycom AG</a></p>
<p style="mso-line-height-rule:exactly; line-height:175%">&nbsp;</p>
<p style="mso-line-height-rule:exactly; line-height:175%"><a href="https://www.zf.com/mobile/en/homepage/homepage.html?utm_campaign=Member%20Newsletter&amp;utm_source=hs_email&amp;utm_medium=email&amp;_hsenc=p2ANqtz-9tjjplD6i39QptBw3VT7PARIVrwXFqQfEW1_jC_WJkZos5O4uaLbYr2nqxfZUTFWJKTcPJ" rel="noopener" style="mso-line-height-rule:exactly; color:#f79422" data-hs-link-id="0" target="_blank">ZF Friedrichshafen AG</a></p>
<p style="mso-line-height-rule:exactly; line-height:175%">&nbsp;</p>
</div>
<h2 style="margin:0; mso-line-height-rule:exactly; line-height:115%; text-align:center; font-size:18px" align="center"><strong>Working Group Participation</strong></h2>
<p style="mso-line-height-rule:exactly; line-height:175%; text-align:center" align="center"><strong>Software-Defined Vehicle Working Group</strong></p>
<p style="mso-line-height-rule:exactly; line-height:175%; text-align:center" align="center"><a href="https://www.accenture.com/ca-en?utm_campaign=Member%20Newsletter&amp;utm_source=hs_email&amp;utm_medium=email&amp;_hsenc=p2ANqtz-9tjjplD6i39QptBw3VT7PARIVrwXFqQfEW1_jC_WJkZos5O4uaLbYr2nqxfZUTFWJKTcPJ" rel="noopener" style="mso-line-height-rule:exactly; color:#f79422" data-hs-link-id="1" target="_blank">Accenture GmbH</a></p>
<p style="mso-line-height-rule:exactly; line-height:175%; text-align:center" align="center">&nbsp;</p>
<p style="mso-line-height-rule:exactly; line-height:175%; text-align:center; font-weight:normal" align="center"><a href="https://www.avl.com/?avlregion=GLOBAL&amp;groupId=10138&amp;lang=en_US&amp;utm_campaign=Member%20Newsletter&amp;utm_source=hs_email&amp;utm_medium=email&amp;_hsenc=p2ANqtz-9tjjplD6i39QptBw3VT7PARIVrwXFqQfEW1_jC_WJkZos5O4uaLbYr2nqxfZUTFWJKTcPJ" rel="noopener" style="mso-line-height-rule:exactly; color:#f79422" data-hs-link-id="0" target="_blank">AVL List GmbH</a></p>
<p style="mso-line-height-rule:exactly; line-height:175%; text-align:center; font-weight:normal" align="center">&nbsp;</p>
<p style="mso-line-height-rule:exactly; line-height:175%; text-align:center; font-weight:normal" align="center"><a href="https://www.capgemini.com/de-de/?utm_campaign=Member%20Newsletter&amp;utm_source=hs_email&amp;utm_medium=email&amp;_hsenc=p2ANqtz-9tjjplD6i39QptBw3VT7PARIVrwXFqQfEW1_jC_WJkZos5O4uaLbYr2nqxfZUTFWJKTcPJ" rel="noopener" style="mso-line-height-rule:exactly; color:#f79422" data-hs-link-id="1" target="_blank">Capgemini Deutschland GmbH</a></p>
<p style="mso-line-height-rule:exactly; line-height:175%; text-align:center; font-weight:normal" align="center">&nbsp;</p>
<p style="mso-line-height-rule:exactly; line-height:175%; text-align:center; font-weight:normal" align="center"><a href="https://www.continental-automotive.com/?utm_campaign=Member%20Newsletter&amp;utm_source=hs_email&amp;utm_medium=email&amp;_hsenc=p2ANqtz-9tjjplD6i39QptBw3VT7PARIVrwXFqQfEW1_jC_WJkZos5O4uaLbYr2nqxfZUTFWJKTcPJ" rel="noopener" style="mso-line-height-rule:exactly; color:#f79422" data-hs-link-id="1" target="_blank">Continental Automotive GmbH</a></p>
<p style="mso-line-height-rule:exactly; line-height:175%; text-align:center; font-weight:normal" align="center">&nbsp;</p>
<p style="mso-line-height-rule:exactly; line-height:175%; text-align:center; font-weight:normal" align="center"><a href="https://dminc.com/?utm_campaign=Member%20Newsletter&amp;utm_source=hs_email&amp;utm_medium=email&amp;_hsenc=p2ANqtz-9tjjplD6i39QptBw3VT7PARIVrwXFqQfEW1_jC_WJkZos5O4uaLbYr2nqxfZUTFWJKTcPJ" rel="noopener" style="mso-line-height-rule:exactly; color:#f79422" data-hs-link-id="1" target="_blank">Digital Mobile Innovations, LLC</a></p>
<p style="mso-line-height-rule:exactly; line-height:175%; text-align:center; font-weight:normal" align="center">&nbsp;</p>
<p style="mso-line-height-rule:exactly; line-height:175%; text-align:center; font-weight:normal" align="center"><a href="https://karakun.com/en/home/?utm_campaign=Member%20Newsletter&amp;utm_source=hs_email&amp;utm_medium=email&amp;_hsenc=p2ANqtz-9tjjplD6i39QptBw3VT7PARIVrwXFqQfEW1_jC_WJkZos5O4uaLbYr2nqxfZUTFWJKTcPJ" rel="noopener" style="mso-line-height-rule:exactly; color:#f79422" data-hs-link-id="0" target="_blank">Karakun AG</a></p>
<p style="mso-line-height-rule:exactly; line-height:175%; text-align:center; font-weight:normal" align="center">&nbsp;</p>
<p style="mso-line-height-rule:exactly; line-height:175%; text-align:center; font-weight:normal" align="center"><a href="https://www.reycom.swiss/?utm_campaign=Member%20Newsletter&amp;utm_source=hs_email&amp;utm_medium=email&amp;_hsenc=p2ANqtz-9tjjplD6i39QptBw3VT7PARIVrwXFqQfEW1_jC_WJkZos5O4uaLbYr2nqxfZUTFWJKTcPJ" rel="noopener" style="mso-line-height-rule:exactly; color:#f79422" data-hs-link-id="1" target="_blank">Reycom AG</a></p>
<p style="mso-line-height-rule:exactly; line-height:175%; text-align:center; font-weight:normal" align="center">&nbsp;</p>
<p style="mso-line-height-rule:exactly; line-height:175%; text-align:center; font-weight:normal" align="center"><a href="https://www.redhat.com/en?utm_campaign=Member%20Newsletter&amp;utm_source=hs_email&amp;utm_medium=email&amp;_hsenc=p2ANqtz-9tjjplD6i39QptBw3VT7PARIVrwXFqQfEW1_jC_WJkZos5O4uaLbYr2nqxfZUTFWJKTcPJ" rel="noopener" style="mso-line-height-rule:exactly; color:#f79422" data-hs-link-id="0" target="_blank">Red Hat</a></p>
<p style="mso-line-height-rule:exactly; line-height:175%; text-align:center; font-weight:normal" align="center">&nbsp;</p>
<p style="mso-line-height-rule:exactly; line-height:175%; text-align:center; font-weight:normal" align="center"><a href="https://www.zf.com/mobile/en/homepage/homepage.html?utm_campaign=Member%20Newsletter&amp;utm_source=hs_email&amp;utm_medium=email&amp;_hsenc=p2ANqtz-9tjjplD6i39QptBw3VT7PARIVrwXFqQfEW1_jC_WJkZos5O4uaLbYr2nqxfZUTFWJKTcPJ" rel="noopener" style="mso-line-height-rule:exactly; color:#f79422" data-hs-link-id="1" target="_blank">ZF Friedrichshafen AG</a></p>
<div style="mso-line-height-rule:exactly; line-height:1.15; text-align:center" align="center">&nbsp;</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_13" class="hse-section" style="padding-left:10px; padding-right:10px">

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

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

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


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

    </div>
   
  </div>

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

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

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


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

    </div>
   
  </div>

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

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

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








  



  
  
  
  
  
  


















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


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

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