<?php  																														require_once($_SERVER['DOCUMENT_ROOT'] . "/eclipse.org-common/system/app.class.php");	require_once($_SERVER['DOCUMENT_ROOT'] . "/eclipse.org-common/system/nav.class.php"); 	require_once($_SERVER['DOCUMENT_ROOT'] . "/eclipse.org-common/system/menu.class.php"); 	$App 	= new App();	$Nav	= new Nav();	$Menu 	= new Menu();		include($App->getProjectCommon());    # All on the same line to unclutter the user's desktop'

$pageTitle 		= "Technology Project Leaders";
$pageKeywords	= "technology";
$pageAuthor		= "Bjorn Freeman-Benson Nov 20/05";

ob_start();
?>

<div id="maincontent">
<div id="midcolumn">
<h1><?= $pageTitle ?></h1>

<p>The Eclipse Technology Project is managed by a small group known as
the Eclipse Technology Project Management Committee (<a
	href="technology-charter.html#PMC">PMC</a>). The PMC holds weekly
conference calls (see <a href="pmc-minutes.php">the minutes</a>) and
holds (some) discussions on <a href="mailto:technology-pmc@eclipse.org">technology-pmc@eclipse.org</a>
mailing list. The work of the Project is organized into subprojects.
Each subproject has a leader who has overall responsibility for its
success. Large subprojects are further divided into component teams,
each of who has a leader that is responsible for its overall success. We
have listed just the PMC <!-- and 
        subproject leaders 
        --> here but you will encounter many dedicated eclipse project
committers and developers in the <a href="/newsgroups/" target="_top">newsgroups</a>
and <a href="/mail/" target="_top">mailing lists</a>.</p>

<h2>Project Management Committee</h2>

<style type="text/css">
	.member {
		min-height: 150px;
	}
</style>

<div class="member">
<h3>Wayne &quot;Mad Dog&quot; Beaton, Eclipse Foundation (PMC lead)</h3>
<img src="images/wayne.jpg" align="left" />
<p>Wayne is the Evangelist for the Eclipse Foundation. His primary role
is that of informing people of all the exciting things that are
happening in the many Eclipse Projects. He is particularly fond of
test-first development and Extreme Programming, but is quite happy with
many lightweight development methodologies. In past lives, he has worked
for The Object People, BEA, and IBM. In his
&lt;sarcasm&gt;copious&lt;/sarcasm&gt; spare time Wayne spends time
driving his kids to hockey practice and studying martial arts.</p>
</div>

<div class="member">
<h3>John Duimovich, IBM</h3>
John Duimovich, IBM distinguished engineer, has been the lead designer
and implementor for OTI/IBM&#146;s virtual machine technology for the
past ten years. He has designed virtual machines for a wide range of
platforms, from the implementations for embedded and real time systems
to those for IBM mainframe systems. John has played a key role in the
development of ENVY/Smalltalk, VA/Micro Edition, and VA/Java Java IDEs.
In addition to serving on the Eclipse Technology PMC, John serves as the
lead of the Eclipse Tools PMC.</p>
</div>

<div class="member">
<h3>Gunnar Wagenknecht, AGETO</h3>
<img src="images/gunnar.jpg" align="left" />
<p>Gunnar is a software engineer who loves server and application
architectures especially those involving Equinox. In his primary role at
AGETO he is thrilled to work on open source software, emerging platforms
and technologies, and to help software companies understand Eclipse and
Equinox and execute on their business objectives in an open source
context. He has been a member of the Eclipse Community since its
beginning. He loves chatting about Eclipse, fishing, diving and his
family and other things that matters over a good beer or a glass of dry,
barrel aged red wine. Gunnar represents the Technology PMC on the <a
	href="http://wiki.eclipse.org/Architecture_Council">Eclipse
Architecture Council</a>.</p>
</div>

<div class="member">
<h3>Chris &quot;Iron Fist&quot; Aniszczyk, Code 9</h3>
<img src="images/chris.jpg" align="left" />
<p>Chris is Principal Consultant at Code 9 and the fearless technical
lead for the Eclipse <a href="http://www.eclipse.org/pde/">Plug-in
Development Environment</a> (PDE) project. Chris tends to be all over
the place inside the Eclipse community by committing on various Eclipse
projects. He sits on the Eclipse Architecture Council and the Eclipse
Foundation Board of Directors. Chris' passions are <a
	href="http://mea-bloga.blogspot.com/">blogging,</a>, software advocacy,
tooling and anything Eclipse. He's always available to discuss
open-source or Eclipse over a frosty beverage.</p>
</div>

<div class="member">
<h3>Konstantin Komissarchik</h3>
<img src="/org/elections/2008/komissarchik.jpg" align="left" />
<p>Konstantin is a Consulting Member of the Technical Staff at Oracle. He has been a 
committer on the Web Tools Platform since before its first release. He has designed 
and implemented the Faceted Project Framework which made it possible for people 
to easily extend capabilities of WTP projects. In his prior life, he has worked on 
compilers, custom servers and network protocol design. He graduated from the 
University of Washington with BS in Computer Science.</p>
</div>

</div>
</div>
<?php
# Paste your HTML content between the EOHTML markers!
$html = ob_get_contents();
ob_end_clean();

# Generate the web page
$App->generatePage($theme, $Menu, $Nav, $pageAuthor, $pageKeywords, $pageTitle, $html);
?>
