<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
    <!-- Copyright (c) 2010, Oracle and/or its affiliates. All rights reserved. -->
    <!--     Use is subject to license terms.-->
<html>
<!--
Copyright (c) 2009, 2010, 2011, 2012 Oracle and/or its affiliates. All rights reserved.
-->
    <head>
        <meta http-equiv="content-type" content="text/html; charset=utf-8">
        <title>Java ME Embedded and Java Card Learning Trail - NetBeans Tutorials, Guides and Articles</title>
        <meta name="description" content="List of resources for creating mobile applications using NetBeans IDE">
        <link rel="stylesheet" href="../../netbeans.css">
    </head>
    <body>
        <h1>Java ME Embedded and Java Card Application Technology Trail</h1>
       <h4 class="align-left">What is a Mobile Application?<a name="what"></a></h4>
        <p>Most mobile applications use the Java Micro Edition (Java ME) platform, which was developed for small devices like mobile phones, 
        but is now used on a wide variety of devices. Java ME uses scaled down subsets of Java SE components, virtual machines and APIs. 
        It also defines APIs that are specifically targeted at consumer mobile and embedded devices. NetBeans IDE supports  <a href="http://www.oracle.com/us/technologies/java/embedded/micro-edition/overview/index.html">Oracle Java ME Embedded</a> and <a href="http://www.oracle.com/technetwork/java/javame/javacard/overview/getstarted/index.html">Java Card platform</a>.</p>
     
        
          <table class="full-width">
            <tbody>
            <tr>
                <td class="valign-top half-width">  
                    <div class="trail-box">
                        <div class="trail-box-header">
                            <img src="../../images_www/v6/trails/trails-box-tr.png" width="7" height="21" class="right" alt="">
                            <img src="../../images_www/v6/trails/trails-box-tl.png" width="7" height="21" class="left"  alt="">
                            <!-- here is the box header -->
                            <h1>Getting Started</h1>
                        </div>
                        <div class="trail-box-content">
                            <ul>
                                
                               <li><a href="../docs/javame/imp-ng.html">Creating, Debugging, and Profiling a Mobile Embedded Application</a></li>
                                <li><a href="../docs/javame/java-card.html">NetBeans Java Card Development Quick Start Guide</a></li>
                            </ul>
                        </div> 
                        <div class="trail-box-bottom">
                            <img src="../../images_www/v6/trails/trails-box-br.png" width="7" height="6" class="right" alt="">
                            <img src="../../images_www/v6/trails/trails-box-bl.png" width="7" height="6" class="left" alt="">
                        </div>
                    </div>
                    
                    <div class="trail-box">
                        <div class="trail-box-header">
                            <img src="../../images_www/v6/trails/trails-box-tr.png" width="7" height="21" class="right" alt="">
                            <img src="../../images_www/v6/trails/trails-box-tl.png" width="7" height="21" class="left" alt="">
                            <!-- here is the box header -->
                            <h1>Tutorials and Articles</h1>
                        </div>
                        
                          
                           <div class="trail-box-content">
                          <p><b>Developing Java Card Applications<a name="javacard" id="javacard"></a></b></p>
                           
							<ul>
                                <li><a href="../docs/javame/javacard.html">Java Card Quick Start Article</a></li>
                                <li><a href="http://www.oracle.com/technetwork/articles/javase/javacard-servlets-136657.html" target="_blank">Deploying Servlets on Smart Cards: Portable Web Servers with Java Card 3.0</a></li>
                            </ul>  
                            
                      </div> 
                        <div class="trail-box-bottom">
                            <img src="../../images_www/v6/trails/trails-box-br.png" width="7" height="6" class="right" alt="">
                            <img src="../../images_www/v6/trails/trails-box-bl.png" width="7" height="6" class="left" alt="">
                        </div>
                    </div>
                <div class="trail-box">
                        <div class="trail-box-header">
                            <img src="../../images_www/v6/trails/trails-box-tr.png" width="7" height="21" class="right" alt="">
                            <img src="../../images_www/v6/trails/trails-box-tl.png" width="7" height="21" class="left" alt="">
                            <!-- here is the box header -->
                            <h1>Screencasts</h1>
                        </div>
                            
                            <div class="trail-box-content">
                                <ul>
								<li class="new-bullet"><a href="../docs/javame/nb_me8_screencast.html">Demo: NetBeans IDE Support for Java ME 8</a></li>
								<li class="new-bullet"><a href="../docs/javame/nb_me_plugins_screencast.html">Demo: Installing and Using Java ME SDK 8.0 Plugins in NetBeans IDE</a></li>
									<li class="new-bullet">YouTube: <a href="http://youtu.be/_1PPSt2AwpM"> Introduction into Java Micro Edition (ME) 8</a> (<em>by Terrence Bar</em>)</li>
                                    
                                    
									
                                </ul>
                                <div class="b-top-dashed align-right"><br><p>
                                        <a href="../../community/media.html">
                                            <img width="15" height="12" src="../../images_www/v6/arrow-button.gif" alt="">
                                            All Screencasts</a></p>
                                </div>
							</div>							
                            <div class="trail-box-bottom">
                                <img src="../../images_www/v6/trails/trails-box-br.png" width="7" height="6" class="right" alt="">
                                <img src="../../images_www/v6/trails/trails-box-bl.png" width="7" height="6" class="left" alt="">
                            </div>
                        
                  </div>  
					   
                </td>
                    <td class="valign-top half-width">     
                        
                        
                         
                        </div>
                        
                        <div class="trail-box">
                            <div class="trail-box-header">
                                <img src="../../images_www/v6/trails/trails-box-tr.png" width="7" height="21" class="right" alt="">
                                <img src="../../images_www/v6/trails/trails-box-tl.png" width="7" height="21" class="left" alt="">
                                <!-- here is the box header -->
                                <h1>Community-Contributed Docs</h1>
                            </div>
                            <div class="trail-box-content">
                                <ul>
                                 <li><a href="http://plugins.netbeans.org/PluginPortal/faces/PluginDetailPage.jsp?pluginid=11194" target="_blank">Installing the Blackberry RIM Plugin for NetBeans IDE</a></li>

                                    <li><a href="http://nbandroid.org/wiki/index.php/Installation" target="_blank">How to Install the Android Plugin into NetBeans</a></li>
                                    
                                </ul>
                                <div class="b-top-dashed align-right"><br><p>
                                        <a href="http://wiki.netbeans.org/CommunityDocs_Contributions" target="_blank">
                                            <img width="15" height="12" src="../../images_www/v6/arrow-button.gif" alt="">
                                            All Community-Contributed Docs                                    </a></p>
                                </div>
                            </div>
                            <div class="trail-box-bottom">
                                <img src="../../images_www/v6/trails/trails-box-br.png" width="7" height="6" class="right" alt="">
                                <img src="../../images_www/v6/trails/trails-box-bl.png" width="7" height="6" class="left" alt="">
                            </div>
                        </div>
                        
                        
                        <div class="trail-box">
                            <div class="trail-box-header">
                                <img src="../../images_www/v6/trails/trails-box-tr.png" width="7" height="21" class="right" alt="">
                                <img src="../../images_www/v6/trails/trails-box-tl.png" width="7" height="21" class="left" alt="">
                                <!-- here is the box header -->
                                <h1>Other Resources</h1>
                            </div>
                            <div class="trail-box-content">
							<ul>
				 <li><a href="http://wiki.netbeans.org/JavaMESDKSupport" target="_blank">NetBeans wiki page on Java ME SDK Support</a> </li>
				 <li class="new-bullet"><a href="http://docs.oracle.com/javame/config/cldc/rel/8/rpi/html/getstart_rpi/debugging.htm#sthref31" target="_blank"> Using NetBeans with the Raspberry Pi Board</a> in <em>Oracle® Java ME Embedded Getting Started Guide for the Reference Platform (Raspberry Pi)
