<!-- 
	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>Paho</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>
dl {
	margin-bottom:20px;
}
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 Paho project is a proposed open source 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>
<br>
<h2>Background</h2>

<!-- 
	Optionally provide the background that has lead you to creating this project.
 -->
 <p>We now have the ability to
measure, sense and monitor nearly anything in the physical world. Rapid advances
in embedded platforms and wireless connectivity are driving growth of M2M
(Machine-to-Machine) technology and the many industries it serves. By 2020, the
number of connected physical world devices is expected to be in the range of 50
billion, fueled by a 1000x increase in wireless broadband traffic. These
factors are forming a significant industry shift that will not be limited to
device connectivity.</p>

<p><img width=504 height=296 src="images/image001.gif"></p>

<p>Machine-to-Machine (M2M) solutions such as industrial control, smart
buildings, asset tracking, traffic control and healthcare monitoring, are an
essential and integral part of nearly all industry, enterprise and daily life. Inherent
to M2M is the need to connect objects in the physical world, via sensors,
actuators and other devices, into monitoring, control, business, and consumer software
systems, often over constrained wireless networks. Advances in wireless,
embedded, internet and mobile technologies are now creating all manner of new
objects that can sense, control and connect. Such smart objects not only create
new M2M opportunities, but also expand the availability of device connectivity
to Web and Enterprise IT developers. Whether looked at as an Internet of Things
or a Smarter Planet, people, systems and objects will increasingly need to
communicate and interact with each other in ways that today, cannot yet be
entirely anticipated.</p>

<p>While smart objects and physical world systems are often integrated with Enterprise and Web middleware today, it is often done using proprietary integration models
and combinations of a prolific number of custom protocols and industry standards.</p>

<p><img width=358 height=282 src="images/image002.gif"></p>

<p>In most established M2M implementations of connected devices, the data
producers and data consumers are programmed to interact in strict and well
defined ways. For example, in a smart city, sensor-based systems can alert
operators of a broken water main and report the extent of flooding in streets
and subways. Well designed open messaging technology would enable solutions
well beyond this, allowing public and private transit systems for example, to
monitor these critical alerts, adjusting their routes and even notifying
commuters and customers of alternative routes, transportation, lodging and
meals. Social networks could subscribe, allowing residents and commuters to
interact, adapt and even provide feedback and status to the city. </p>

<p>In an example like this, the M2M system monitoring the water main would not,
in its original design, have been able to communicate or interact with the
traffic systems or residents. The next generation of messaging technology will
support an architecture that enables a more spontaneous reuse and rerouting of
data with minimal programming or reconfiguration of legacy monitoring systems.</p>

<p>Open source messaging components are needed that can cater to the
serendipitous nature of data and events from the physical world around us,
accelerating and opening new markets. These components will of course have to support
the open messaging models prevalent on the Web. They will have to meet high
volume, low latency transaction requirements expected by Enterprise IT.&nbsp; At
the same time, they will have to work equally well across the constrained
networks and embedded platforms that are inherent to physical world of machine-to-machine
systems.&nbsp; This will enable a paradigm shift from legacy point-to-point
protocols and the limitations of protocols like SOAP or HTTP into more loosely
coupled yet determinable models. It will bridge the SOA, REST, Pub/Sub and
other middleware architectures already well understood by Web 2.0 and
Enterprise IT shops today, with the embedded and wireless device architectures
inherent to M2M.<br>
<img width=383 height=289 src="images/image003.gif"></p>
<br>
<h2>Scope</h2>
<p>The scope of the Paho project is to provide open source implementations of open
and standard messaging protocols that support current and emerging requirements
of M2M integration with Web and Enterprise middleware and applications.&nbsp; It
will include client implementations for use on embedded platforms along with
corresponding server support as determined by the community.</p>

<p>In order for M2M device and client developers to integrate, develop and test
messaging components end-to-end, Paho will address the development of
frameworks and sample code needed to support testing and development of end-to-end
device connectivity with a server. The project will make these available in an
Eclipse M2M sever &#8220;sandbox&#8221;, as recommended by the Eclipse M2M Industry
Working Group. &nbsp;</p>

<p>The Paho project scope includes the development of tooling that will support
effective use, integration and testing of the messaging components.</p>
<!-- 
	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.
 -->
