
<div id="bigbuttons">
<h3>Primary Links</h3>
<ul>
	<li><a id="buttonDownload" href="download.php" title="Download">Eclipse
	Distribution, Update Site, Dropins</a></li>
	<li><a id="buttonDocumentation" href="documentation.php"
		title="Documentation">Tutorials, Examples, Videos, Reference Documentation</a></li>
	<li><a id="buttonSupport" href="https://bugs.eclipse.org/bugs/buglist.cgi?query_format=advanced;product=UOMo;classification=Technology" title="Issues">Bug
	Tracker, Newsgroup, Professional Support</a></li>
	<li><a id="buttonInvolved" href="http://git.eclipse.org/c/uomo/org.eclipse.uomo.git/" title="Getting Involved">VCS,
	Workspace Setup, Wiki, Committers</a></li>
</ul>
</div>

<div id="midcolumn">
<h3>What is it?</h3>
	<div id="introText">
	
	<p class="left">UOMo adds <strong>Units of Measurement</strong> support to Information Technology Systems for <strong>Data</strong> and <strong>Services</strong>.</p>
	
	<p class="right"> This project has been provisioned.  You can see the proposal 
	<a href="/proposals/uomo">here</a>
	
	</p>
	
	</div>
	
	<div id="screencast">
	<!--
	<object width="640" height="480"><param name="allowfullscreen" value="true" /><param name="allowscriptaccess" value="always" /><param name="movie" value="http://vimeo.com/moogaloop.swf?clip_id=8260921&amp;server=vimeo.com&amp;show_title=0&amp;show_byline=0&amp;show_portrait=0&amp;color=DBD7EF&amp;fullscreen=1" /><embed src="http://vimeo.com/moogaloop.swf?clip_id=8260921&amp;server=vimeo.com&amp;show_title=0&amp;show_byline=0&amp;show_portrait=0&amp;color=DBD7EF&amp;fullscreen=1" type="application/x-shockwave-flash" allowfullscreen="true" allowscriptaccess="always" width="640" height="480"></embed></object>
	-->
	<img src="http://upload.wikimedia.org/wikipedia/commons/c/ca/Vitruvian_Man_Measurements.png" alt="UOMo vitruviano" border="0">
	
	</div>
	
	<!-- 
	<h3>...and yet powerful</h3>
	 -->
	<div id="feature_1">
	
	<h4>Motivation</h4>
	<p><span class="Apple-style-span" style="border-collapse: separate; color: rgb(0, 0, 0); font-style: normal; font-variant: normal; font-weight: normal; letter-spacing: normal; line-height: normal; orphans: 2; text-align: auto; text-indent: 0px; text-transform: none; white-space: normal; widows: 2; word-spacing: 0px; -webkit-border-horizontal-spacing: 0px; -webkit-border-vertical-spacing: 0px; -webkit-text-decorations-in-effect: none; -webkit-text-size-adjust: auto; -webkit-text-stroke-width: 0px;"><span class="Apple-style-span" style="line-height: 16px;">Developers frequently encounter the need to model units<span class="Apple-converted-space">&nbsp;</span><span class="searchword">of</span><span class="Apple-converted-space">&nbsp;</span>measurement, because objects in the real world are subject to these measures. When working with units, developers need to understand the mathematics<span class="Apple-converted-space">&nbsp;</span><span class="searchword">of</span><span class="Apple-converted-space">&nbsp;</span>units, how to convert between systems, and how to format and parse string representations<span class="Apple-converted-space">&nbsp;</span><span class="searchword">of</span><span class="Apple-converted-space">&nbsp;</span>units. Most<span class="Apple-converted-space">&nbsp;</span><span class="searchword">of</span><span class="Apple-converted-space">&nbsp;</span>this work can be consolidated into one or two Java packages, which is a primary aim<span class="Apple-converted-space">&nbsp;</span><span class="searchword">of</span><span class="Apple-converted-space">&nbsp;</span>this project. This project will help developers create safe, correct s<span class="searchword">of</span>tware to deal with common problem<span class="Apple-converted-space">&nbsp;</span><span class="searchword">of</span><span class="Apple-converted-space">&nbsp;</span>modeling units.</span></span></p>
	</div>
	
	<div id="feature_2">
	<h4>Data</h4>
	<ul>
	  <li>Basic implementation of <a href="http://www.unitsofmeasure.org">UCUM</a> System for use in any context</li>
	  <li>Help to incorporate units into <a href="http://www.w3.org">W3C</a> standard <a href="http://www.w3.org/TR/mathml-units/">MathML</a></li>
	  <li>Support <a href="http://www.oasis-open.org">OASIS</a> standard <a href="http://unitsml.nist.gov/">Units Markup Language (UnitsML)</a></li>
	</ul>
	  <p>&nbsp;</p>
	</div>
	
	<div id="feature_3">
	<h4>Services</h4>
	<ul>
	  <li>Strong Unit Typing (Compile time support)</li>
	  <li>HL7 Services</li>
	  <li>Financial API based on general Units of Measurement implementation </li>
	</ul>
	  <blockquote>
	  <p>The focus of the project is on <a href="http://www.oracle.com/technetwork/java/index.html">Java</a> implementations, but other languages both on a JVM or other platforms will be supported as appropriate, desired and/or contributed.</p>
	 </blockquote>
	</div>
	
	<div id="feature_more">
	<h4>&nbsp;&nbsp;&nbsp;&nbsp;...&nbsp;and more&nbsp;...</h4>
	<p><!--Read the UOMo <a href="/project/documentation.php">documentation</a> and j-->Join the discussion at the <a href="http://www.eclipse.org/forums/eclipse.uomo">forum</a> to learn more about UOMo.</p>
	<!--
	<p> Want to know more? <a href="/projects/project_summary.php?projectid=technology.uomo">About This Project</a>
	-->
	
	</div>
	
	<div id="headlines">
	   <h3>Famous quotes</h3>
	   <p>"Questo &egrave; un piccolo passo per l'<strong>uomo</strong> ... uno ... balzo gigantesco per l'umanit&agrave;"<br>
	   <em>(Neil Armstrong, July 21st, 1969) </em></p>
	</div>

