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

	<name>Mik Kersten</name>

	<title> <![CDATA[CEO, Tasktop]]> </title>

	<image>kersten.jpg</image>
	
	<email>mik.kersten@tasktop.com</email>

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

	<vision> <![CDATA[
		<p>Eclipse has matured and cemented its role as a robust and stable platform for innovation.  As its Sustaining Members, we play a key role in driving the direction of Eclipse.  Our 
		contributions in the form of code, evangelism, as well as Eclipse-based products and services have made Eclipse the vibrant multi-vendor ecosystem that it is today.</p>

		<p>In joining Eclipse as one of the first non-IBM committers, I've been engaged with both the technology community and the commercialization aspects of Eclipse since the 
		outset in 2001. For the past three years I have been your representative on the Eclipse Board of directors, previously served as committer representative, lead the top-level Mylyn project, and servie on the and Planning Councils.</p>

		<p>I've worked directly with many Solution Member companies and watched some Eclipse business models flourish while others have failed. Starting a profitable company around Eclipse has given me a pragmatic perspective on how to participate in the platform while growing both product and service revenues on Eclipse-based offerings. For the past two years I served as your representative on the Eclipse board, and for this next year I plan on continuing to apply my experience and ongoing dialog with members in order to help make your Eclipse-based efforts successful.  Should I be elected, please do not hesitate to reach out to me as many others have done over the years, as it is my goal to assist you in making your Eclipse-based efforts successful.</p>

		<p>Succeeding in Eclipse means striking a balance between the member, committer and user communities.  As your board representative, my priorities will be to:</p>
			<ul>
				<li><b>Facilitate reaching users:</b> Marketing in a vendor-neutral open source ecosystem can be far from obvious, and reaching the very broad Eclipse user base is needed for both the commercial success of members and of Eclipse as a whole.  I have been closely involved in <a target="_blank" href="http://tasktop.com/blog/eclipse/growing-open-source-ecosystems-install">improving the install story</a> for Eclipse solutions and the upcoming <a target="_blank" href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=296131">Eclipse Marketplace</a> client.  These efforts will provide the next generation of opportunities to get your solution into Eclipse users' hands.</li>
				<li><b>Lower the barrier to engaging with projects:</b> With product releases and other pressures, too often the step of getting directly involved with an Eclipse project that you build on does not make the cost/benefit cut.  But not getting involved has the longer-term cost of incompatibilities and overhead.  Lowering the bar for direct participation will provide members with better access to the collaboration and contributor community that make Eclipse a great open source ecosystem.  On the Mylyn project we have had over 900 bugs and feature requests resolved by community contributions.  I will use my experience of making this work for Mylyn to help lower the overhead of participation with existing projects so that similar benefits are accessible to more members.</li>
				<li><b>Listen to members:</b> My job will be to represent your needs on the board, and I will work with the other representatives to actively seek out feedback from all Solution Members.  I helped make the needs of individual committers heard as a committer representative on the Eclipse board, and will ensure that your needs are represented in discussions and decisions made at the board level.</li>
			</ul>
		
		<p>We made good progress on these priorities in the past thre years, and I hope to continue representing you and helping you make the most out of your investment and engagement in Eclipse in 2013.</p>
	]]></vision>

	<bio><![CDATA[
		<p>Dr. Mik Kersten is the Co-founder and CEO of Tasktop , creator of the Eclipse Mylyn open source project and inventor of the task-focused interface. As a research scientist at Xerox PARC, Mik implemented the first aspect-oriented programming tools for AspectJ. He created Mylyn and the task-focused interface during his PhD in Computer Science at the University of British Columbia. Mik has been an Eclipse committer since 2002, is an elected member of the Eclipse Board of Directors and serves on the Eclipse Planning Council. Mik's thought leadership on task-focused collaboration makes him a popular speaker at software conferences.  He enjoys building tools that offload our brains and make it easier to get creative work done. Follow @mik_kersten on Twitter.</p> 
<p>As a long-time Eclipse evangelist, Mik is a frequent source for media and analysts on matters related to Eclipse and developer tools.  Highlights of Mik's contributions to Eclipse include:</p>
		<ul>
			<li>Creator and lead of the Eclipse Mylyn top-level project (since 2005)</li>
			<li>Active member of the Eclipse Architecture Council (since 2007)</li> 
			<li>Member of the Eclipse Planning Council (since 2010)</li>
			<li>Elected committer representative on the Eclipse Board of Directors in (2008/2009)</li>
			<li>Only Eclipse evangelist to be voted a <a href="http://java.sun.com/javaone/2009/articles/rockstar_kersten.jsp">JavaOne Rock Star</a> (2008 and 2009)</li>
			<li>Only Eclipse content author on the <a target="_blank" href="http://www.ibm.com/developerworks/java/library/j-topjava.html?S_TACT=105AGX54&S_CMP=C1001&ca=dnw-1037&ca=dth-j&open&cm_mmc=6046-_-n-_-vrm_newsletter-_-10731_132372&cmibm_em=dm:0:13623213">top authors of the decade</a> list of IBM developerWorks Java</li>
			<li>PhD in Computer Science from the University of British Columbia that lead to the invention of Mylyn's <a href="http://en.wikipedia.org/wiki/Task-focused_interface">task-focused interface</a> (2006)</li>
			<li>Co-creator of the Eclipse AspectJ and AJDT projects (2002) based on his work creating of the first Aspect-Oriented Programming (AOP) tools, Xerox PARC (2000)</li>
		</ul>
		<p>Related publications:</p>
		<ul>
			<li><a target="_blank" href="http://blog.symbian.org/2010/01/14/mik-kersten-on-transparency/">Symbian Blog: Mik Kersten on Transparency</a></li>
			<li><a target="_blank" href="http://tasktop.com/blog/eclipse/growing-open-source-ecosystems-install">Tasktop Blog: Growing open source ecosystems: the install story</a></li>
			<li><a target=_blank" href="http://tasktop.com/blog/eclipse/tasktop-working-with-microsoft-to-improve-eclipse-on-windows-7">Tasktop Blog: Tasktop working with Microsoft to improve Eclipse on Windows 7</a></li>
			<li><a target="_blank" href="http://howsoftwareisbuilt.com/2008/09/26/interview-with-mik-kersten-president-cto-tasktop-technologies-member-eclipse-board-of-directors/">How Software is Built: Interview with Mik Kersten</a> (highest ranked in series)</li>
			<li><a target="_blank" href="http://tasktop.com/blog/eclipse/tips-on-paying-for-free-software">Tasktop Blog: Tips on paying for free software</a></li>
			<li><a target="_blank" href="http://tasktop.com/blog/uncategorized/platform-for-innovation-part-1-openness-modularity">Tasktop Blog: Platform for Innovation, Part 1: Openness & Modularity</a></li>
		</ul>
		<p>Read more about <a target="_blank" href="http://en.wikipedia.org/wiki/Mik_Kersten">Mik Kersten on Wikipedia</a>.</p>
	]]></bio>

	<affiliation><![CDATA[ 
		<a target="_blank" href="http://tasktop.com">Tasktop Technologies</a> and <a target="_blank" href="http://eclipse.org/mylyn">Eclipse Mylyn</a>
	]]></affiliation>
			
</boardmember>