<br>
<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>Architectural requirements for network, client and server support will be
developed with the Eclipse Machine-to-Machine Industry Working Group and will
include, but are not necessarily limited to:</p>

<ul>
	<li>Bi-directional
messaging that can handle both signals and commands from devices, as well as supporting
the provisioning and configuration of physical world systems. Bi-directional
messaging also enables an important characteristic of the next generation of
M2M solutions: the ability to configure or move processing closer to the
physical world systems as needed, in support of changing business requirements
and the constant reshaping of the Web.</li>
	<li>Determinable
delivery of messages to and from sensors, actuators, and other resource
constrained devices connected by intermittent or constrained networks.</li>
	<li>Provide
loose coupling in highly dynamic system environments where large volumes of
physical word events and messages that need to be made available to the Enterprise, Web, and other consumers in ways that may not always be anticipated. This
should include time, space and synchronization decoupling that will avoid
unnecessarily tight binding between systems.</li>
	<li>Constrained
platforms: Instrumentation of the physical world must be supported in an
extremely fragmented space where technologies, platforms and network choices
are driven by very diverse equations of cost, technology and physical constraints.</li>
</ul>
<br>
<CENTER>
<img border=0 width=859 height=266
src="images/image004.gif"></h2>
</CENTER>
<br>
<br>
<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>Eclipse has long had a focus on open tooling, runtimes, frameworks,
standards and software architecture. The Eclipse Foundation has initiated an
M2M Industry Working Group, recognizing the importance of growing and scaling
device connectivity solutions needed to realize new business opportunities and
keep markets open. Eclipse has a large and diverse membership, an established
industry presence, and a proven track record on technology projects.&nbsp; The
industry working group will provide a forum for discussing the broad topics of
machine-to-machine communications while the Paho open source project will make
implementations of advanced messaging technology readily available to M2M, Web
and Enterprise customers, working to improve adoption.&nbsp; </p>

<p>The Paho project will have relationships with Equinox and
other Eclipse projects, including the Koneki project and other tooling projects
used by embedded, enterprise and Web developers. </p>
 <br>
 
<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 initial code contribution to Paho will include &nbsp;Java and C client-side implementations
the <a
href="http://www.ibm.com/developerworks/webservices/library/ws-mqtt/index.html">MQTT
protocol</a>, contributed by IBM. MQTT is a lightweight publish/subscribe
protocol designed for mobile and remote devices, wireless connectivity, and dealing
with lossy, constrained and/or intermittent network characteristics. </p>

<p>Eurotech will contribute
the implementation of a framework and sample applications which device and
client developers can use when integrating and testing Paho messaging
components. This will require the setup of an appropriate M2M test server which
will be worked out with the Eclipse Foundation. The architecture for this
sandbox will be coordinated with the M2M Industry Working Group.</p>
 <br>
<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 known legal issues. Work will be done under EPL.</p>
 <br>
<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>Project Leader: Scott de Deugd (IBM)</dt>
	<dt>Committer: Ian Craggs (IBM)</dt>
	<dt>Committer: Chad Kienle (Eurotech)</dt>
	<dt>Committer: Dave Locke (IBM)</dt>
</dl>

<p>All listed committers authored the initial contribution.</p> 

<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.
 -->
<br>
<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>David Williams</li>
	<li>John Duimovich</li>	
</ul>
<br>
<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>Simon Archer, IBM, Eclipse Equinox</li>
 <li>James Branigan, BXI</li>
 <li>Randy Carroll, Wintergreen Technology Group</li>
 <li>Hendrik_Hoefer, MicroDoc</li>
 <li>Benjamin Cab&eacute;, Sierra Wireless</li>
 <li>Werner Keil, Eclipse UOMo</li>
</ul>
<br>
<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.
 -->
<p>November 28, 2011: Initial submission to Eclipse of MQTT Java and C client code. December
16, 2011: Stable release 1 of MQTT Java and C client code</p>
 <br>
 
<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>14-Dec-2011</td>
		<td>Added project mentors.</td>
	</tr>
	<tr>
		<td>14-Nov-2011</td>
		<td>Added Werner Keil, Eclipse UOMo to the interested parties.</td>
	</tr>
</table>
</body>
</html>