<!-- id is the same as the file name without the extension
     type is one of "committer" or "add-in-provider" -->
<boardmember id="khouzam" type="committer">

	<name>Matthew Khouzam</name>

	<title></title>

	<!-- Name of the file containing the image of the candidate; location relative to this file.  -->
	<image>khouzam.jpg</image>

	<!-- eMail address will be modified before it is included on a webpage so that robots will not harvest it. -->
	<email>matthew.khouzam@ericsson.com</email>

	<phone></phone>

	<!-- How do we contact you? e.g. postal address -->
	<contact></contact>

	<!-- What do you do with eclipse? -->
	<eclipse_affiliation>I work on Trace Compass, as well as the Trace Compass environment as a manager and developer. I also work with Eclipse Theia, Blueprint, and CDT.cloud. I work within the tools team at Ericsson.</eclipse_affiliation>

	<!-- Feel free to include html tags and what-not between the CDATA tags. -->
	<vision>
		<![CDATA[
<p>I would focus on security, integrity, clarity, performance and community aspects. On the community side, I would push for efforts to make Eclipse more interesting for academia and smaller businesses, in an effort to diversify the ecosystem. With performance, despite being a "manager," in my heart I am a performance engineer. Trace Compass and MicroProfile have done great work making instrumentation easier in Eclipse. I would foster more collaborations on their side as well.</p>
<p>On the clarity side, the Eclipse Foundation is a role model of openness, and I would continue to defend their efforts. On the integrity side, projects such as dash-licenses show that the project is open in a responsible way and encourages strong IP due diligence, and I would continue to support such initiatives as well as the open chain initiative.</p>
<p>For security, Eclipse is world class, in my opinion. Their response time to CVEs such as Log4j and XercesJ was exemplary. I would continue encouraging such behaviour in any way possible.</p>
<p>We are a large and diverse community. This is great - let's share our ideas more, and have fun in the process.</p>
		]]>
	</vision>

	<!-- Tell us a little bit about yourself. -->
	<bio><![CDATA[
		<p>I have been using Eclipse tools since the Callisto release and have been a committer on Eclipse projects for 10 years, with almost 5,000 reviews to my name. I am the product manager for Eclipse Theia, OpenVSX, Eclipse Trace Compass within Ericsson and co-lead for the Eclipse Trace Compass Incubator. I am also co-lead of the CDT.cloud project. I am a technology enthusiast, especially in the field of performance engineering. In the copious amounts of free time I have left, I am a husband, a father, and I enjoy cooking, biking and woodworking. I am also a budding doodler and has been co-developing a game in my remaining spare time.</p>
		<p>I have worked in academia and industry, coordinating between large and small companies as well as university research labs.</p>
		<p>Finally, I am a great big nerd. I will gladly broach any subject if the other side brings enthusiasm.</p>
		<p>I was honored to have been elected in 2022 and have focused on protecting Eclipse's brand as well as increasing a focus on security and software origins/SBOMs in general. I will continue pushing these issues as with the current climate, this will benefit all committers.</p>
		<p>I am not related to Marc, though he is wonderful!</p>
    ]]></bio>

	<!-- Who do you work for? -->
	<affiliation>Product Manager / Developer at Ericsson</affiliation>

</boardmember>
