<boardmember id="holmes" type="addin">

	<name> Chris Holmes </name>

	<title> Product Architect, Planet Labs </title>

	<image>holmes.jpg</image>

	<email> cholmes at planet.com </email>

	<eclipse_affiliation> <![CDATA[
		LocationTech	
	]]> </eclipse_affiliation>

	<vision>  <![CDATA[
<p>More than any other open source foundation, Eclipse has secured its reputation as the best place for companies to collaborate. This started with the IDE, and has flourished with the rich ecosystem of tools built upon the Eclipse Platform. As a former Java developer I was excited to come back into the Eclipse universe through my involvement in LocationTech. And I have been inspired by seeing that core company collaboration model expand out even more, to location, science, Internet of Things, embedded systems and automotive domains.
</p>

<p>When I was elected to the board last year my first priority was to represent LocationTech, but I’ve been excited by how much potential there is in the broader Eclipse world. My vision for Eclipse is to be the preeminent foundation for companies to collaborate together on software. In the short term this means strengthening the existing Eclipse Working Groups, and making clear to the world that Eclipse is more than a Java IDE. This does not mean we should decrease investment in the core Eclipse Platform, as it is critical that it remains our foremost example of successful collaboration. But it does mean making our messaging clearer about what Eclipse is and promoting all our projects.</p>

<p>My background is all open source software - first coding and building a community around an Java-based online mapping server, then figuring out a consultancy business model to sustain core developers. We then successfully transitioned it to a product company, selling enterprise packages of our fully open source stack. Having seen so many different phases of the company lifecycle I believe I can represent the sustaining members well, and I’ve served in similar board roles in geospatial foundations, including the Open Geospatial Consortium and Global Spatial Data Infrastructure. But I believe the background that can best serve Eclipse is my background in product management, strategy and open source business. 
</p>

<p>If re-elected as a sustaining member representative my priorities will be:
</p>

<ul>
<li>Understand and represent the needs of Sustaining Member companies at the board level. Though the companies with the largest budgets can easily 
contribute monetarily, I believe the intangible contributions of time, ideas and code are even more vital to the continued success of the community. 
Sustaining member companies are the lifeblood of Eclipse, and I hope to represent any concerns of the group as my own and represent at the board level. Of 
particular interest to me is the Working Groups, as I believe they have great potential.
</li>
<li>Help the Eclipse Management Organization explore alternate business models that can fund core improvements that are desired by 
users but less well addressed by the community. The Friends of Eclipse has been a great start in that direction, but I believe we can go much 
further. A key is making it so it’s easier for a traditional procurement process to ‘buy’ the improvements desired by large companies. 
I believe my experiences can be helpful in the Eclipse ecosystem.
</li>
<li>Focus on core improvements to the Java IDE - further improving usability, integrations (like improving the Git experience), performance, 
and general utility to a mainstream user. The thing everyone still thinks of as ‘Eclipse’ needs to be strong, and work well for the mainstream user. 
</li>
<li>Support LocationTech to become the premier collaboration place for geospatial software. I will do this by helping push and celebrate 
graduation from incubation for projects and leveraging contacts to contribute their best projects and become members. My priorities for LocationTech 
are to bring in an evangelist, grow the tour and conferences, and help cross fertilization of ideas and technologies between LocationTech, other 
Eclipse Foundation working groups, and the broader community.
</li>
<li>Work to make the Eclipse Foundation more welcoming to new projects. There are two main parts to this. First is clarity of branding and 
messaging for the Eclipse Foundation, Eclipse Java IDE and Working Group projects in a way that promotes all. The second is improving the onboarding 
process for projects not built on the Eclipse Platform. The incubation and IP review process can be onerous, and the time commitment for project 
developers is unclear. Higher level projects built on the vast array of great open source code created outside the foundation can be 
hindered by months of delay. We need to balance the huge value of IP review with the reality of how modern companies use and adopt 
open source, so the benefits to developers of their great project joining Eclipse outweigh the burdens.</li>
</ul>

	]]> </vision>


	<bio> <![CDATA[
<p>Chris Holmes started his career as lead developer of <a target="_blank" href="http://geoserver.org/">GeoServer</a> and then founded OpenGeo (operating now as <a target="_blank" href="http://boundlessgeo.com/">Boundless</a>), providing commercial support for a suite of open source geospatial software projects. He currently works at <a target="_blank" href="http://planet.com/">Planet Labs</a>, a startup that builds and operates the largest constellation of earth imaging satellites, with over 100 successfully launched to date. At Planet Labs Chris serves as the Product Architect, where he sits at the nexus of technology and business, leading product management and strategy. He also sits on the boards of the <a target="_blank" href="http://www.opengeospatial.org/">Open Geospatial Consortium (OGC)</a> and <a target="_blank" href="http://www.bravenewsoftware.org/">Brave New Software</a>, and serves as an advisor to <a target="_blank" href="https://cartodb.com/">CartoDB</a>. Chris previously was a Fulbright Scholar in Zambia, served on the board of the Global Spatial Data Infrastructure Association and was a founding board member of the Open Source Geospatial Consortium 
</p>

		
	]]> </bio>

	<affiliation> <![CDATA[ 
		
	Planet Labs
	]]>
	</affiliation>

		
</boardmember>

