<!-- 
	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>Koneki</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;
}

.archiBlock {
	font-family: sans-serif;
	font-variant: small-caps;
	color: #FFF;
	padding: 5px;
	margin-bottom: 0.8em;
	margin-top: 1em;
	display: inline-block;
	border: solid 3px;
	display: inline-block;
}

#embdd {
	background-color: #A48FC0;
	border-color: #62457C;
}

#protocols {
	background-color: #51BBCE;
	border-color: #008498;
}

#server {
	background-color: #A8C377;
	border-color: #73903A;
}

#appModel {
	background-color: #FEA664;
	border-color: #C4782E;
}
</style>

<body>
	<p>
		The Koneki project is a proposed open source incubator project under
		the <a
			href="http://www.eclipse.org/projects/project_summary.php?projectid=technology">Eclipse
			Technology 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 Eclipse
		community. 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.
 -->

	<pre>
  [Wikipedia] : Machine-to-Machine (M2M) refers to technologies that
allow both wireless and wired systems to communicate with other devices
of the same ability.
	</pre>
	<p>
		<img src="images/m2m-overview.PNG" />
	</p>

	<p>When first faced with the assignment of setting up a remote
		management and supervision system for devices scattered over a large
		geographical area, a developer faces miscellaneous and usually tricky
		engineering problems.</p>

	<ul>
		<li><strong>Embedded application development complexity</strong>
			- Because it is very close to the underlying hardware, embedded
			development can turn out to be a complex task, especially considering
			the fact that people developing M2M solutions are domain experts
			(healthcare, smart grid, &#8230;), not necessarily software
			specialists.</li>
		<li><strong>Variety of M2M embedded modules</strong> - There are
			many M2M-capable devices available on the market, and they all come
			with different operating systems (although Linux seems to become the
			norm), different APIs to communicate with a distant server (over
			HTTP, TCP, or whatever) or with a "local" asset (serial protocol,
			Modbus, ZigBee&reg;, &#8230;). This fragmentation makes it very difficult
			to come up with reusable, portable, software.</li>
	</ul>

	<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>The main goal of the proposed project is to provide
		Machine-to-Machine solutions developers with tools easing the
		development, simulation, testing/debugging and deployment of such
		solutions.</p>
	<p>More specifically, Koneki aims at:</p>

	<ul>
		<li>Enabling M2M development
			<ul>
				<li>support for languages and runtimes used to develop M2M
					applications, with a specific focus on Lua (ligthweight language,
					very well-suited for M2M applications)</li>
				<li>support for communication protocols used in M2M
					applications</li>
				<li>smooth integration of M2M servers</li>
			</ul>
		<li>Establishing an M2M application model</li>
		<li>Providing tooling built on top of this application model to
			improve M2M development experience.</li>
		<!-- <li>Providing application examples promoting</li>  -->
	</ul>

	<p>
		As detailed in the <em>Background</em> paragraph, there are many
		flavors of M2M modules, vendor SDKs, communication protocols, etc. ;
		the proposed project will therefore define and expose the APIs needed
		to support M2M development in the large.
	</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 Koneki project goal will be to deliver a first-class
		development environment for M2M solutions developers.</p>

	<p>
		<img src="images/koneki-architecture.png">
	</p>

	<p>Here are the key features that the Koneki project aims at
		providing:
	<ul>
		<li><strong class="archiBlock" id="embdd">M2M Embedded
				Development</strong>
			<ul>
				<li><strong>Language tools</strong> &mdash; Koneki will rely
					on existing language development tools (CDT, JDT, DLTK-based
					editors, &#8230;) to give the M2M developer access to usual editing
					features (syntax highlighting, content assist, outlines, &#8230;).</li>
				<li><strong>M2M embedded runtimes</strong> &mdash; Koneki will
					ease the use of M2M embedded runtimes: remote configuration, remote
					application deployment/debugging, shell access, &#8230;</li>
				<li><strong>M2M application generation</strong> &mdash; Koneki
					will provide an extensible generation infrastructure built on top
					of the M2M application model.</li>
				<li><strong>Application examples</strong> &mdash;
					Machine-to-Machine solution developers are not necessarily skilled
					embedded developers (e.g. a solution to remotely control an
					industrial equipment will likely be developed by a control
					engineer), the Koneki project will therefore focus on providing the
					developer with embedded application templates and examples.</li>
			</ul>
		</li>
		<li><strong class="archiBlock" id="protocols">Protocols</strong>
			<ul>
				<li>Koneki project will provide the user with utilities to
					manipulate M2M &amp; industrial protocols: encode/decode binary
					frames, perform bandwidth usage simulation according to different
					communication scenarios, etc.</li>
				<li><strong>Simulation</strong> &mdash; Koneki will provide
					extension points enabling the creation of a consistent UI on top of
					existing protocol simulators/emulators.</li>
			</ul>
		</li>
		<li><strong class="archiBlock" id="server">M2M Server
				Development</strong>
			<ul>
				<li>Koneki will define an abstraction (a la WST Server Adapter)
					of what an M2M server is. It will allow M2M services providers to
					implement their own connector, and developers to easily configure
					the server-side model of their application, discover the Web
					Services exposed by the server, etc.</li>
				<li><strong>Simulation</strong> &mdash; Koneki will provide a
					generic simulation infrastructure to allow developer to test
					different communication policies (and their consequences on
					bandwidth consumption), monitor data transfers, simulate
					communication failures, etc.</li>
				<li><strong>Application examples</strong> &mdash; Koneki may
					package exemplary end-user applications to illustrate the use of
					M2M server APIs.</li>
			</ul>
		</li>
		<li><strong class="archiBlock" id="appModel">M2M Model</strong>
			<ul>
				<li><strong>Application model</strong> &mdash; Koneki will
					implement an M2M application model allowing an M2M solution
					developer to create an abstract definition of the capabilities of
					an M2M application (communication capabilities, exposed variables,
					communication policy, supported remote commands, &#8230;).</li>
				<li><strong>Application editors</strong> &mdash; Koneki will
					provide high-level editors (forms, diagrams, DSL-based editors) of
					M2M application models, assisting the developer with the design of
					his/her embedded application.</li>
			</ul>
		</li>
	</ul>

	<h2>Why Eclipse?</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>The Koneki project has relationships with many Eclipse projects
		and the Koneki team will closely collaborate with these projects
		since:</p>
	<ul>
		<li>Lua tooling relies on DLTK 2,</li>
		<li>&#8220;EMF Forms&#8221; (PDE Incubator) is used for easing
			the development of form-based editors,</li>
		<li>Tools TM (Terminal and RSE components) is used to communicate
			with embedded devices,</li>
		<li>Modeling projects (EMF, EMF Transaction, GMF)  support the
			M2M application model,</li>
	</ul>

	<p>Koneki will work even more closely with eTrice (MDT project) and
		Yakindu (EclipseLabs project at the moment) teams to establish an M2M
		application/component model.</p>

	<p>In addition, an Eclipse M2M Industry Working Group will likely
		be created to help industrial partners and tool vendors to come up
		with a reference environment to develop M2M solutions. Having Koneki
		at eclipse.org is the best way to ensure a good collaboration between
		the Koneki team and the members of the Working Group in charge of
		identifying M2M tooling requirements.</p>

	<h2>Initial Contribution</h2>

	<!-- 
	Projects are expected to arrive at Eclipse with existing code.
	
	Describe the existing code that will be contributed to the project. Please provide
	a couple of paragraphs describing the code with modest detail, including important
	information like code ownership (who holds the copyright?), and some consideration
	of community that exists around the code. Include a listing of third-party libraries 
	and associated licenses.
 -->
	<p>The Koneki project will be seeded with an initial contribution
		from Sierra Wireless in the form of the following tools:</p>
	<ul>
		<li>A set of plug-ins to suppport the Lua language: editor,
			content-assist, packaging, &#8230;</li>
		<li>A set of plug-ins to ease Linux target communication: remote
			project copy, remote application launch, debugging &#8230;</li>
		<li>A packaging mechanism of M2M applications examples,</li>
		<li>A prototype of a component model for M2M applications, based
			on a dataflow paradigm,</li>
		<li>A graphical editor on top of this component model to give the
			developer the ability to visualize and modify its application
			structure, and perform type and consistency checks.</li>
	</ul>

	<h2>Legal Issues</h2>

	<!-- 
	Please describe any potential legal issues in this section. Does somebody else
	own the trademark to the project name? Is there some issue that prevents you
	from licensing the project under the Eclipse Public License? Are parts of the 
	code available under some other license? Are there any LGPL/GPL bits that you
	absolutely require?
 -->
	<p>No legal issues are anticipated although all 3rd party bundles
		used in the initial contribution, and that are not already made
		available via the Orbit project, will need to go through the standard
		Eclipse IP process.</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>
			<b>Benjamin Cab&eacute;</b>, Sierra Wireless (project co-lead)
		</dt>
		<dd>Benjamin is a long-time contributor on many Eclipse projects
			(Eclipse, PDE, EMF, ECF, &#8230;) and committer on e4 and PDE
			(inactive though). He loves spreading the good word about Eclipse
			awesomeness at various conferences and writing blogs and articles. </dd>
		<dt>
			<b>Ga&eacute;tan Morice</b>, Sierra Wireless (project co-lead)
		</dt>
		<dd>Ga&eacute;tan leads the Embedded Tooling Development team at
			Sierra Wireless. The tools his team is developing will be built on
			top of Koneki components. On a side note, he is passionated by modern
			programming languages, and especially Clojure. </dd>
		<dt>
			<b>Simon Bernard</b>, Sierra Wireless
		</dt>
		<dd>Simon is the lead developer of Sierra Wireless Tools for
			Embedded Development. He has 5+ years of experience with Eclipse
			development (RCP, EMF, GMF, CDT, &#8230;). </dd>
		<dt>
			<b>K&eacute;vin Kin-Foo</b>, Sierra Wireless
		</dt>
		<dd>K&eacute;vin is the developer behind LuaEclipse 2, which he
			has developed during an internship at Sierra Wireless, and improved
			on his spare time. He has been hired by Sierra recently and will be
			the lead developer for the Lua Development Environment.  </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 will mentor this
		project:</p>

	<ul>
		<li>Bernd Kolb, SAP AG</li>
		<li>Martin Oberhuber, Wind River</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>Kai Kreuzer, openHAB project lead</li>
		<li>K&eacute;vin Kin-Foo, LuaEclipse 2 project</li>
		<li>itemis AG (Yakindu project)</li>
		<li>Protos Software GMBh (eTrice project)</li>
		<li>Joe Biron, Axeda</li>
	</ul>

	<h2>Tentative Plan</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>May 2011 &ndash; Sierra Wireless initial contribution
			<ul>
				<li>&#8220;Enablers&#8221;</li>
				<li>Lua tooling</li>
				<li>Modeling environment prototype </li>
			</ul>
		</li>

		<li>June 2011
			<ul>
				<li>Convert Koneki's build to Tycho</li>
				<li>Make Lua Tooling available at Eclipse Marketplace</li>
			</ul>
		</li>

		<li>Q3 2011
			<ul>
				<li>Call for community participation to define an M2M
					application model</li>
				<li>Improve Lua Tooling: LuaRocks support</li>
			</ul>
		</li>

		<li>Q4 2011
			<ul>
				<li>Communicate at EclipseCon Europe</li>
				<li>Setup M2M server simulation infrastructure</li>
				<li>Lua Tooling component to be moved to its own Technology
					project </li>
			</ul>
		</li>

		<li>Q2 2012 &ndash; First release of an &#8220;end-to-end&#8221;
			M2M IDE</li>
	</ul>

	<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>24-February-2011</td>
			<td>Document created</td>
		</tr>
		<tr>
			<td>09-March-2011</td>
			<td>Added Kai Kreuzer from openHAB to the Interested Parties</td>
		</tr>
		<tr>
			<td>14-March-2011</td>
			<td>Added K&eacute;vin Kin-Foo from LuaEclipse 2 to Interested Parties</td>
		</tr>
		<tr>
			<td>07-Apr-2011</td>
			<td>Added new Interested Parties and Mentors</td>
		</tr>
		<tr>
			<td>20-Apr-2011</td>
			<td>Detailed the functional architecture.<br /> Refined the
				project plan and relationships with other Eclipse projects.<br />
				Added K&eacute;vin Kin-Foo to initial committers list.</td>
		</tr>
	</table>
</body>
</html>