<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 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 commercialization aspects of Eclipse since the outset in 2001. For the past year I have been your representative on the Eclipse Board of directors, previously served as committer representative, lead the now top-level Mylyn project, and am currently serving on the Architecture 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 year 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.</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 year, and I hope to continue representing you and helping you make the most out of your investment and engagement in Eclipse in 2011.</p>
	]]></vision>

	<bio><![CDATA[
		<p>Dr. Mik Kersten is the CEO of Tasktop Technologies and lead of the Eclipse Mylyn project. Mik is a popular speaker on Eclipse at conferences in the United States, Germany, and worldwide.  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>