<!-- id is the same as the file name without the extension
     type is one of "committer" or "add-in-provider" -->
     
<boardmember id="aniszczyk" type="committer">

	<name>Chris Aniszczyk</name>

	<title> <![CDATA[
	CTO, Cloud Native Computing Foundation (CNCF)<br>
	VP, Developer Relations, Linux Foundation
	]]> </title>

	<image>aniszczyk.jpg</image>

	<email>caniszczyk at gmail.com</email>

	<eclipse_affiliation> <![CDATA[
        <a href="http://www.eclipse.org/technology/team-leaders.php">Technology</a> PMC Member<br>
        <a href="http://www.eclipse.org/orbit">Orbit</a> Committer<br>
        <a href="http://planet.eclipse.org">PlanetEclipse.org</a> Maintainer<br>
		<a href="http://www.eclipse.org/egit">EGit</a> / JGit Committer (formerly)<br>
        <a href="http://www.eclipsecon.org">EclipseCon</a> Program Committee (2007-2012)<br>
        Eclipse Board Committer Representative (2007-2020)
	]]> </eclipse_affiliation>

	<vision>  <![CDATA[
		<p>I've been grateful to be a part of the Eclipse community for over a decade and honored to have served the committers on the Board for about a decade. My previous activities on the board I've helped initiative a <a href=“http://aniszczyk.org/2015/06/26/eclipse-code-of-conduct/”>code of conduct</a>, update our infrastructure by moving to
		<a href="http://mmilinkov.wordpress.com/2012/12/21/eclipse-says-goodbye-to-cvs/">Git/Gerrit</a>, push the Board to <a href="http://mmilinkov.wordpress.com/2013/06/20/embracing-social-coding-at-eclipse/">embrace social coding at the Foundation</a> as an option for development (see <a href="http://www.infoq.com/news/2013/01/vertx-eclipse">Vertx as a case study</a>) and helped push for a simplified the IP process with <a href="http://mmilinkov.wordpress.com/2013/06/17/eclipse-clas-are-live/">CLAs</a>.
	</p><p>While my current job is helping run an open source foundation dedicated to cloud native computing, which has led to us collaborating on a new event <a href="https://eclipse-5413615.hs-sites.com/cn4j-day">Cloud Native For Java Day</a> (CN4J). I have a lot of ideas I can share from that experience on how to improve the lives of committers concretely:</p>

		<p><b>Expand the usage of modern tooling within the Eclipse infrastructure and don't shy away from cloud offerings. There are amazing tools out there such as GitLab, FOSSA, Snyk, Orbit, etc that the committers should be able to take advantage of.</b></p>

		<p><b>Push the Eclipse Foundation to diversify/grow revenue to hire more staff</b></p>

<p><b>Push the Eclipse Foundation to collaborate more with other foundations, from cross project collaboration to colocating events like Cloud Native for Java Day or having Eclipse participate in events like <a href ="https://events.linuxfoundation.org/kubernetes-on-edge-day/">Kubernetes Edge Day</a>.</b></p>

				<p><b>Attract new projects and continue to mentor projects at the Eclipse Foundation</b></p>

				<p>While I'm not as active on the Eclipse coding front as I've been in the past, I'm almost always one of the first people to volunteer to mentor a new project. I will continue to do my best to grow the Eclipse committer community by attracting and mentoring new projects.</p>
		</ul>

		<p>On the whole, my goal has always been to make Eclipse thrive and be transparent as possible about the board's
		activities. I really love bringing new projects to the Eclipse ecosystem and mentoring new committers. In the end,
		I would be honored to represent committers on the board.</p>
		]]> </vision>

	<bio> <![CDATA[
		<p>
		Chris Aniszczyk (<a href="http://twitter.com/cra">@cra</a>) is an open source executive and software engineer by trade with a
		passion for building ecosystem. At Twitter, he was responsible for
		creating their open source program and managing their open source efforts. He also has the honor
		to sit on the Eclipse Architecture and Planning councils. In a previous life, he traveled the world and
		consulted companies on Eclipse technology. He also lead and hacked on many eclipse.org and linux related
		projects. In his spare time, you'll find him running, cycling or doing yoga.</p>
	]]> </bio>

	<affiliation> <![CDATA[
		Independent
	]]>
	</affiliation>

</boardmember>
