<!-- 
	This document is provided as a template along with some guidance for creating
	your project proposal. This is just a template. Feel free to change it as
	you see fit (add sections, remove section). We feel, however, that the
	suggestions represented in this document represent the reasonable minimum
	amount of information to move forward.
	
	Please keep the formatting in this document simple. Please do not edit 
	this document in Microsoft Word as it adds huge piles of markup that make
	it difficult to restyle.
	
	More information is available here:
	
	http://wiki.eclipse.org/Development_Resources/HOWTO/Pre-Proposal_Phase
	
	Direct any questions about this template to emo@eclipse.org
 -->

<html>
<head>

<!-- 
	Include the title here. We will parse it out of here and include it on the
	rendered webpage. Do not duplicate the title within the text of your page.
 -->

<title>3P - PolarSys Packaging Project</title>
</head>

<!-- 
	We make use of the 'classic' HTML Definition List (dl) tag to specify
	committers. I know... you haven't seen this tag in a long while...
 -->

<style>
dt {
	display: list-item;
	list-style-position: outside;
	list-style-image:
		url(/eclipse.org-common/themes/Phoenix/images/arrow.gif);
	margin-left: 16px;
}

dd {
	margin-left: 25px;
	margin-bottom: 5px;
}
</style>

<body>
	<p>
		The PolarSys Packaging Project, or 3P for short, is a proposed open
		source project under the <a
			href="http://www.eclipse.org/projects/project_summary.php?projectid=[ContainerProjectId]">PolarSys
			Top-Level Project</a>.
	</p>

	<!-- 
	The communication channel must be specified. Typically, this is the
	"Proposals" forum. In general, you don't need to change this.
 -->
	<p>
		This proposal is in the Project Proposal Phase (as defined in the
		Eclipse Development Process) and is written to declare its intent and
		scope. We solicit additional participation and input from the PolarSys
		and Eclipse communities. Please send all feedback to the <a
			href="http://www.eclipse.org/forums/eclipse.proposals">Eclipse
			Proposals</a> Forum.
	</p>

	<h2>Background</h2>

	<!-- 
	Optionally provide the background that has lead you to creating this project.
 -->
	<p>PolarSys is an Industry Working Group aiming to fulfill the
		embedded / critical system industries' requirements on tools and
		components. While its industrial users are interested in individual
		technological components as building blocks, the main value for them
		is in integrated packages gathering complete stacks of functions for
		given activities (e.g. System Modeling, Requirement Management, etc.).</p>


	<h2>Scope</h2>

	<!-- 
	All projects must have a well-defined scope. Describe, concisely, what
	is in-scope and (optionally) what is out-of-scope. An Eclipse project
	cannot have an open-ended scope.
 -->
	<p>3P provides packages, platforms, and installers for
		functional stacks identified as required by the Polarsys Architecture
		Committee. Those stacks will be based on components originating from
		Eclipse and PolarSys projects.</p>

	<h2>Description</h2>

	<!-- 
	Describe the project here. Be concise, but provide enough information that
	somebody who doesn't already know very much about your project idea or domain
	has at least a fighting chance of understanding its purpose.
 -->

	<p>The objectives of 3P are to:</p>

	<ul>
	</ul>
	<li>Provide Polarsys-specific packages which address requirements
		of embedded / critical software and system development. The initial
		bundle is a Model Driven configuration of Eclipse covering most
		development stages (specification, design, implementation). More
		packages will come later.</li>
	<li>Provide installers that improves the install experience.</li>
	<li>Provide platforms that keep packages building simple. These
		building platforms cover Eclipse packages - as far as possible using
		CBI or EPP - but also packages based on other technologies like C/C++,
		CAML, etc.</li>
	<li>Provide build platforms compatible with Very Long Term
		Support.</li>
	</ul>
	<p>
		As for PolarSys domains identified in the Top-Level project, 3P
		belongs to <em>Build Continuous Integration</em> of the Polarsys
		Service Framework.
	</p>

	<h2>Why PolarSys?</h2>

	<!--
	Answer these two questions:	What value does this project bring to the Eclipse
	community? What value do you expect to obtain from hosting your project at Eclipse?
	
	What value do you get by having your project at Eclipse over and above the value
	of hosting at Eclipse Labs?
 -->
	<p>This project is a basement of PolarSys infrastructure. As such,
		it needs to be hosted by the IWG.</p>

	<h2>Initial Contribution</h2>

	None.

	<h2>Legal Issues</h2>

	<p>Each package, installer and build platform provided by 3P has
		its own licensing policy, complying with the PolarSys rules.</p>

	<h2>Committers</h2>

	<!-- 
	List any initial committers that should be provisioned along with the
	new project. Include affiliation, but do not include email addresses at
	this point.
 -->

	<p>The following individuals are proposed as initial committers to
		the project:</p>

	<dl>
		<dt>Pierre Gaufillet, Airbus</dt>
		<dd>
			Pierre is experienced in building Eclipse packages within Airbus for
			years. He is also involved in <a href="http://www.topcased.org">TOPCASED</a>
			since 2005. He participates in defining and maintaining 3P building
			platforms and PolarSys packages. Pierre is a member of PolarSys
			Architecture Committee, and is proposed as Project lead.
		</dd>
		<dt>Matthieu Helleboid, Thales</dt>
		<dd>Matthieu is a committer on the EGF project. He participates
			in defining and maintaining 3P building platforms and PolarSys
			packages.
		<dt>Benoit Langlois, Thales</dt>
		<dd>Benoit is a committer on the EGF project where he has made
			significant contributions. He participates in defining and
			maintaining 3P building platforms and PolarSys packages. Benoit is a
			member of PolarSys Architecture Committee.</dd>
		<dt>Mélanie Bats, Obeo</dt>
		<dd>Mélanie will contribute to the smooth integration of Obeo projects 
		    in the Polarsys bundles,</dd>
	</dl>

	<p>We welcome additional committers and contributions.</p>

	<!-- 
	Describe any initial contributions of code that will be brought to the 
	project. If there is no existing code, just remove this section.
 -->

	<h2>Mentors</h2>

	<!-- 
	New Eclipse projects require a minimum of two mentors from the Architecture
	Council. You need to identify two mentors before the project is created. The
	proposal can be posted before this section is filled in (it's a little easier
	to find a mentor when the proposal itself is public).
 -->

	<p>The following Architecture Council members mentor this project:</p>

	<ul>
		<li>C&eacute;dric Brun, Obeo</li>
		<li>Benjamin Cab&eacute;, Sierra Wireless</li>
	</ul>

	<h2>Interested Parties</h2>

	<!-- 
	Provide a list of individuals, organisations, companies, and other Eclipse
	projects that are interested in this project. This list will provide some
	insight into who your project's community will ultimately include. Where
	possible, include affiliations. Do not include email addresses.
 -->

	<p>The following individuals, organisations, companies and projects
		have expressed interest in this project:</p>

	<ul>
		<li>Pierre Gaufillet, Airbus</li>
		<li>Alain Rossignol, Astrium</li>
		<li>Dominique Toupin, Ericsson</li>
		<li>Benoit Langlois, Thales</li>
		<li>Rapha&euml;l Faudou, ATOS</li>
		<li>Obeo</li>
	</ul>

	<h2>Project Scheduling</h2>

	<!-- 
	Describe, in rough terms, what the basic scheduling of the project will
	be. You might, for example, include an indication of when an initial contribution
	should be expected, when your first build will be ready, etc. Exact
	dates are not required.
 -->
	<ul>
		<li>End of 2012: basic building platform based on Eclipse CBI for
			PolarSys IDE 0.1, based on Juno SR1</li>
		<li>April 2013: releasing PolarSys IDE milestone 1.0M1</li>
		<li>July 2013: releasing PolarSys IDE milesonte 1.0M2</li>
		<li>Oct 2013: PolarSys IDE 1.0, aligned on Kepler, platforms:
			Windows (64 bits), Linux (64 bits), MAC, Solaris</li>
	</ul>

	Forthcoming releases of PolarSys IDE will be aligned on the planning of
	the Eclipse release train.


	<h2>Changes to this Document</h2>

	<!-- 
	List any changes that have occurred in the document here.
	You only need to document changes that have occurred after the document
	has been posted live for the community to view and comment.
 -->

	<table>
		<tr>
			<th>Date</th>
			<th>Change</th>
		</tr>
		<tr>
			<td>18-January-2013</td>
			<td>Added Obeo as an interested party, and Mélanie Bats as a committer.</td>
		</tr>
		<tr>
			<td>16-November-2012</td>
			<td>Document created</td>
		</tr>
	</table>
	<p />
</body>
</html>