<boardmember id="kamutzki" type="addin">

<name>Hans Kamutzki</name>
<title> <![CDATA[
Managing Director,<br>
MicroDoc
 ]]> </title>
<image>kamutzki.jpg</image>
<email>hka@microdoc.com</email>

<eclipse_affiliation> <![CDATA[
MicroDoc has been an Eclipse add-in member for many years and Eclipse is a core element of MicroDoc's company strategy. 
MicroDoc has donated "Java Bindings for OpenVG", a vector grafics library for mobile devices, to the eRCP project.
Hans currently serves his third term as a Sustaining Member Representative on the Board of Directors of the Eclipse Foundation, is a member of the Eclipse Finance Commitee and has recently been elected to be a member of the IP Advisory Board.
 ]]> </eclipse_affiliation>

<vision> <![CDATA[
<p>
Eclipse is evolving as an eco system since its very beginning. Soon after we started using Eclipse as an IDE, runtime 
components were introduced. Now Eclipse opens up to non-Java technologies and Industry Working Groups focusing on 
vertical developments. I see Eclipse developing into kind of a "meta-foundation" - a sound and proven organisational structure and 
legal framework to host open source initiatives of all kinds. And as a main differentiator from other forges and foundations, Eclipse 
needs to maintain its valuable IP-process and that will ensure that commercial use of Eclipse open source components is widely accepted in 
the industry &ndash; even in mission critical runtime scenarios. </p>
<p>
I want to see a member driven initiative to make sure the traditional core technology of the Eclipse IDE is kept alive and is reasonably modernized and I will support any and all reasonable approaches to make this happen. I'm also in favor of reviewing the Eclipse infrastructure and move it into the cloud where ever that is cost effective and improves the service level for Eclipse users.
</p>
<p>
I want to continue to work on my fifth term on the Board with all members to maintain Eclipse as a safe source for commercial OSS offerings and build up a center of gravity for open source innovation 
</p>


]]></vision>

<bio><![CDATA[
Hans Kamutzki is co-founder and Managing Director of MicroDoc, Munich. 
He studied Physics and Computer Science in Bonn and Munich, Germany and focused on realtime image processing and 
process control in the early days of his professional work. For a "device and algorithm for the automatic detection of 
objects" he was co-awarded a German and European patent. After many years of development and project management practice in 
Smalltalk and Java, Hans now runs the Embedded Java operations at MicroDoc. 
]]></bio>

<affiliation><![CDATA[ 
MicroDoc is a software consultancy and product development business founded in 1991 by Hendrik Hoefer and 
Hans Kamutzki. In the 90s, MicroDoc's focus was on object oriented programming with Smalltalk. Hans Kamutzki 
was a main contributor to a MicroDoc product called "Objects for Notes", a technical Smalltalk to Lotus Notes gateway 
that was licensed to IBM in 1995. He worked as a technical and operational liaison between MicroDoc and IBM and spent 
several months with integration work in the RTP labs in Raleigh, NC and on other lab engagements. Even before 
Java became mainstream, MicroDoc invested in this technology and provided a number of product components to 
the international market of reusable components. Among these products are Java based persistence frameworks, 
an EJB persistency container and a variety of migration and quality assurance tools as well as some contributions 
to IBM's VisualAge for Java product. MicroDoc's work with Eclipse started in 2002 with an IDE migration project for a 
large airline. Eclipse has become a universal tool within MicroDoc since then. Eclipse is used as a development platform, 
but also heavily as a runtime environment for RCP and eRCP clients and server applications. As MicroDoc is building end to 
end solutions (starting on the mainframe and scaling down to mobile and embedded devices), the Eclipse RCP/eRCP platforms are 
essential building blocks for harmonizing the architecture in many MicroDoc projects today. As a Managing Directory, Hans is in 
charge for the embedded Java business as well as legal and contractual matters within MicroDoc today.
]]></affiliation>		
</boardmember>