<?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);
?>
