<boardmember id="aniszczyk" type="committer">

	<name>Chris Aniszczyk</name>

	<title>Executive Director, Open Container Initiative (OCI)</title>
	<title>CTO, Cloud Native Computing Foundation (CNCF)</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> and Mylyn PMC Member<br>
        <a href="http://www.eclipse.org/egit">EGit</a> / JGit Committer<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.eclipsecon.org">EclipseCon</a> Program Committee (2007-2012)<br>
        Eclipse Board Committer Representative (2007-2017)
	]]> </eclipse_affiliation>

	<vision>  <![CDATA[
		<p>I've been grateful to be a part of the Eclipse community for a decade and honored to have served the committers on the Board for nearly 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>If I'm elected, I want to focus on few concrete tasks to make the lives of committers easier:</p>

		<p><b>Push the Eclipse Foundation to modify the principle of vendor neutrality in relation to tooling available for committers. In the past, it has always prevented us from using non-OSS components in our infrastructure and I think it's important we have a discussion on whether it's worth having this restriction in place in todays world.</b> For example, there are third party tools such as Travis CI, CircleCI, FOSSA and so on that can make the lives of committers easier.</p>

		<p><b>Push the Eclipse Foundation to hire more developers on staff (they recently started to do this)</b></p>

			<p><b>Ensure Eclipse processes are transparent and lightweight as possible</b></p>

			<p>We have done a lot of work to make Eclipse processes lighter than they have been before, but I believe we can do better. There
				are opportunities for more automation and making it easier to do release reviews. We need to keep the quality bar high (including IP cleanliness),
				but we need to do our best to not get in the way of projects shipping.</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 a software architect by trade with a
		passion for open source and building communities. 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>
