<boardmember id="merks" type="committer">

	<name>Ed Merks</name>

	<title>President, Macro Modeling</title>

	<image>merks.jpg</image>

	<email>Ed.Merks@gmail.com</email>

	<eclipse_affiliation> <![CDATA[		
		Eclipse Modeling Project Lead<br>
		Eclipse Modeling Framework Project Lead<br>
		XML Schema Definition Project Lead<br>
		Oomph Project Committer
	]]> </eclipse_affiliation>

	<vision>  <![CDATA[
	
<p>
Eclipse is a diverse community driven by a huge constellation of contributors: 
large and small commercial interests, educational institutions, and our dedicated committer community, i.e., people who do day-to-day development at Eclipse like you and me.
With the shift from a small number of large commercial interests to a broader spectrum of smaller organizations,
our influence as individuals grows.
As your committer representative on the board, I will employ my ten years of experience to promote the rights and privileges of committers.
I will continue to be a visible and approachable technical representative, who navigates the political landscape on your behalf.
I feel I've demonstrated this with my long track record as your representative on the board.
My background as a Canadian immigrant, born in the Netherlands, living in Berlin and having learned Deutsch, sensitizes me to the fact that great communities span cultural and linguistic boundaries.
</p>

<p>
Cliche as it may sound, I believe strongly that helping is its own reward. 
I answer questions daily on a broad range of forums, not just those for my own projects,
I fix bugzillas quickly for the users of my software,
and I develop cool new features whenever possible.
I am particularly proud of the <a href="http://wiki.eclipse.org/Eclipse_Oomph_Installer" target="_blank">Oomph technology</a> Eike Stepper and I have been working on to help ease the installation and configuration of development IDEs.
I am deeply honored to have received Eclipse's <a href="http://www.eclipse.org/org/press-release/20120326_awardwinners.php" target="_blank">Lifetime Contribution Award</a> in 2012.
I feel my track record as an Eclipse committer since 2002 is demonstrated with deeds not merely with words.
I focus on being a positive influence and on balancing the drive to fix problems and to make improvements 
with recognition of the fact that real problems are difficult to solve and that what constitutes improvement is often highly subjective.
</p>

<p>
I will continue to work hard to ensure that Eclipse's processes are the best they can be and are ever improving.
I believe in minimal processes that focus on best practices and achievable, pragmatic results. 
I can be counted upon as the person who will speak up diplomatically even when personal risk is involved.
As your representative, I commit to working tirelessly to promote not only Eclipse itself but also the community that drives it.
It has been an honor and a privilege to serve as your representative these past years. 
If reelected, you can count on the fact that Merks works for you.
</p>
]]> </vision>

	<bio> <![CDATA[
		Ed Merks founded his own small consulting company, <a href="http://www.macromodeling.com/" target="_blank">Macro Modeling</a>. He 
		is a coauthor of the authoritative book "<a href="http://www.informit.com/store/product.aspx?isbn=9780321331885" 
		target="_blank">EMF: Eclipse Modeling Framework</a>" which is published as a second expanded edition. He has been 
		an elected member of the <a href="http://www.eclipse.org/org/foundation/directors.php" target="_blank">Eclipse Foundation 
		Board of Directors</a> for the past ten years and has been recognized by the Eclipse Community Awards as 
		Top New Comer Evangelist, Top Ambassador, and Top Committer, as well as for Lifetime Achievement. Ed is well known for his dedication to the 
		Eclipse community since 2002, having posted more than 28,000 forum answers. He spent 16 years at IBM, 
		achieving the level of Senior Technical Staff Member after completing his Ph.D. at Simon Fraser University. He is a 
		partner of <a href="http://www.itemis.com/" target="_blank">itemis AG</a> and is currently living in Berlin and has learned to speak German. His 
		experience in modeling technology spans thirty years.
	]]> </bio>

	<affiliation> <![CDATA[ 
		<a href="http://www.macromodeling.com/" target="_blank">Macro Modeling</a>, President<br>
		<a href="http://www.itemis.com/" target="_blank">itemis AG</a>, Partner
	]]>
	</affiliation>
		
</boardmember>