</div>

<div id="rightcolumn">

  <div>
  <h3>Incubation</h3>
  <center>
    <a href="http://www.eclipse.org/projects/what-is-incubation.php">
      <img src="http://www.eclipse.org/images/egg-incubation.png" border="0" alt="Incubation"/>
    </a>
  </center>
  <p>UOMo is in the <a href="http://www.eclipse.org/projects/dev_process/incubation-phase.php">Incubation Phase</a>.</p>
  </div>

  <div id="headlines">
  <h3>New and Noteworthy</h3>
  <p>
  <a href="https://unitsofmeasurement.github.io/2019/code1jcon19-jcpaward.html">JSR 385 won JCP Award for Most Significant JSR, Spec Leads</a> 2019-09-25<br>
  <a href="http://projects.eclipse.org/projects/technology.uomo/releases/0.7.0">UOMo 0.7.0 Release</a> 2018-05-16<br>
  <a href="https://ci.eclipse.org/uomo/">Dedicated Jenkins</a> replaces Hudson instance 2017-12-31<br>  
  <a href="http://projects.eclipse.org/projects/technology.uomo/releases/0.6.1">UOMo 0.6.1 Release</a> 2017-05-28<br>
  <a href="https://hudson.eclipse.org/uomo/">Dedicated Hudson CI</a> replaces shared instance 2015-12-09<br>
  <a href="https://jcp.org/en/press/news/awards/2015award_nominees">JSR 363 won JCP Award for Most Significant JSR</a> 2015-10-26<br>
  <a href="http://codex-uomo.blogspot.com/2013/10/happy-3rd-birthday-uomo.html">Happy 3rd Birthday UOMo</a> 2013-10-20<br>
  <a href="documents/EclipseUOMoTutorial.pdf">UOMo Tutorial</a> 2013-06-10<br>
  <a href="http://projects.eclipse.org/projects/technology.uomo/releases/0.6.0">UOMo 0.6 Release Review</a> 2013-06-05<br>
  <a href="documentation.php">Updated Documentation</a> 2013-05-27<br>
  <a href="http://www.eclipse.org/org/foundation/eclipseawards/">UOMo nominated for Eclipse Awards 2013</a>, <b>please vote</b> 2013-02-01<br/>
  Happy Birthday, UOMo 2012-10-20<br>
  <a href="https://github.com/eclipse/uomo">GitHub Mirror of UOMo Repository</a> 2011-04-04<br>
  Java.net <a href="http://weblogs.java.net/blog/editor/archive/2010/12/15/chennai-jug-meeting-features-presentation-eclipse-uomo-project">wrote about UOMo</a> on 2010-12-15<br>
  Project created on 2010-10-20.</p>
  </div>

   <div class="sideitem">
       <div align="left" id="twtr-search-widget"></div>
       <script src="http://widgets.twimg.com/j/1/widget.js"></script>
       <link href="http://widgets.twimg.com/j/2/widget.css" type="text/css" rel="stylesheet">
       <script>
           new TWTR.Widget({
             search: '#eclipseuomo',
             id: 'twtr-search-widget',
             loop: true,
             title: 'What\'s being said about...',
             subject: '#EclipseUOMo',
             width: 240,
             height: 400,
             theme: {
               shell: {
                 background: '#002E62',
                 color: '#ffffff'
               },
               tweets: {
                 background: '#ffffff',
                 color: '#444444',
                 links: '#002E62'
               }
             }
           }).render().start();
       </script>
       <br/><font size=-1>Follow: <a href="http://twitter.com/wernerkeil">Werner Keil</a> (lead)
       </font>
   </div>

    <div class="sideitem">
    <!-- 
	    <script language="javascript" type="text/javascript" src="//t7.auriq.com/asp/aq_tag.js">
		</script>
		<script language="javascript" type="text/javascript">
		var myrtw_display = "ON";
		var myrtw_url = "AUTO";
		var myrtw_width = 240;
		var myrtw_height = 260;
		var myrtw_toppagecount = 3;
		var myrtw_toppagescroll = "ON";
		var myrtw_defaultview = "7DAY";
		var myrtw_extra = "";
		var myrtw_name = "rppv";
		var myrtw_key = "";
		var aqid = "MFU39GC4URSZJEWA7CNA";
		aq_tag();
		</script>
		<script language="javascript" type="text/javascript" src="http://myrt.auriq.com/widget/widget.php?a=rppv">
		</script>
	-->
	   <script language="javascript" type="text/javascript" src="//t7.auriq.com/asp/aq_tag.js">
		</script>
		<script language="javascript" type="text/javascript">
		var myrtw_display = "ON";
		var myrtw_url = "AUTO";
		var myrtw_toppagecount = 3;
		var myrtw_defaultview = "7DAY";
		var myrtw_extra = "";
		var myrtw_name = "cssrp";
		var myrtw_key = "";
		var aqid = "MFU39GC4URSZJEWA7CNA";
		aq_tag();
		</script>
		<script language="javascript" type="text/javascript" src="http://myrt.auriq.com/widget/widget.php?a=cssrp">
		</script>
    </div>
</div>