<?xml version="1.0" encoding="UTF-8" standalone="yes" ?>
<?xml-stylesheet type="text/xsl" href="http://www.eclipse.org/projects/project-plan.xsl"?>
<!-- cf. http://wiki.eclipse.org/Development_Resources/Project_Plan -->
<plan xmlns="http://www.eclipse.org/project/plan" xmlns:html="http://www.w3.org/1999/xhtml"
	name="eTrice">
	<release projectid="modeling.mdt.etrice" version="0.3.0" />
	<introduction>
		<html:div>
			<html:p>This document is about the development progress for the eTrice release 0.3</html:p>
		</html:div>
	</introduction>
	<release_deliverables>
		<html:div>
			<html:p>
				The release deliverables consist of the following items:
				<html:ul>
					<html:li>eTrice modeling tools (includes runtime, sources, tutorial and
						documentation) (ZIP file download and update site).</html:li>
					<html:li>eTrice Java code generator, middleware and model library (no download but installable
						by a New Wizard shipped with eTrice).</html:li>
					<html:li>eTrice ANSI-C code generator, middleware and model library.</html:li>
					<html:li>eTrice C++ code generator, middleware and model library.</html:li>
					<html:li>eTrice tests (no download, executed in central Hudson build)</html:li>
				</html:ul>
			</html:p>
		</html:div>
	</release_deliverables>
	<release_milestones>
		<milestone date="11/15/2012" milestone="0.3.0 M1">
			<html:div>
					<html:a
						href="https://bugs.eclipse.org/bugs/buglist.cgi?classification=Modeling;product=MDT.Etrice;query_format=advanced;status_whiteboard=0.3.0M1;status_whiteboard_type=allwordssubstr">
						bugzillas
	      			</html:a>
			</html:div>
		</milestone>
		<milestone date="12/15/2012" milestone="0.3.0 M2">
			<html:div>
					<html:a
						href="https://bugs.eclipse.org/bugs/buglist.cgi?classification=Modeling;product=MDT.Etrice;query_format=advanced;status_whiteboard=0.3.0M2;status_whiteboard_type=allwordssubstr">
						bugzillas
	      			</html:a>
			</html:div>
		</milestone>
		<milestone date="04/30/2013" milestone="0.3.0">
			<html:div>
					<html:a
						href="https://bugs.eclipse.org/bugs/buglist.cgi?classification=Modeling;product=MDT.Etrice;query_format=advanced;status_whiteboard=0.3.0;status_whiteboard_type=allwordssubstr">
						bugzillas
	      			</html:a>
			</html:div>
		</milestone>
		<postamble />
	</release_milestones>
	<target_environments>
		<html:div>
			<html:p>
				In order to remain up-to-date, each Eclipse release targets
				reasonably current versions of the underlying operating
				environments. The eTrice project depends upon the Platform and
				other projects, which are mostly "pure" Java. The 0.3.0 release of
				the eTrice Project is written and compiled against the Juno APIs,
				and targeted to run on version 1.6 of the
				Java Runtime Environment, Standard Edition. eTrice will be tested
				and validated against a subset of target environments listed for the platform.
			</html:p>
		</html:div>
		<internationalization>
			<html:div>
				<html:p>
					eTrice aims at real-time and embedded developers.
					All texts come by default in English only, no
					internationalization is planned.
				</html:p>
			</html:div>
		</internationalization>
	</target_environments>
	<compatibility_with_previous_releases>
		<html:div>
			<html:p>
				There will be additional features in models and code generators, leading to limited compatibility.
			</html:p>
		</html:div>
	</compatibility_with_previous_releases>
	<themes_and_priorities>
		<preamble>
			<html:div>
				<html:p>
					With the third release of eTrice consolidation and integration of various contributions are the main themes.
     			</html:p>
			</html:div>
		</preamble>
		<theme name="Consolidation of Existing Features: Model Editors, Generators and Runtimes (Java and C)">
			<description>
				<html:div>
					<html:p>
						Exisiting features will be consolidated. Some minor features are missing in the C generator, others are missing
						in the Java generator. We will add more test to get a better coverage of tested features.
						We will also do some re-factorings and round-offs where appropriate.
	        		</html:p>
				</html:div>
			</description>
		</theme>
		<theme name="Integration of Google Summer of Code Projects">
			<description>
				<html:div>
					<html:p>
						Summer 2012 we had three Google Summer of Code students working on eTrice projects
						<html:ul>
						<html:li>Diagram Layout with KIELER</html:li>
						<html:li>Generic Action Code Language</html:li>
						<html:li>Extended Model Validation and State Graph Proposal Generation Based on Protocol Semantics</html:li>
						</html:ul>
	        		</html:p>
	        		<html:a href="http://wiki.eclipse.org/Google_Summer_of_Code_2012_Ideas#Ideas_around_the_eTrice_project">See here</html:a> for more details.
	        		<html:a>
	        			All this code will be integrated and completed where necessary.
	        		</html:a>
				</html:div>
			</description>
		</theme>
		<theme name="First Version of the C++ Generator and Runtime">
			<description>
				<html:div>
					<html:p>
						A first version of the C++ generator and runtime was contributed which we will integrate to make it
						available to the community.
	        		</html:p>
				</html:div>
			</description>
		</theme>
		<theme name="Improved Documentation and Tutorials">
			<description>
				<html:div>
					<html:p>
						The documentation will be completed and more tutorials will be added.
	        		</html:p>
				</html:div>
			</description>
		</theme>
	</themes_and_priorities>
	<appendix />
</plan>