Release 8 EA 2</em> </li>
				<li class="new-bullet"><a href="http://docs.oracle.com/javame/config/cldc/rel/3.3/win/gs/html/getstart_win32/setup_nbenv.htm" target="_blank"> Using the Oracle Java ME SDK Software with NetBeans</a></li>
				<li class="new-bullet"><a href="http://www.oracle.com/pls/topic/lookup?ctx=nb8000&amp;id=NBDAG1552" target="_blank"> Developing Java ME Applications</a> in <em>Developing Applications with NetBeans IDE</em></li>
				
				 </ul>
			<p><b>NetBeans Mobility Community Resources <a name="comrec" id="comrec"></a></b></p>
				<ul class="b-bottom-dashed">
				 <li><a href="http://wiki.netbeans.org/NetBeansUserFAQ#Java_ME.2FMobility" target="_blank">NetBeans Mobility FAQs</a> </li>
                 <li><a href="http://forums.netbeans.org/javame-users.html" target="_blank">NetBeans Java ME User Forum</a> </li>
                </ul> 
			 
			<p><b>Java ME Related Sites<a name="jmerel" id="jmerel"></a></b></p>
					<ul >
					<li class="new-bullet"><a href="http://www.oracle.com/technetwork/java/embedded/resources/me-embeddocs/index.html">Java ME Embedded Documentation</a></li>
					 <li><a href="http://www.oracle.com/technetwork/java/javame/index.html" target="_blank">Oracle Technology Network - Java ME Landing Page</a> </li>
                    
                   
                    </ul>
                          </div>
                            <div class="trail-box-bottom">
                                <img src="../../images_www/v6/trails/trails-box-br.png" width="7" height="6" class="right" alt="">
                                <img src="../../images_www/v6/trails/trails-box-bl.png" width="7" height="6" class="left" alt="">
                            </div>
                        </div>
                        
                    </td>
              </tr>
                
            </tbody>
        </table>
    </body>
</html>