<?xml version="1.0" encoding="UTF-8" ?>
<?xml-stylesheet type="text/xsl" href="http://www.eclipse.org/projects/project-plan.xsl"?>
<plan 
	plan-format="1.0" xmlns="http://www.eclipse.org/project/plan"
	xmlns:html="http://www.w3.org/1999/xhtml" 
	name="Spatiotemporal Epidemiological Modeler">
	<release projectid="technology.stem" version="4.0.1" />
	<introduction>
		<html:div>
			The Spatiotemporal Epidemiological Modeler (STEM) tool is designed to
			help scientists and public health officials create and use
			spatial and temporal models of emerging infectious diseases. These models
			could aid in understanding, and potentially preventing,
			the spread such diseases.
		</html:div>
	</introduction>
	<release_deliverables>
		<html:div>
			<html:p />
			STEM is delivered as an Eclipse Rich Client Platform (RCP)
			application runnable on Windows, Linux, and Mac OS X platforms.  
			STEM 4.0 is based on and fully compatible with Eclipse 4.x
			Starting with STEM V3.0.0M1, STEM requires (J2SE) 8.0 JVM. 
			The STEM application includes tools
			for designing, simulating, and analyzing epidemiological models.
			STEM contains a wealth of prepackaged data in the form of existing
			disease models and simulations as well as geographic/demographic data
			for the world.
			The latest build with bug fixes are available in V4.0.1
		</html:div>
	</release_deliverables>
	<release_milestones>
		<preamble>
			<html:div>Here is the timeline for the current STEM release cycle.
			</html:div>
		</preamble>
		<milestone date="12/14/2012" milestone="1.4.1">
			<html:div>Release 1.4.1</html:div>
		</milestone>
		<milestone date="04/02/2013" milestone="2.0.0 M1">
			<html:div>2.0.0 M1 (milestone complete)</html:div>
		</milestone>
		<milestone date="09/20/2013" milestone="2.0.0 M5">
			<html:div>2.0.0 M5 (milestone complete)</html:div>
		</milestone> 
		<milestone date="10/15/2013" milestone="2.0.0">
			<html:div>Release 2.0.0 (release complete)</html:div>
		</milestone>
		<milestone date="01/09/2015" milestone="2.0.3">
			<html:div>Release 2.0.3 (release complete)</html:div>
		</milestone>
		<milestone date="10/09/2015" milestone="3.0.0M1">
			<html:div>3.0.0M1 (milestone complete)</html:div>
		</milestone>
		<milestone date="02/04/2016" milestone="3.0.0M2">
			<html:div>3.0.0M2 (milestone complete)</html:div>
		</milestone>
		<milestone date="04/02/2016" milestone="3.0.0M3">
			<html:div>3.0.0M3 (milestone complete)</html:div>
		</milestone>
		<milestone date="12/01/2018" milestone="4.0.0M1">
			<html:div>4.0.0M1 (milestone complete)</html:div>
		</milestone>
		<milestone date="01/15/2019" milestone="4.0.0">
			<html:div>Release 4.0.0 (release complete)</html:div>
		</milestone>
		<milestone date="01/1/2021" milestone="5.0.0M1">
			<html:div>5.0.0M1 (STEM on Cloud. tentative date)</html:div>
		</milestone>
	</release_milestones>
	<target_environments>
			<html:div>
			Today STEM runs 64-bit Windows, Linux, and Mac OS X
			platforms. It is built using Eclipse 4.x and requires Java 8 or
			later.
			</html:div>
		<internationalization>
			<html:div>
				STEM currently has partial National Language Support for several languages.
				NLS resources for STEM are managed through Eclipse Babel and additional translations
				can be contributed through the Babel Project (http://eclipse.org/babel/).
			</html:div>
		</internationalization>
	</target_environments>
	<compatibility_with_previous_releases>
			<html:div>
			STEM 5.0.0 Will containerize all of STEM, creating separate microservice so STEM can run in any cloud environment
			</html:div>
	</compatibility_with_previous_releases>
	<themes_and_priorities>
		<preamble>
			<html:div>
				Work with users to extend STEM to support work on the most
				important current problems in epidemiology and public health.
			</html:div>
		</preamble>

		<theme name="STEM of Cloud">
			<description>
				<html:p>
					In 2020 we will continue improving STEM and support its community and support nCoV modeling. 
					We will begin the process of designing STEM 5.0 to run on Cloud as a collection of microservices. 
				</html:p>
			</description>
		</theme>

	</themes_and_priorities>
	<!-- <appendix name="Project Refactoring"> ...html... </appendix> -->
</plan>
