diff --git a/content/en_index.php b/content/en_index.php
index ce2d769..07d0c70 100644
--- a/content/en_index.php
+++ b/content/en_index.php
@@ -33,7 +33,7 @@
                 <li>To learn how the bug-fixing process works, check out the <a href="http://wiki.eclipse.org/Bug_Reporting_FAQ">bug reporting FAQ</a>.</li>
                 <li>To learn about the lifecycle of bugzilla entries, check out the <a href="http://wiki.eclipse.org/Development_Resources/HOWTO/Bugzilla_Use">development process</a>.</li>
               </ul>
-              <li><i class="fa fa-li fa-chevron-circle-right orange"></i> Participate in our <a href="dev_program.php">Friends-Enabled Eclipse IDE/Platform Enhancements Program</a>
+              <li><i class="fa fa-li fa-chevron-circle-right orange"></i> Participate in our <a href="dev_program.php">Friend of Eclipse Enhancements Program</a>
               either as a funded developer, or by making a <a href="/donate/">donation</a>.</li>
               <li><i class="fa fa-li fa-chevron-circle-right orange"></i> <a href="https://wiki.eclipse.org/Learn_About_Eclipse">Learn about Eclipse</a>.</li>
               <li>Browse our <a href="https://git.eclipse.org/c/">source code repositories</a>.</li>
