<?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.2.0" />
	<introduction>
		<html:div>
			<html:p>This document is about the development progress for the eTrice release 0.2</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 tests (no download, executed in central Hudson build)</html:li>
				</html:ul>
			</html:p>
		</html:div>
	</release_deliverables>
	<release_milestones>
		<milestone date="15/03/2012" milestone="M1">
			<html:div>
					<html:a
						href="https://bugs.eclipse.org/bugs/buglist.cgi?classification=Modeling;product=MDT.Etrice;query_format=advanced;status_whiteboard=0.2.0M1;status_whiteboard_type=allwordssubstr">
						bugzillas
	      			</html:a>
			</html:div>
		</milestone>
		<milestone date="05/21/2012" milestone="M2">
			<html:div>
					<html:a
						href="https://bugs.eclipse.org/bugs/buglist.cgi?classification=Modeling;product=MDT.Etrice;query_format=advanced;status_whiteboard=0.2.0M2;status_whiteboard_type=allwordssubstr">
						bugzillas
	      			</html:a>
			</html:div>
		</milestone>
		<milestone date="09/30/2012" milestone="0.2.0">
			<html:div>
					<html:a
						href="https://bugs.eclipse.org/bugs/buglist.cgi?classification=Modeling;product=MDT.Etrice;query_format=advanced;status_whiteboard=0.2.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.2.0 release of
				the eTrice Project is written and compiled against the Indigo release
				train 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 modeling 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 second release of eTrice more modeling features, code generators (ANSI-C) 
					and model level inheritance for Actors and Finite State Machines will be introduced.
     			</html:p>
			</html:div>
		</preamble>
		<theme name="Create a Code Generator for ANSI-C as Target Language">
			<description>
				<html:div>
					<html:p>
						The second supported target language (the ROOM "detail level language") will be ANSI-C because it is
						widely used in embedded systems.
						Small and large systems with hard real-time requirements should be in scope of this.
						Especially for micro controllers emphasis will be layed on small memory and performance footprint.
	        		</html:p>
				</html:div>
			</description>
		</theme>
		<theme name="Model Level Inheritance for Actors and Finite State Machines">
			<description>
				<html:div>
					<html:p>
						The existing model level inheritance in the textual syntax will be implemented also for the graphical editors.
						Inheritance will be implemented for both target languages by means of code generation.
	        		</html:p>
				</html:div>
			</description>
		</theme>
		<theme name="Create more Tutorials to cover the most important Features of eTrice">
			<description>
				<html:div>
					<html:p>
						A good documentation and tutorials are a crucial prerequisite for the adoption of the tooling.
						More complex tutorials will enable a deeper understanding of the possibilities of ROOM.
	        		</html:p>
				</html:div>
			</description>
		</theme>
	</themes_and_priorities>
	<appendix />
</plan>