diff --git a/dev_program.php b/dev_program.php
index 12d26b4..4f1fd2f 100644
--- a/dev_program.php
+++ b/dev_program.php
@@ -1,334 +1,334 @@
-<?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'
-
-	#*****************************************************************************
-	#
-	# sample_3col.php
-	#
-	# Author: 		Mike Milinkovich
-	# Date:			2015-09-22
-	#
-	# Description: Document the Friends-Enabled Eclipse IDE/Platform Enhancements 
-	#              Program (FEEP)
-	#
-	#
-	#****************************************************************************
-	
-	#
-	# Begin: page-specific settings.  Change these. 
-	$pageTitle 		= "Friends-Enabled Eclipse IDE/Platform Enhancements Program (FEEP)";
-	$pageKeywords	= "eclipse, foundation, development, platform, funding";
-	$pageAuthor		= "Mike Milinkovich, September 22, 2015";
-	
-
-	include (dirname(__FILE__) . '/dev_program/_projectCommon.php');
-	
-	# Add page-specific Nav bars here
-	# Format is Link text, link URL (can be http://www.someothersite.com/), target (_self, _blank), level (1, 2 or 3)
-	# $Nav->addNavSeparator("My Page Links", 	"downloads.php");
-	# $Nav->addCustomNav("My Link", "mypage.php", "_self", 1);
-	# $Nav->addCustomNav("Google", "http://www.google.com/", "_blank", 1);
-
-	# End: page-specific settings
-	#
-		
-	# Paste your HTML content between the EOHTML markers!	
-	$html = <<<EOHTML
-
-	<div id="midcolumn">
-		<h1>$pageTitle</h1>
-
-		<small><b>Draft</b> v05 - September 17th, 2015</small>
-		 
-		<h2>Program Objective:</h2>
-		<p>The Friends-Enabled Eclipse IDE/Platform Enhancements Program, or FEEP, utilizes the funds donated 
-			through the Friends of Eclipse program to make significant and meaningful improvements and enhancements 
-			to the Eclipse IDE/Platform.</p>
-		 
-		<h2>Program Summary:</h2>
-		<p>The Eclipse Foundation (EF) is committed to directing the funds donated through the Friends of 
-			Eclipse initiative directly to making improvements to the Eclipse IDE/Platform.</p>
-		 
-		<p>	EF will engage with key stakeholders in the community to determine the highest priority issues to be 
-			addressed, convert these priorities into actionable development tasks, and then engage with qualified 
-			resources to carry out these tasks. </p>
-		 
-		<p>The guiding principles of the process are:</p>
-		<ul>
-			<li>To adhere to the principle of transparency and openness. </li>
-			<li>To complement the existing development efforts already underway. </li>
-			<li>To encourage a “multiplying effect” where community participation is amplified by this funding program’s undertakings.</li>
-		</ul>
-		 
-		<p>Development will be carried out in an on-going series of Development Cycles, which are described below. </p>
-		 
-		<p>The effectiveness of the Program is dependent on the funds available. The expectation is for contributions to 
-			continue to grow, especially once positive results are demonstrated.</p>
-		 
-		<blockquote>NOTE: FEEP utilizes the funds donated exclusively through the Friends of Eclipse program.  
-			EF also accepts corporate donations, including directed donations.  In the case of directed donations, 
-			a corporation may request their donation be directed to priorities identified by them.  EF will ensure 
-			these donations are used for these exclusive purposes, regardless of whether these corporate priorities 
-			differ from the priorities identified by FEEP.  However, EF is motivated to ensure the impact of the 
-			donations through both sources collectively, regardless of corporate or individual donations, leads 
-			to the maximum positive impact. 
-		</blockquote>
-			
-		<h2>Program Governance:</h2>
-		<p>FEEP will be managed exclusively by the Eclipse Foundation.  The EF commits to a full disclosure of the 
-			expenditures made related to this program, as well as disclosure of the priorities established for selecting 
-			development efforts. </p>
-		 
-		<p>The Eclipse Management Organization (EMO) will designate a FEEP Program Manager (“FEEP PM”) to manage the various tasks and processes on its behalf.  
-			Initially, it is expected the role of FEEP PM will be played by one of EF’s staff member, though this may 
-			change over time. </p>
-		 
-		<p>As the Program grows, EF may decide to create an IDE/Platform Working Group.  This would be done primarily 
-			to broaden governance responsibilities to interested Members, and would establish committees to, for example, 
-			oversee budgets, contribute corporate funding directly to the program, expand the prioritization process, 
-			work more closely with contractors, etc.</p>
-		 
-		<h2>Budget:</h2>
-		<p>The amount of funds available for development will vary, depending on the amount of donations received through 
-			the Friends of Eclipse initiative. </p>
-		 
-		<p>Initially, EF will collect the funds received over the previous half year, and then use this amount for the 
-			development efforts identified for the upcoming quarter.  For example, if we receive $75,000 in contributions 
-			in Q3, we will apply $75,000 to the development efforts in Q4.  EF may change this to a more or less frequent 
-			process, depending on the experience gained. </p>
-		 
-		<p>As background, in 2014 the amount donated through the Friends of Eclipse totaled $120,000.</p>
-		
-		<h2>Expected Areas of Focus:</h2>
-		<p>Initially, the primary areas of focus to be addressed by this Program are:</p>
-		<ul>
-			<li>Resolve deep technical issues that are outstanding and not being addressed by the community otherwise.</li>
-			<li>Accelerate work on areas deemed critical by key stakeholders, including the Architecture Council, relevant 
-				PMCs and others, to aid in keeping the Eclipse IDE state of the art. “Accelerate work” can take on many forms, 
-				from directly funding development to reviewing inbound community contributions.</li>
-			<li>Make improvements to the IDE that make adoption within the community simpler and broader.</li>
-			<li>Improve the tools, processes, etc. related to directly improving the IDE.</li>
-		</ul>
-		 
-		<p>EF reserves the right, through its governance role, to modify these areas of focus. </p>
-		 
-		<h2>FEEP Cycles:</h2>
-		<p>To create a process that is easier to track, budget for, and measure success, development will be done through 
-			a series of FEEP Cycles.</p>
-		 
-		<p>At a glance, each FEEP Cycle involves a 5 step process:</p>
-		 
-		<table cellpadding="2" cellspacing="2">
-			<col width="425">
-			<col width="169">
-			<tr>
-				<td style="border-top: 1px solid #000000; border-bottom: 2.25pt solid #000000; border-left: 1px solid #000000; border-right: 1px solid #000000; padding: 0.19cm">
-					<p align="center" style="font-variant: normal; font-style: normal; text-decoration: none">
-					<font color="#000000"><font face="Arial"><font size="2" style="font-size: 10pt"><b><span style="background: transparent">EF
-					FEEP Cycle Activity</span></b></font></font></font></p>
-				</td>
-				<td style="border-top: 1px solid #000000; border-bottom: 2.25pt solid #000000; border-left: 1px solid #000000; border-right: 1px solid #000000; padding: 0.19cm">
-					<p align="center" style="font-variant: normal; font-style: normal; text-decoration: none">
-					<font color="#000000"><font face="Arial"><font size="2" style="font-size: 10pt"><b><span style="background: transparent">Estimated
-					Time Period</span></b></font></font></font></p>
-				</td>
-			</tr>
-			<tr>
-				<td bgcolor="#c0c0c0" style="border-top: 2.25pt solid #000000; border-bottom: 1px solid #000000; border-left: 1px solid #000000; border-right: 1px solid #000000; padding: 0.19cm">
-					<p align="center" style="font-variant: normal; font-style: normal; font-weight: normal; text-decoration: none">
-					<font color="#000000"><font face="Arial"><font size="2" style="font-size: 10pt"><span style="background: #c0c0c0">Collect
-					Input on Priorities</span></font></font></font></p>
-				</td>
-				<td bgcolor="#c0c0c0" style="border-top: 2.25pt solid #000000; border-bottom: 1px solid #000000; border-left: 1px solid #000000; border-right: 1px solid #000000; padding: 0.19cm">
-					<p align="center" style="font-variant: normal; font-style: normal; font-weight: normal; text-decoration: none">
-					<font color="#000000"><font face="Arial"><font size="2" style="font-size: 10pt"><span style="background: #c0c0c0">Weeks
-					1-2</span></font></font></font></p>
-				</td>
-			</tr>
-			<tr>
-				<td style="border: 1px solid #000000; padding: 0.19cm">
-					<p align="center" style="font-variant: normal; font-style: normal; font-weight: normal; text-decoration: none">
-					<font color="#000000"><font face="Arial"><font size="2" style="font-size: 10pt"><span style="background: transparent">Establish
-					Budget and Select Approved Development Efforts</span></font></font></font></p>
-				</td>
-				<td style="border: 1px solid #000000; padding: 0.19cm">
-					<p align="center" style="font-variant: normal; font-style: normal; font-weight: normal; text-decoration: none">
-					<font color="#000000"><font face="Arial"><font size="2" style="font-size: 10pt"><span style="background: transparent">Week
-					2-3</span></font></font></font></p>
-				</td>
-			</tr>
-			<tr>
-				<td bgcolor="#c0c0c0" style="border: 1px solid #000000; padding: 0.19cm">
-					<p align="center" style="font-variant: normal; font-style: normal; font-weight: normal; text-decoration: none">
-					<font color="#000000"><font face="Arial"><font size="2" style="font-size: 10pt"><span style="background: #c0c0c0">Solicit
-					Bids For Development Efforts</span></font></font></font></p>
-				</td>
-				<td bgcolor="#c0c0c0" style="border: 1px solid #000000; padding: 0.19cm">
-					<p align="center" style="font-variant: normal; font-style: normal; font-weight: normal; text-decoration: none">
-					<font color="#000000"><font face="Arial"><font size="2" style="font-size: 10pt"><span style="background: #c0c0c0">Week
-					3-4</span></font></font></font></p>
-				</td>
-			</tr>
-			<tr>
-				<td style="border: 1px solid #000000; padding: 0.19cm">
-					<p align="center" style="font-variant: normal; font-style: normal; font-weight: normal; text-decoration: none">
-					<font color="#000000"><font face="Arial"><font size="2" style="font-size: 10pt"><span style="background: transparent">Award
-					Contracts For Development Efforts</span></font></font></font></p>
-				</td>
-				<td style="border: 1px solid #000000; padding: 0.19cm">
-					<p align="center" style="font-variant: normal; font-style: normal; font-weight: normal; text-decoration: none">
-					<font color="#000000"><font face="Arial"><font size="2" style="font-size: 10pt"><span style="background: transparent">Week
-					5</span></font></font></font></p>
-				</td>
-			</tr>
-			<tr>
-				<td bgcolor="#c0c0c0" style="border: 1px solid #000000; padding: 0.19cm">
-					<p align="center" style="font-variant: normal; font-style: normal; font-weight: normal; text-decoration: none">
-					<font color="#000000"><font face="Arial"><font size="2" style="font-size: 10pt"><span style="background: #c0c0c0">Sign-Off
-					On Completed Development Efforts</span></font></font></font></p>
-				</td>
-				<td bgcolor="#c0c0c0" style="border: 1px solid #000000; padding: 0.19cm">
-					<p align="center"><span style="font-variant: normal"><font color="#000000"><span style="text-decoration: none"><font face="Arial"><font size="2" style="font-size: 10pt"><span style="font-style: normal"><span style="font-weight: normal"><span style="background: #c0c0c0">Week
-					13</span></span></span></font></font></span></font></span><span style="font-variant: normal"><font color="#000000"><span style="text-decoration: none"><font face="Cambria"><font size="3" style="font-size: 12pt"><span style="font-style: normal"><span style="font-weight: normal"><span style="background: #c0c0c0">[1]</span></span></span></font></font></span></font></span></p>
-				</td>
-			</tr>
-		</table>
-
-		 
-		<br/><p>Each step in the FEEP Cycle process is described below.</p>
-		 
-		<p>It is expected that FEEP Cycles will be done initially on 
-			a semi-annual basis, though the EF may change the frequency at its sole discretion. </p>
-		 
-		<h3>1. Collect Input on Priorities</h3>
-		 
-		<p>The FEEP-PM will gather input from interested parties, including:</p>
-		<ul>
-			<li>Respective PMC’s</li>
-			<li>Member corporations that have donated funds with specific requests for development.</li>
-			<li>The Eclipse Management Organization (EMO), which includes</li>
-			<ul>
-				<li>Architecture Council</li>
-				<li>Planning Council</li>
-				<li>Foundation staff</li>
-			</ul>
-		</ul>
-
-		<p>From this input and interaction, the FEEP-PM will produce a collection of Development Efforts. </p>
-		 
-		<p>The description of each Development Effort is expected to include, as a minimum:  </p>
-		<ul>
-			<li>task name and Bugzilla id,</li>
-			<li>time estimate,</li>
-			<li>cost estimate,</li>
-			<li>expected deliverable(s)/outcome(s),</li>
-			<li>anticipated dependencies,</li>
-			<li>means of demonstration and/or verification of completion.</li>
-		</ul>
-		 
-		<p>The FEEP-PM is likely to engage with potential contractors at this stage to seek their input on the 
-			Development Efforts to enable him/her to provide better estimates.  This input from potential contractors 
-			will be provided based strictly on a non-committal basis by both sides, and is used for informational 
-			purposes only.  No funding will be provided to potential contractors for this input.  </p>
-		 
-		<h3>2. Establish Budget and Select Approved Development Efforts</h3>
-		 
-		<p>The FEEP-PM will create a draft budget identifying which of the Development Efforts identified will 
-			go to contract.  This draft budget will be based on the funds available through donation, as well as the 
-			relative priorities established.</p>
-		 
-		<p>The EMO will review both the budget and list of prioritized Development Efforts, and will generate a list of 
-			Approved Development Efforts. </p>
-		 
-		<blockquote>Note: Any budgeted development funds that are not allocated for development, or any funds not released due 
-			to non-completion of a development effort, will be added to the funds available for the next Development Cycle.
-		</blockquote>
-		 
-		<p>Before soliciting bids for the Approved Development Efforts, the FEEP-PM will review with the affected project or 
-			PMC the Approved Development Efforts targeted in their project. The project or PMC must commit their support to 
-			the proposed work, including naming the project committer(s) that will review, and commit the work if the 
-			contractor isn't a committer on that project.</p>
-			
-		<h3>3. Solicit Bids for Approved Development Efforts</h3>
-		 
-		<p>The FEEP-PM will post the Approved Development Efforts to the EF website.  During the open bidding period, expected 
-			to be approximately 2 weeks, potential contractors may interact with the FEEP-PM to seek additional information 
-			regarding the development efforts.</p>
-		 
-		<p>Interested contractors may submit confidential bids for any or all of the Approved Development Efforts. </p>
-		 
-		<blockquote>Note: EMO reserves the right to solicit bids from specific Committers and/or contractors should it feel particular expertise or experience is required to be successful.  The EMO is not obliged to disclose that it has chosen to carry out this solicitation.</blockquote>
-		 
-		<p>In each bid, the contractor must identify, as a minimum:</p>
-		<ul>
-			<li>Description of the approa	ch to address the Development Effort.</li>
-			<li>Identification of who will perform the work (i.e., named developers).</li>
-			<li>The proposed timeframe for the development effort.</li>
-			<li>Any dependencies/caveats that exist that must be addressed.</li>
-			<li>Proposed outcome for the work, including how to demonstrate the work has been completed.</li>
-			<li>Explicit list of deliverables, including any interim deliverables.</li>
-			<li>A proposed price, including whether the bid is being made on a fixed price or time and materials 
-				basis, and whether any interim milestones and associated and/or interim payments are proposed. </li>
-		</ul>
-		 
-		<p>All bids should indicate any taxes to be charged in addition to the costs identified.  It is expected that no 
-			expenses shall be incurred as part of any bid, though exceptions may be proposed by contractors.  These exceptions 
-			must be clearly identified, and contractors may only bill for such expenses if agreed to in writing by the 
-			FEEP-PM as part of the contract for the Approved Development Effort, and if the expense is actually incurred.  </p>
-		 
-		<p>All bids submitted will be treated as confidential by EF.  However, all contractors must agree to EF posting the 
-			name and value of each contracted Development Effort.</p>
-		 
-		<h3>4. Award Contracts For Successful Bids</h3>
-		
-		<p>The FEEP-PM will work with others within the EMO to evaluate the submitted bids.  Winning bids will be selected 
-		upon the following criteria:</p>
-		<ul>
-			<li>Price</li>
-			<li>Quality of proposed development and deliverables</li>
-			<li>Skillset of proposed developers, with preference given to Committers in the relevant area.</li>
-			<li>Bidder’s relationship with EF, with preference given to either Solution Members with Committers, 
-				or self-employed Committers with relevant expertise</li>
-			<li>Any additional relevant elements in the bid, including delivery date, whether fixed price vs. 
-				time and materials basis, etc. </li> 
-		</ul>
-		 
-		<p>EMO may decide, at its sole discretion, not to let a contract for any particular Approved Development Effort, 
-			even if acceptable bids have been submitted.</p>
-		 
-		<p>Contractors will be expected to execute a Statement of Work (SOW) for each winning bid.  Each SOW will be created 
-			against the standing Professional Services Agreement with the contractor, which must have been previously executed 
-			by the contractor. </p>
-		 
-		<p>Following the execution of each SOW, EMO will publish the name of the winning contractor and the total contract value.</p>
-		 
-		<h3>5. Sign-Off on Completed Development Efforts</h3>
-		 
-		<p>For each Development Effort, the contractor is expected to provide:
-		<ul>
-			<li>Source code. In most cases, it will be expected that the acceptance criteria for code is that it has been 
-				committed by the Eclipse project. Other scenarios may be possible in exceptional circumstances.</li>
-			<li>Test harness(es) for code</li>
-			<li>Documentation, including appropriate documentation related to IP</li>
-			<li>Any other appropriate deliverables, including those to which the contractor committed in the original bid.</li>
-		</ul>
-		 
-		<p>Unless explicitly agreed to otherwise, payment will only be made at the completion of the Development Effort, 
-		and once the FEEP-PM has signed-off on the deliverables.  The FEEP-PM may seek assistance and opinions from the 
-		relevant interested parties to evaluate the completeness of the deliverables.</p>
-		 
-		<p>Sign-off by FEEP-PM on a submitted completed Development Effort is expected to take up to 14 days. </p>
-		
-		
-		<small>[1] Completion dates may vary, depending on the individual development efforts. </small>
-		
-
-
-
-	</div>
-
-EOHTML;
-
-
-	# Generate the web page
-	$App->generatePage($theme, $Menu, $Nav, $pageAuthor, $pageKeywords, $pageTitle, $html);
-?>
+<?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'
+
+	#*****************************************************************************
+	#
+	# sample_3col.php
+	#
+	# Author: 		Mike Milinkovich
+	# Date:			2015-09-22
+	#
+	# Description: Document the Friend of Eclipse Enhancement 
+	#              Program (FEEP)
+	#
+	#
+	#****************************************************************************
+	
+	#
+	# Begin: page-specific settings.  Change these. 
+	$pageTitle 		= "Friend of Eclipse Enhancement Program (FEEP)";
+	$pageKeywords	= "eclipse, foundation, development, platform, funding";
+	$pageAuthor		= "Mike Milinkovich, September 22, 2015";
+	
+
+	include (dirname(__FILE__) . '/dev_program/_projectCommon.php');
+	
+	# Add page-specific Nav bars here
+	# Format is Link text, link URL (can be http://www.someothersite.com/), target (_self, _blank), level (1, 2 or 3)
+	# $Nav->addNavSeparator("My Page Links", 	"downloads.php");
+	# $Nav->addCustomNav("My Link", "mypage.php", "_self", 1);
+	# $Nav->addCustomNav("Google", "http://www.google.com/", "_blank", 1);
+
+	# End: page-specific settings
+	#
+		
+	# Paste your HTML content between the EOHTML markers!	
+	$html = <<<EOHTML
+
+	<div id="midcolumn">
+		<h1>$pageTitle</h1>
+
+		<small><b>Draft</b> v05 - September 17th, 2015</small>
+		 
+		<h2>Program Objective:</h2>
+		<p>The Friend of Eclipse Enhancement Program, or FEEP, utilizes the funds donated 
+			through the Friends of Eclipse program to make significant and meaningful improvements and enhancements 
+			to the Eclipse IDE/Platform.</p>
+		 
+		<h2>Program Summary:</h2>
+		<p>The Eclipse Foundation (EF) is committed to directing the funds donated through the Friends of 
+			Eclipse initiative directly to making improvements to the Eclipse IDE/Platform.</p>
+		 
+		<p>	EF will engage with key stakeholders in the community to determine the highest priority issues to be 
+			addressed, convert these priorities into actionable development tasks, and then engage with qualified 
+			resources to carry out these tasks. </p>
+		 
+		<p>The guiding principles of the process are:</p>
+		<ul>
+			<li>To adhere to the principle of transparency and openness. </li>
+			<li>To complement the existing development efforts already underway. </li>
+			<li>To encourage a “multiplying effect” where community participation is amplified by this funding program’s undertakings.</li>
+		</ul>
+		 
+		<p>Development will be carried out in an on-going series of Development Cycles, which are described below. </p>
+		 
+		<p>The effectiveness of the Program is dependent on the funds available. The expectation is for contributions to 
+			continue to grow, especially once positive results are demonstrated.</p>
+		 
+		<blockquote>NOTE: FEEP utilizes the funds donated exclusively through the Friends of Eclipse program.  
+			EF also accepts corporate donations, including directed donations.  In the case of directed donations, 
+			a corporation may request their donation be directed to priorities identified by them.  EF will ensure 
+			these donations are used for these exclusive purposes, regardless of whether these corporate priorities 
+			differ from the priorities identified by FEEP.  However, EF is motivated to ensure the impact of the 
+			donations through both sources collectively, regardless of corporate or individual donations, leads 
+			to the maximum positive impact. 
+		</blockquote>
+			
+		<h2>Program Governance:</h2>
+		<p>FEEP will be managed exclusively by the Eclipse Foundation.  The EF commits to a full disclosure of the 
+			expenditures made related to this program, as well as disclosure of the priorities established for selecting 
+			development efforts. </p>
+		 
+		<p>The Eclipse Management Organization (EMO) will designate a FEEP Program Manager (“FEEP PM”) to manage the various tasks and processes on its behalf.  
+			Initially, it is expected the role of FEEP PM will be played by one of EF’s staff member, though this may 
+			change over time. </p>
+		 
+		<p>As the Program grows, EF may decide to create an IDE/Platform Working Group.  This would be done primarily 
+			to broaden governance responsibilities to interested Members, and would establish committees to, for example, 
+			oversee budgets, contribute corporate funding directly to the program, expand the prioritization process, 
+			work more closely with contractors, etc.</p>
+		 
+		<h2>Budget:</h2>
+		<p>The amount of funds available for development will vary, depending on the amount of donations received through 
+			the Friends of Eclipse initiative. </p>
+		 
+		<p>Initially, EF will collect the funds received over the previous half year, and then use this amount for the 
+			development efforts identified for the upcoming quarter.  For example, if we receive $75,000 in contributions 
+			in Q3, we will apply $75,000 to the development efforts in Q4.  EF may change this to a more or less frequent 
+			process, depending on the experience gained. </p>
+		 
+		<p>As background, in 2014 the amount donated through the Friends of Eclipse totaled $120,000.</p>
+		
+		<h2>Expected Areas of Focus:</h2>
+		<p>Initially, the primary areas of focus to be addressed by this Program are:</p>
+		<ul>
+			<li>Resolve deep technical issues that are outstanding and not being addressed by the community otherwise.</li>
+			<li>Accelerate work on areas deemed critical by key stakeholders, including the Architecture Council, relevant 
+				PMCs and others, to aid in keeping the Eclipse IDE state of the art. “Accelerate work” can take on many forms, 
+				from directly funding development to reviewing inbound community contributions.</li>
+			<li>Make improvements to the IDE that make adoption within the community simpler and broader.</li>
+			<li>Improve the tools, processes, etc. related to directly improving the IDE.</li>
+		</ul>
+		 
+		<p>EF reserves the right, through its governance role, to modify these areas of focus. </p>
+		 
+		<h2>FEEP Cycles:</h2>
+		<p>To create a process that is easier to track, budget for, and measure success, development will be done through 
+			a series of FEEP Cycles.</p>
+		 
+		<p>At a glance, each FEEP Cycle involves a 5 step process:</p>
+		 
+		<table cellpadding="2" cellspacing="2">
+			<col width="425">
+			<col width="169">
+			<tr>
+				<td style="border-top: 1px solid #000000; border-bottom: 2.25pt solid #000000; border-left: 1px solid #000000; border-right: 1px solid #000000; padding: 0.19cm">
+					<p align="center" style="font-variant: normal; font-style: normal; text-decoration: none">
+					<font color="#000000"><font face="Arial"><font size="2" style="font-size: 10pt"><b><span style="background: transparent">EF
+					FEEP Cycle Activity</span></b></font></font></font></p>
+				</td>
+				<td style="border-top: 1px solid #000000; border-bottom: 2.25pt solid #000000; border-left: 1px solid #000000; border-right: 1px solid #000000; padding: 0.19cm">
+					<p align="center" style="font-variant: normal; font-style: normal; text-decoration: none">
+					<font color="#000000"><font face="Arial"><font size="2" style="font-size: 10pt"><b><span style="background: transparent">Estimated
+					Time Period</span></b></font></font></font></p>
+				</td>
+			</tr>
+			<tr>
+				<td bgcolor="#c0c0c0" style="border-top: 2.25pt solid #000000; border-bottom: 1px solid #000000; border-left: 1px solid #000000; border-right: 1px solid #000000; padding: 0.19cm">
+					<p align="center" style="font-variant: normal; font-style: normal; font-weight: normal; text-decoration: none">
+					<font color="#000000"><font face="Arial"><font size="2" style="font-size: 10pt"><span style="background: #c0c0c0">Collect
+					Input on Priorities</span></font></font></font></p>
+				</td>
+				<td bgcolor="#c0c0c0" style="border-top: 2.25pt solid #000000; border-bottom: 1px solid #000000; border-left: 1px solid #000000; border-right: 1px solid #000000; padding: 0.19cm">
+					<p align="center" style="font-variant: normal; font-style: normal; font-weight: normal; text-decoration: none">
+					<font color="#000000"><font face="Arial"><font size="2" style="font-size: 10pt"><span style="background: #c0c0c0">Weeks
+					1-2</span></font></font></font></p>
+				</td>
+			</tr>
+			<tr>
+				<td style="border: 1px solid #000000; padding: 0.19cm">
+					<p align="center" style="font-variant: normal; font-style: normal; font-weight: normal; text-decoration: none">
+					<font color="#000000"><font face="Arial"><font size="2" style="font-size: 10pt"><span style="background: transparent">Establish
+					Budget and Select Approved Development Efforts</span></font></font></font></p>
+				</td>
+				<td style="border: 1px solid #000000; padding: 0.19cm">
+					<p align="center" style="font-variant: normal; font-style: normal; font-weight: normal; text-decoration: none">
+					<font color="#000000"><font face="Arial"><font size="2" style="font-size: 10pt"><span style="background: transparent">Week
+					2-3</span></font></font></font></p>
+				</td>
+			</tr>
+			<tr>
+				<td bgcolor="#c0c0c0" style="border: 1px solid #000000; padding: 0.19cm">
+					<p align="center" style="font-variant: normal; font-style: normal; font-weight: normal; text-decoration: none">
+					<font color="#000000"><font face="Arial"><font size="2" style="font-size: 10pt"><span style="background: #c0c0c0">Solicit
+					Bids For Development Efforts</span></font></font></font></p>
+				</td>
+				<td bgcolor="#c0c0c0" style="border: 1px solid #000000; padding: 0.19cm">
+					<p align="center" style="font-variant: normal; font-style: normal; font-weight: normal; text-decoration: none">
+					<font color="#000000"><font face="Arial"><font size="2" style="font-size: 10pt"><span style="background: #c0c0c0">Week
+					3-4</span></font></font></font></p>
+				</td>
+			</tr>
+			<tr>
+				<td style="border: 1px solid #000000; padding: 0.19cm">
+					<p align="center" style="font-variant: normal; font-style: normal; font-weight: normal; text-decoration: none">
+					<font color="#000000"><font face="Arial"><font size="2" style="font-size: 10pt"><span style="background: transparent">Award
+					Contracts For Development Efforts</span></font></font></font></p>
+				</td>
+				<td style="border: 1px solid #000000; padding: 0.19cm">
+					<p align="center" style="font-variant: normal; font-style: normal; font-weight: normal; text-decoration: none">
+					<font color="#000000"><font face="Arial"><font size="2" style="font-size: 10pt"><span style="background: transparent">Week
+					5</span></font></font></font></p>
+				</td>
+			</tr>
+			<tr>
+				<td bgcolor="#c0c0c0" style="border: 1px solid #000000; padding: 0.19cm">
+					<p align="center" style="font-variant: normal; font-style: normal; font-weight: normal; text-decoration: none">
+					<font color="#000000"><font face="Arial"><font size="2" style="font-size: 10pt"><span style="background: #c0c0c0">Sign-Off
+					On Completed Development Efforts</span></font></font></font></p>
+				</td>
+				<td bgcolor="#c0c0c0" style="border: 1px solid #000000; padding: 0.19cm">
+					<p align="center"><span style="font-variant: normal"><font color="#000000"><span style="text-decoration: none"><font face="Arial"><font size="2" style="font-size: 10pt"><span style="font-style: normal"><span style="font-weight: normal"><span style="background: #c0c0c0">Week
+					13</span></span></span></font></font></span></font></span><span style="font-variant: normal"><font color="#000000"><span style="text-decoration: none"><font face="Cambria"><font size="3" style="font-size: 12pt"><span style="font-style: normal"><span style="font-weight: normal"><span style="background: #c0c0c0">[1]</span></span></span></font></font></span></font></span></p>
+				</td>
+			</tr>
+		</table>
+
+		 
+		<br/><p>Each step in the FEEP Cycle process is described below.</p>
+		 
+		<p>It is expected that FEEP Cycles will be done initially on 
+			a semi-annual basis, though the EF may change the frequency at its sole discretion. </p>
+		 
+		<h3>1. Collect Input on Priorities</h3>
+		 
+		<p>The FEEP-PM will gather input from interested parties, including:</p>
+		<ul>
+			<li>Respective PMC’s</li>
+			<li>Member corporations that have donated funds with specific requests for development.</li>
+			<li>The Eclipse Management Organization (EMO), which includes</li>
+			<ul>
+				<li>Architecture Council</li>
+				<li>Planning Council</li>
+				<li>Foundation staff</li>
+			</ul>
+		</ul>
+
+		<p>From this input and interaction, the FEEP-PM will produce a collection of Development Efforts. </p>
+		 
+		<p>The description of each Development Effort is expected to include, as a minimum:  </p>
+		<ul>
+			<li>task name and Bugzilla id,</li>
+			<li>time estimate,</li>
+			<li>cost estimate,</li>
+			<li>expected deliverable(s)/outcome(s),</li>
+			<li>anticipated dependencies,</li>
+			<li>means of demonstration and/or verification of completion.</li>
+		</ul>
+		 
+		<p>The FEEP-PM is likely to engage with potential contractors at this stage to seek their input on the 
+			Development Efforts to enable him/her to provide better estimates.  This input from potential contractors 
+			will be provided based strictly on a non-committal basis by both sides, and is used for informational 
+			purposes only.  No funding will be provided to potential contractors for this input.  </p>
+		 
+		<h3>2. Establish Budget and Select Approved Development Efforts</h3>
+		 
+		<p>The FEEP-PM will create a draft budget identifying which of the Development Efforts identified will 
+			go to contract.  This draft budget will be based on the funds available through donation, as well as the 
+			relative priorities established.</p>
+		 
+		<p>The EMO will review both the budget and list of prioritized Development Efforts, and will generate a list of 
+			Approved Development Efforts. </p>
+		 
+		<blockquote>Note: Any budgeted development funds that are not allocated for development, or any funds not released due 
+			to non-completion of a development effort, will be added to the funds available for the next Development Cycle.
+		</blockquote>
+		 
+		<p>Before soliciting bids for the Approved Development Efforts, the FEEP-PM will review with the affected project or 
+			PMC the Approved Development Efforts targeted in their project. The project or PMC must commit their support to 
+			the proposed work, including naming the project committer(s) that will review, and commit the work if the 
+			contractor isn't a committer on that project.</p>
+			
+		<h3>3. Solicit Bids for Approved Development Efforts</h3>
+		 
+		<p>The FEEP-PM will post the Approved Development Efforts to the EF website.  During the open bidding period, expected 
+			to be approximately 2 weeks, potential contractors may interact with the FEEP-PM to seek additional information 
+			regarding the development efforts.</p>
+		 
+		<p>Interested contractors may submit confidential bids for any or all of the Approved Development Efforts. </p>
+		 
+		<blockquote>Note: EMO reserves the right to solicit bids from specific Committers and/or contractors should it feel particular expertise or experience is required to be successful.  The EMO is not obliged to disclose that it has chosen to carry out this solicitation.</blockquote>
+		 
+		<p>In each bid, the contractor must identify, as a minimum:</p>
+		<ul>
+			<li>Description of the approa	ch to address the Development Effort.</li>
+			<li>Identification of who will perform the work (i.e., named developers).</li>
+			<li>The proposed timeframe for the development effort.</li>
+			<li>Any dependencies/caveats that exist that must be addressed.</li>
+			<li>Proposed outcome for the work, including how to demonstrate the work has been completed.</li>
+			<li>Explicit list of deliverables, including any interim deliverables.</li>
+			<li>A proposed price, including whether the bid is being made on a fixed price or time and materials 
+				basis, and whether any interim milestones and associated and/or interim payments are proposed. </li>
+		</ul>
+		 
+		<p>All bids should indicate any taxes to be charged in addition to the costs identified.  It is expected that no 
+			expenses shall be incurred as part of any bid, though exceptions may be proposed by contractors.  These exceptions 
+			must be clearly identified, and contractors may only bill for such expenses if agreed to in writing by the 
+			FEEP-PM as part of the contract for the Approved Development Effort, and if the expense is actually incurred.  </p>
+		 
+		<p>All bids submitted will be treated as confidential by EF.  However, all contractors must agree to EF posting the 
+			name and value of each contracted Development Effort.</p>
+		 
+		<h3>4. Award Contracts For Successful Bids</h3>
+		
+		<p>The FEEP-PM will work with others within the EMO to evaluate the submitted bids.  Winning bids will be selected 
+		upon the following criteria:</p>
+		<ul>
+			<li>Price</li>
+			<li>Quality of proposed development and deliverables</li>
+			<li>Skillset of proposed developers, with preference given to Committers in the relevant area.</li>
+			<li>Bidder’s relationship with EF, with preference given to either Solution Members with Committers, 
+				or self-employed Committers with relevant expertise</li>
+			<li>Any additional relevant elements in the bid, including delivery date, whether fixed price vs. 
+				time and materials basis, etc. </li> 
+		</ul>
+		 
+		<p>EMO may decide, at its sole discretion, not to let a contract for any particular Approved Development Effort, 
+			even if acceptable bids have been submitted.</p>
+		 
+		<p>Contractors will be expected to execute a Statement of Work (SOW) for each winning bid.  Each SOW will be created 
+			against the standing Professional Services Agreement with the contractor, which must have been previously executed 
+			by the contractor. </p>
+		 
+		<p>Following the execution of each SOW, EMO will publish the name of the winning contractor and the total contract value.</p>
+		 
+		<h3>5. Sign-Off on Completed Development Efforts</h3>
+		 
+		<p>For each Development Effort, the contractor is expected to provide:
+		<ul>
+			<li>Source code. In most cases, it will be expected that the acceptance criteria for code is that it has been 
+				committed by the Eclipse project. Other scenarios may be possible in exceptional circumstances.</li>
+			<li>Test harness(es) for code</li>
+			<li>Documentation, including appropriate documentation related to IP</li>
+			<li>Any other appropriate deliverables, including those to which the contractor committed in the original bid.</li>
+		</ul>
+		 
+		<p>Unless explicitly agreed to otherwise, payment will only be made at the completion of the Development Effort, 
+		and once the FEEP-PM has signed-off on the deliverables.  The FEEP-PM may seek assistance and opinions from the 
+		relevant interested parties to evaluate the completeness of the deliverables.</p>
+		 
+		<p>Sign-off by FEEP-PM on a submitted completed Development Effort is expected to take up to 14 days. </p>
+		
+		
+		<small>[1] Completion dates may vary, depending on the individual development efforts. </small>
+		
+
+
+
+	</div>
+
+EOHTML;
+
+
+	# Generate the web page
+	$App->generatePage($theme, $Menu, $Nav, $pageAuthor, $pageKeywords, $pageTitle, $html);
+?>
