<HTML>
<HEAD>

<!-- Browseable online at https://netbeans.org/community/news/edge-22.html -->

<title>NetBeans Edge - Issue 22 - April 2004</title>
<meta NAME="description" CONTENT="The NetBeans Edge monthly newsletter, Issue 22, April 2004">
<meta http-equiv="content-language" content="en">
<meta http-equiv="content-type" content="text/html;  charset=utf-8">


<link rel="stylesheet" type="text/css" href="/netbeans.css">
<!-- ------------------------------------------------------ -->
<!-- Please do not edit this file by hand, it is rebuilt    -->
<!-- automatically and your changes will be lost.           -->
<!-- Contact webmaster@netbeans.org for details             -->
<!-- Rebuilt at 2004 19-May 16:57 CET                       -->
<!-- ------------------------------------------------------ -->

</HEAD>
<BODY>
<center>
<table border="0" WIDTH="584" bordercolor=red cellpadding="0" cellspacing="0">



<TR>
<TD COLSPAN="3">
<table border='0' cellpadding='0' cellspacing='0' width='100%'>
<tr>
<td width='5' height='88' align='left' valign='top' background='/images_www/marketing_newsletter/template/sprout_banner_bg.gif'><img src='/images_www/marketing_newsletter/template/netbeans-edge-left.png' width='5' height='88' border='0' alt='-'></td>
<td width='100%' height='88' align='center' background='/images_www/marketing_newsletter/template/sprout_banner_bg.gif'><a href='/community/news/newsletter/index.html'><img src='/images_www/marketing_newsletter/template/netbeans-edge.png' width='574' height='88' border='0' alt='banner'></a></td>
<td width='5' height='88' align='right' valign='top' background='/images_www/marketing_newsletter/template/sprout_banner_bg.gif'><img src='/images_www/marketing_newsletter/template/netbeans-edge-right.png' width='5' height='88' border='0' alt='-'></td>
</tr>
</table>
</TD>
</TR>

<tr>
	<td width="173" valign="top" bgcolor="#205481"><a href='https://netbeans.org/'><img src="/images_www/marketing_newsletter/template/transparent-nb-logo.gif" width="173" height="50" border="0" alt="Logo" hspace="0" vspace="0"></a>
	<a href="http://services.netbeans.org/downloads/download.php?a=b&amp;p=1"><img src="/images_www/marketing_newsletter/template/download-36.gif" width="173" height="20" border="0" alt="Download" hspace="0" vspace="0"></a><br>

	<!-- left menu -->

	&nbsp;<br>
  &nbsp;<font face='Verdana, sans-serif, helvetica, arial' size='2' color='#ffffff' class='default'><b>Check this out</b></font>
	<table BORDER="0" width="170" cellpadding="0" cellspacing="0" bgcolor="#205481">
	<tr>
		<td valign="top" height="10" background="/images_www/marketing_newsletter/template/transparent_top_menu_l.gif"><img src="/images_www/pixel.gif" width="170" height="10" border="0" alt=""></td>
	</tr>
	<tr>
		<td background="/images_www/marketing_newsletter/template/transparent_middle_menu_l.gif">
		<table border='0' width="160" bgcolor="#205481">
		<td><a href='https://netbeans.org/catalogue' style='color:white'><font face='Verdana, sans-serif, helvetica, arial' size='1' color='#FFFFFF'>Module Catalogue</font></a>
<font face='Verdana, sans-serif, helvetica, arial' color='#FFFFFF' size='1'> Catalogue of free and commercial add-on modules available for your NetBeans
IDE.
<br></font> </td></tr><td><a href='http://www.java.net' style='color:white'><font face='Verdana, sans-serif, helvetica, arial' size='1' color='#FFFFFF'>java.net</font></a>
<font face='Verdana, sans-serif, helvetica, arial' color='#FFFFFF' size='1'> Java community central where NetBeans is a federated member<br></font> </td></tr><td><a href='http://services.netbeans.org/downloads/download.php?a=b&amp;p=1' style='color:white'><font face='Verdana, sans-serif, helvetica, arial' size='1' color='#FFFFFF'>New! NetBeans IDE 3.6</font></a>
<font face='Verdana, sans-serif, helvetica, arial' color='#FFFFFF' size='1'> Available for download<br></font> </td></tr><td><a href='http://developers.sun.com/prodtech/javatools/jsstandard/index.html' style='color:white'><font face='Verdana, sans-serif, helvetica, arial' size='1' color='#FFFFFF'>Sun Java Studio Portal</font></a>
<font face='Verdana, sans-serif, helvetica, arial' color='#FFFFFF' size='1'> NetBeans related resources<br></font> </td></tr>		</table>
	</td>
	</tr>
	<tr>
		<td valign="top" height="26" background="/images_www/marketing_newsletter/template/transparent_bottom_menu_l.gif"><img src="/images_www/pixel.gif" width="170" height="26" border="0" alt=""></td>
	</tr>
	</table>

	<br>&nbsp;<br>
  &nbsp;<font face='Verdana, sans-serif, helvetica, arial' size='2' color='#ffffff' class='default'><b>Hot Threads</b></font>
	<table BORDER="0" width="170" cellpadding="0" cellspacing="0">
	<tr>
		<td valign="top" height="10" background="/images_www/marketing_newsletter/template/transparent_top_menu_l.gif"><img src="/images_www/pixel.gif" width="170" height="10" border="0" alt=""></td>
	</tr>
	<tr>
		<td background="/images_www/marketing_newsletter/template/transparent_middle_menu_l.gif">
		<table border='0' width="160">
		<tr>
        <td colspan='2' valign='top'><font face='Verdana, sans-serif, helvetica, arial' style='font-size:11px;' size='1' color='#FF9542'>nbdev</font></td>
        </tr><tr>
              <td><a href='https://netbeans.org/servlets/ReadMsg?msgId=729718&listName=nbdev' style='color:#FFFFFF;'><font face='Verdana, sans-serif, helvetica, arial' color='#FFFFFF' style='font-size:11px;' size='1'>Re: "I want an IDE that manage his projects by using Ant !"</font></a></td>
              <td align='right' valign='top'><font face='Verdana, sans-serif, helvetica, arial' style='font-size:11px;' size='1' color='#FFFFFF'>36</font></td>
              </tr><tr>
              <td><a href='https://netbeans.org/servlets/ReadMsg?msgId=726363&listName=nbdev' style='color:#FFFFFF;'><font face='Verdana, sans-serif, helvetica, arial' color='#FFFFFF' style='font-size:11px;' size='1'>give me "netbeans"</font></a></td>
              <td align='right' valign='top'><font face='Verdana, sans-serif, helvetica, arial' style='font-size:11px;' size='1' color='#FFFFFF'>15</font></td>
              </tr><tr>
              <td><a href='https://netbeans.org/servlets/ReadMsg?msgId=738137&listName=nbdev' style='color:#FFFFFF;'><font face='Verdana, sans-serif, helvetica, arial' color='#FFFFFF' style='font-size:11px;' size='1'>Re: How to measure responsivness?</font></a></td>
              <td align='right' valign='top'><font face='Verdana, sans-serif, helvetica, arial' style='font-size:11px;' size='1' color='#FFFFFF'>11</font></td>
              </tr>
<tr>
        <td colspan='2' valign='top'><font face='Verdana, sans-serif, helvetica, arial' style='font-size:11px;' size='1' color='#FF9542'>nbusers</font></td>
        </tr><tr>
              <td><a href='https://netbeans.org/servlets/ReadMsg?msgId=730169&listName=nbusers' style='color:#FFFFFF;'><font face='Verdana, sans-serif, helvetica, arial' color='#FFFFFF' style='font-size:11px;' size='1'>Project Rave</font></a></td>
              <td align='right' valign='top'><font face='Verdana, sans-serif, helvetica, arial' style='font-size:11px;' size='1' color='#FFFFFF'>14</font></td>
              </tr><tr>
              <td><a href='https://netbeans.org/servlets/ReadMsg?msgId=738035&listName=nbusers' style='color:#FFFFFF;'><font face='Verdana, sans-serif, helvetica, arial' color='#FFFFFF' style='font-size:11px;' size='1'>Netbeans Linux performance</font></a></td>
              <td align='right' valign='top'><font face='Verdana, sans-serif, helvetica, arial' style='font-size:11px;' size='1' color='#FFFFFF'>12</font></td>
              </tr>
	</table>
		</td>
	</tr>
	<tr>
		<td valign="top" height="26" background="/images_www/marketing_newsletter/template/transparent_bottom_menu_l.gif"><img src="/images_www/pixel.gif" width="170" height="26" border="0" alt=""></td>
	</tr>
</table>

<!-- Update by Jack -->
	<br>&nbsp;<br>
&nbsp;<font face='Verdana, sans-serif, helvetica, arial' size='2' color='#ffffff' class='default'><b>Most Active Posters</b></font>
	<table BORDER="0" width="170" cellpadding="0" cellspacing="0">
	<tr>
		<td valign="top" height="10" background="/images_www/marketing_newsletter/template/transparent_top_menu_l.gif"><img src="/images_www/pixel.gif" width="170" height="10" border="0" alt=""></td>
	</tr>
	<tr>
		<td background="/images_www/marketing_newsletter/template/transparent_middle_menu_l.gif">
		<table border='0' width="160">
		
<tr><td><font face='Verdana, sans-serif, helvetica, arial' style='font-size:11px;' size='1' color='#FFFFFF'>Jesse Glick</font></td>
				<td align='right' valign='top'><font face='Verdana, sans-serif, helvetica, arial' style='font-size:11px;' size='1' color='#FFFFFF'>176</font></td>
				</tr><tr><td><font face='Verdana, sans-serif, helvetica, arial' style='font-size:11px;' size='1' color='#FFFFFF'>Jaroslav Tulach</font></td>
				<td align='right' valign='top'><font face='Verdana, sans-serif, helvetica, arial' style='font-size:11px;' size='1' color='#FFFFFF'>38</font></td>
				</tr><tr><td><font face='Verdana, sans-serif, helvetica, arial' style='font-size:11px;' size='1' color='#FFFFFF'>Glenn Holmer</font></td>
				<td align='right' valign='top'><font face='Verdana, sans-serif, helvetica, arial' style='font-size:11px;' size='1' color='#FFFFFF'>29</font></td>
				</tr><tr><td><font face='Verdana, sans-serif, helvetica, arial' style='font-size:11px;' size='1' color='#FFFFFF'>Trung Duc Tran</font></td>
				<td align='right' valign='top'><font face='Verdana, sans-serif, helvetica, arial' style='font-size:11px;' size='1' color='#FFFFFF'>27</font></td>
				</tr><tr><td><font face='Verdana, sans-serif, helvetica, arial' style='font-size:11px;' size='1' color='#FFFFFF'>vincent brabant</font></td>
				<td align='right' valign='top'><font face='Verdana, sans-serif, helvetica, arial' style='font-size:11px;' size='1' color='#FFFFFF'>26</font></td>
				</tr>		</table>
		</td>
	</tr>
	<tr>
		<td valign="top" height="26" background="/images_www/marketing_newsletter/template/transparent_bottom_menu_l.gif"><img src="/images_www/pixel.gif" width="170" height="26" border="0" alt=""></td>
	</tr>
</table>

<br>&nbsp;<br>
&nbsp;<font face='Verdana, sans-serif, helvetica, arial' size='2' color='#ffffff' class='default'><b>Statistics: April</b></font>
<table BORDER="0" width="170" cellpadding="0" cellspacing="0">
	<tr>
		<td valign="top" height="10" background="/images_www/marketing_newsletter/template/transparent_top_menu_l.gif"><img src="/images_www/pixel.gif" width="170" height="10" border="0" alt=""></td>
	</tr>
	<tr>
		<td background="/images_www/marketing_newsletter/template/transparent_middle_menu_l.gif">
		<table border='0' width="160">
		<tr>
<td colspan='2' valign='top'><font face='Verdana, sans-serif, helvetica, arial' style='font-size:11px;' size='1' color='#FF9542'>IDE Downloads</font></td>
</tr>
<tr>
<td colspan='2' valign='top'><font face='Verdana, sans-serif, helvetica, arial' style='font-size:11px;' size='1' color='#FFFFFF'>Total: 1,345,614; +83,588</font></td>
</tr>
<tr>
<td colspan='2' valign='top'><font face='Verdana, sans-serif, helvetica, arial' style='font-size:11px;' size='1' color='#FF9542'>Platform Downloads</font></td>
</tr>
<tr>
<td colspan='2' valign='top'><font face='Verdana, sans-serif, helvetica, arial' style='font-size:11px;' size='1' color='#FFFFFF'>Total: 45,540; +3,776</font></td>
</tr>
<tr>
<td colspan='2' valign='top'><font face='Verdana, sans-serif, helvetica, arial' style='font-size:11px;' size='1' color='#FF9542'>Subscribers</font></td>
</tr>
<tr>
<td colspan='2' valign='top'><font face='Verdana, sans-serif, helvetica, arial' style='font-size:11px;' size='1' color='#FFFFFF'>Total: 39,662; +19,817</font></td>
</tr>
<tr>
<td colspan='2' valign='top'><font face='Verdana, sans-serif, helvetica, arial' style='font-size:11px;' size='1' color='#FF9542'>Messages Posted</font></td>
</tr>
<tr>
<td colspan='2' valign='top'><font face='Verdana, sans-serif, helvetica, arial' style='font-size:11px;' size='1' color='#FFFFFF'>+4,008</font></td>
</tr>
		</table>
		</td>
	</tr>
	<tr>
		<td valign="top" height="26" background="/images_www/marketing_newsletter/template/transparent_bottom_menu_l.gif"><img src="/images_www/pixel.gif" width="170" height="26" border="0" alt=""></td>
	</tr>
</table>

	<!-- left menu -->




	</td>

<!--
	<td valign="top" height='82' colspan="2" align="right"><img src="/images_www/marketing_newsletter/template/banner.jpg" width="411" height="82" border="0" alt="Banner" hspace="0" vspace="0"></td>
</tr>
<tr>
-->

	<td bgcolor="#FFF0D4" width="410" valign='top'>

	<table border='0' width="100%">
	<tr>
  <td><a href='/community/news/edge-22_fr.html'><img src='/images_www/flags/fr_small.gif' width='20' height='13' alt='French Edition' border='0'></a>&nbsp;<a href='/community/news/edge-22_nl.html'><img src='/images_www/flags/nl_small.gif' width='20' height='13' alt='Dutch Edition' border='0'></a>&nbsp;<a href='/community/news/edge-22_pt.html'><img src='/images_www/flags/pt_small.gif' width='20' height='13' alt='Portuguese Edition' border='0'></a>&nbsp;<a href='/community/news/edge-22_ru.html'><img src='/images_www/flags/ru_small.gif' width='20' height='13' alt='Russian Edition' border='0'></a>&nbsp;</td>  <td align='right'><font face='Verdana, sans-serif, helvetica, arial' ><b>Issue 22</b></font></td></tr>
	</table>

	<table border='0' width='100%' cellspacing='3' cellpadding='3'>
  <tr>
  <td align='center'><table border='0' cellpadding='0' cellspacing='0' width='98%'>
      <tr class='tabler' bgcolor='#ffffff'>
      <TD  VALIGN='TOP' class='tabler' bgcolor='#ffffff'><IMG SRC='/images_www/marketing_newsletter/template/top-left.gif' WIDTH='12' HEIGHT='17' ALT=''></TD>
      <td>&nbsp;</td>
      <td align='right'>&nbsp;</td>
      <TD  VALIGN='TOP' class='tabler' align='right' bgcolor='#ffffff'><IMG SRC='/images_www/marketing_newsletter/template/top-right.gif' WIDTH='12' HEIGHT='17' ALT=''></TD>
      </tr>
      <tr class='tabler' bgcolor='#ffffff'>
      <td class='tabler' bgcolor='#ffffff'><IMG SRC='/images_www/pixel.gif' WIDTH='12' HEIGHT='1' ALT=''></td>
      <td colspan='2'><a name='s186'></a><font face='Verdana, sans-serif, helvetica, arial' color='#FF0F12' class='titlec'><b>NetBeans Edge, Issue 22</b></font><br>&nbsp;<br><font face='Verdana, sans-serif, helvetica, arial' >Get Involved!
<br>
By Steve Wilson, Engineering Director, Sun Microsystems
<p>
The NetBeans community is growing by leaps and bounds.  In the past six months, the number of subscribers on our mailing lists have grown from about 5,000 to 40,000!  With this many new members of the community I thought it would be work talking about all the ways you can get better involved with what's going on.  There are a number of ways you can get involved today and we're working on even more options, no matter what level of time commitment you'd like to provide.
<p>
Use the IDE and Tell a Friend!
Our goal is to have as many users as possible using the technology produced at NetBeans.org.  The most basic way you can be part of the community is to let people know you like the technology.
<p>
Discuss the Future!
Most of the people on our mailing lists are subscribed to the "announce" list -- which is only one-way communication.  However, there are numerous lists where users and developers discuss a wide range of topics.  For a lists of some of the most interesting lists <a href="https://netbeans.org/community/lists/top.html">you can go here</a>.

<p>The "nbdiscuss" list is a great place to make your voice heard on things you'd like to see happen with this community going forward.  Discussions on "nbusers" and "nbdev" have recently been having a big impact on the design of NetBeans 4.0 features, such as the new build system.  Make your voice heard.
<p>
Dive Right In!<br>
If you're using NetBeans then you're a Java developer.  The IDE is designed to be modular so that people can add features and functionality without hacking on the core IDE.  Recently the team developing the Web Apps support asked for help implementing a feature to test compile JSP pages.  Developer Illya Kysil offered to pitch in and has built an initial version of this module that users can try.  Thanks Illya!
<p>
What's Next?<br>
Over the next few months we're going to be rolling out more and better ways to get involved.  We want to make it easier for you to contribute so that everyone gets a better experience.  If you have suggestions for how we can improve then why don't you post to nbdiscuss and let us know your ideas?</font></td>
      <td><IMG SRC='/images_www/pixel.gif' WIDTH='12' HEIGHT='1' ALT=''></td>
      </tr>
      <tr class='tabler' bgcolor='#ffffff'><td colspan='4'>&nbsp;</td></tr>
      <tr class='tabler' bgcolor='#ffffff'>
      <TD  VALIGN='bottom' class='tabler' bgcolor='#ffffff'><IMG SRC='/images_www/pixel.gif' WIDTH='1' HEIGHT='1' ALT=''></TD>
      <td>&nbsp;</td>
      <td align='right'><font face='Verdana, sans-serif, helvetica, arial' >&nbsp;Steve Wilson</font></td>
      <TD  VALIGN='bottom' class='tabler' bgcolor='#ffffff'><IMG SRC='/images_www/pixel.gif' WIDTH='1' HEIGHT='1' ALT=''></TD>
      </tr>
      <tr class='tabler' bgcolor='#ffffff'>
      <TD  VALIGN='bottom' class='tabler' bgcolor='#ffffff'><IMG SRC='/images_www/marketing_newsletter/template/bottom-left.gif' WIDTH='12' HEIGHT='17' ALT=''></TD>
      <TD  colspan='2' VALIGN='bottom' class='tabler' bgcolor='#ffffff'><IMG SRC='/images_www/pixel.gif' WIDTH='1' HEIGHT='1' ALT=''></TD>
      <TD  aligm='right' VALIGN='bottom' class='tabler' bgcolor='#ffffff'><IMG SRC='/images_www/marketing_newsletter/template/bottom-right.gif' WIDTH='12' HEIGHT='17' ALT=''></TD>
      </tr>
      </table><img src='/images_www/pixel.gif' width='1' height='4' bolder='0'><table border='0' cellpadding='0' cellspacing='0' width='98%'>
      <tr class='tabler' bgcolor='#ffffff'>
      <TD  VALIGN='TOP' class='tabler' bgcolor='#ffffff'><IMG SRC='/images_www/marketing_newsletter/template/top-left.gif' WIDTH='12' HEIGHT='17' ALT=''></TD>
      <td>&nbsp;</td>
      <td align='right'>&nbsp;</td>
      <TD  VALIGN='TOP' class='tabler' align='right' bgcolor='#ffffff'><IMG SRC='/images_www/marketing_newsletter/template/top-right.gif' WIDTH='12' HEIGHT='17' ALT=''></TD>
      </tr>
      <tr class='tabler' bgcolor='#ffffff'>
      <td class='tabler' bgcolor='#ffffff'><IMG SRC='/images_www/pixel.gif' WIDTH='12' HEIGHT='1' ALT=''></td>
      <td colspan='2'><a name='s189'></a><font face='Verdana, sans-serif, helvetica, arial' color='#FF0F12' class='titlec'><b>NetBeans Day</b></font><br>&nbsp;<br><font face='Verdana, sans-serif, helvetica, arial' >The first ever NetBeans Day conference will be taking place at JavaOne.
<p>
On Tuesday, June 29, 2004, we'll be having a companion event to JavaOne that will feature the NetBeans Project including a preview of the latest release, inside NetBeans technology and will also feature key NetBeans Partners.  
<p>
The keynote will feature James Gosling talking about Tools and the future.  And if you've seen James talk, you know they'll be some great surprises. This is not to be missed!
<p>
Whether or not you're planning to sign up for a full JavaOne pass, registration for NetBeans Day is free. And, as a special bonus if you're thinking about signing up for a full JavaOne pass then you can receive a special $300 discount as a member of the NetBeans community. 
<p>
This is great time hear from key Sun technical staff who manage the NetBeans project, to learn about the technology and the roadmap. Additionally we'll be featuring NetBeans partners that help make NetBeans a thriving ecosystem. Meet you fellow NetBeans enthusiasts and learn those invaluable shared knowledge tips.
<p>
We'll be conveniently located in the Yerba Buena Theater which is adjacent to the Moscone Convention Centers entrances. The proposed schedule of events:
<p>
<table cellpadding="2" cellspacing="2">

<tr class="tablerbg">
<td class="smalltext"><B>Time</b></td>
<td class="smalltext"><B>Title</b></td>
<td class="smalltext"><B>Speakers</b></td>
</tr>

<tr class="tablersh">
<td class="smalltext">9:00 AM</td>
<td class="smalltext">Registration</td>
<td class="smalltext"> </td>

<tr>
<td class="smalltext">10:00 AM</td>
<td class="smalltext">Keynote: The Future of Open Source Dev Tools</td>
<td class="smalltext">James Gosling, Steve Wilson</td>
</tr>

<tr class="tablersh">
<td class="smalltext">11:00 AM</td>
<td class="smalltext">Advances in NetBeans Technology</td>
<td class="smalltext">Ian Formanek, Tim Boudreau, Jesse Glick</td>
</tr>

<tr>
<td class="smalltext">12:00 PM</td>
<td class="smalltext">NetBeans Plug-in Development brownbag</td>
<td class="smalltext">Jesse Glick, Tim Boudreau</td>
</tr>

<tr class="tablersh">
<td class="smalltext">1:00 PM</td>
<td class="smalltext">NetBeans Solutions  I</td>
<td class="smalltext">Moderator + Partners</td>
</tr>

<tr>
<td class="smalltext">2:00 PM</td>
<td class="smalltext">Building Web Applications with NetBeans</td>
<td class="smalltext">Anna Von Klopp, Pavel Buzek, Chris Kutler</td>
</tr>

<tr class="tablersh">
<td class="smalltext">3:00 PM</td>
<td class="smalltext">NetBeans Solutions  II</td>
<td class="smalltext">Moderator + Partners</td>
</tr>

<tr>
<td class="smalltext">4:00 PM</td>
<td class="smalltext">Building Mobile Applications with NetBeans</td>
<td class="smalltext">Martin Ryzl</td>
</tr>

<tr class="tablersh">
<td class="smalltext">5:00 PM</td>
<td class="smalltext">BOF: NetBeans Community Development and Marketing</td>
<td class="smalltext">Zaheda Bhorat, Larry Baron, Robert Demmer</td>
</tr>

<tr>
<td class="smalltext">6:00-8:00 PM</td>
<td class="smalltext">Sun Tools Event</td>
<td class="smalltext">Refreshements, awards, demos and more</td>
</tr>

</table>

<p><b>Register</b> for the free NetBeans Day event, or for a discounted full JavaOne pass at <a href="https://www.javaone04.com/portal/reg.jsp?code=NetBeans">the JavaOne Registration site</a>.</font></td>
      <td><IMG SRC='/images_www/pixel.gif' WIDTH='12' HEIGHT='1' ALT=''></td>
      </tr>
      <tr class='tabler' bgcolor='#ffffff'><td colspan='4'>&nbsp;</td></tr>
      <tr class='tabler' bgcolor='#ffffff'>
      <TD  VALIGN='bottom' class='tabler' bgcolor='#ffffff'><IMG SRC='/images_www/pixel.gif' WIDTH='1' HEIGHT='1' ALT=''></TD>
      <td><font face='Verdana, sans-serif, helvetica, arial' >[latest details]</font>&nbsp;</td>
      <td align='right'><font face='Verdana, sans-serif, helvetica, arial' >&nbsp;Larry Baron</font></td>
      <TD  VALIGN='bottom' class='tabler' bgcolor='#ffffff'><IMG SRC='/images_www/pixel.gif' WIDTH='1' HEIGHT='1' ALT=''></TD>
      </tr>
      <tr class='tabler' bgcolor='#ffffff'>
      <TD  VALIGN='bottom' class='tabler' bgcolor='#ffffff'><IMG SRC='/images_www/marketing_newsletter/template/bottom-left.gif' WIDTH='12' HEIGHT='17' ALT=''></TD>
      <TD  colspan='2' VALIGN='bottom' class='tabler' bgcolor='#ffffff'><IMG SRC='/images_www/pixel.gif' WIDTH='1' HEIGHT='1' ALT=''></TD>
      <TD  aligm='right' VALIGN='bottom' class='tabler' bgcolor='#ffffff'><IMG SRC='/images_www/marketing_newsletter/template/bottom-right.gif' WIDTH='12' HEIGHT='17' ALT=''></TD>
      </tr>
      </table><img src='/images_www/pixel.gif' width='1' height='4' bolder='0'><table border='0' cellpadding='0' cellspacing='0' width='98%'>
      <tr class='tabler' bgcolor='#ffffff'>
      <TD  VALIGN='TOP' class='tabler' bgcolor='#ffffff'><IMG SRC='/images_www/marketing_newsletter/template/top-left.gif' WIDTH='12' HEIGHT='17' ALT=''></TD>
      <td>&nbsp;</td>
      <td align='right'>&nbsp;</td>
      <TD  VALIGN='TOP' class='tabler' align='right' bgcolor='#ffffff'><IMG SRC='/images_www/marketing_newsletter/template/top-right.gif' WIDTH='12' HEIGHT='17' ALT=''></TD>
      </tr>
      <tr class='tabler' bgcolor='#ffffff'>
      <td class='tabler' bgcolor='#ffffff'><IMG SRC='/images_www/pixel.gif' WIDTH='12' HEIGHT='1' ALT=''></td>
      <td colspan='2'><a name='s191'></a><font face='Verdana, sans-serif, helvetica, arial' color='#FF0F12' class='titlec'><b>NetBeans IDE 3.6 Multilingual Cobundle</b></font><br>&nbsp;<br><font face='Verdana, sans-serif, helvetica, arial' >The Chinese and Japanese NetBeans IDE 3.6 multilingual release is <a href="http://services.netbeans.org/downloads/download.php?a=b&amp;p=1">now available for immediate download</a>

<p>Localised Documents include:</p>
<p>Installation Guide: <a href="https://netbeans.org/community/releases/36/install_zh_CN.html">Chinese</a>, <a href="https://netbeans.org/community/releases/36/install_ja.html">Japanese</a>
<br>Release Notes: <a href="https://netbeans.org/community/releases/36/relnotes_zh_CN.html">Chinese</a>, <a href="https://netbeans.org/community/releases/36/relnotes_ja.html">Japanese</a>
<br>What's New in NetBeans 3.6? <a href="https://netbeans.org/community/releases/36/Whats_New_zh_CN.html">Chinese</a>, <a href="https://netbeans.org/community/releases/36/Whats_New_ja.html">Japanese</a>
<br>GUI Building in NetBeans IDE 3.6: <a href="https://netbeans.org/kb/archive/index.html">Chinese</a>, <a href="https://netbeans.org/kb/archive/index.html">Japanese</a>
<br>NetBeans IDE 3.6 Quick Start Guide: <a href="https://netbeans.org/kb/archive/index.html">Chinese</a>, <a href="https://netbeans.org/kb/archive/index.html">Japanese</a>
<br>Using NetBeans 3.6: <a href="https://netbeans.org/kb/archive/index.html">Chinese</a>, <a href="https://netbeans.org/kb/archive/index.html">Japanese</a>
</p>

<p>You can also subscribe to the <a href="https://netbeans.org/community/lists/top.html">Chinese discussion list</a> (nbdiscuss_zh@netbeans.org) and/or the <a href="http://www.netbeans.jp/mailinglist.htm">Japanese discussion list</a> for more support.</p></font></td>
      <td><IMG SRC='/images_www/pixel.gif' WIDTH='12' HEIGHT='1' ALT=''></td>
      </tr>
      <tr class='tabler' bgcolor='#ffffff'><td colspan='4'>&nbsp;</td></tr>
      <tr class='tabler' bgcolor='#ffffff'>
      <TD  VALIGN='bottom' class='tabler' bgcolor='#ffffff'><IMG SRC='/images_www/pixel.gif' WIDTH='1' HEIGHT='1' ALT=''></TD>
      <td><font face='Verdana, sans-serif, helvetica, arial' >[<a href='https://netbeans.org/kb/' target='new'>support & docs</a>]</font>&nbsp;</td>
      <td align='right'><font face='Verdana, sans-serif, helvetica, arial' >&nbsp;</font></td>
      <TD  VALIGN='bottom' class='tabler' bgcolor='#ffffff'><IMG SRC='/images_www/pixel.gif' WIDTH='1' HEIGHT='1' ALT=''></TD>
      </tr>
      <tr class='tabler' bgcolor='#ffffff'>
      <TD  VALIGN='bottom' class='tabler' bgcolor='#ffffff'><IMG SRC='/images_www/marketing_newsletter/template/bottom-left.gif' WIDTH='12' HEIGHT='17' ALT=''></TD>
      <TD  colspan='2' VALIGN='bottom' class='tabler' bgcolor='#ffffff'><IMG SRC='/images_www/pixel.gif' WIDTH='1' HEIGHT='1' ALT=''></TD>
      <TD  aligm='right' VALIGN='bottom' class='tabler' bgcolor='#ffffff'><IMG SRC='/images_www/marketing_newsletter/template/bottom-right.gif' WIDTH='12' HEIGHT='17' ALT=''></TD>
      </tr>
      </table><img src='/images_www/pixel.gif' width='1' height='4' bolder='0'><table border='0' cellpadding='0' cellspacing='0' width='98%'>
      <tr class='tabler' bgcolor='#ffffff'>
      <TD  VALIGN='TOP' class='tabler' bgcolor='#ffffff'><IMG SRC='/images_www/marketing_newsletter/template/top-left.gif' WIDTH='12' HEIGHT='17' ALT=''></TD>
      <td>&nbsp;</td>
      <td align='right'>&nbsp;</td>
      <TD  VALIGN='TOP' class='tabler' align='right' bgcolor='#ffffff'><IMG SRC='/images_www/marketing_newsletter/template/top-right.gif' WIDTH='12' HEIGHT='17' ALT=''></TD>
      </tr>
      <tr class='tabler' bgcolor='#ffffff'>
      <td class='tabler' bgcolor='#ffffff'><IMG SRC='/images_www/pixel.gif' WIDTH='12' HEIGHT='1' ALT=''></td>
      <td colspan='2'><a name='s187'></a><font face='Verdana, sans-serif, helvetica, arial' color='#FF0F12' class='titlec'><b>Module Catalogue</b></font><br>&nbsp;<br><img src='/images_www/marketing_newsletter/36.gif' widht='100' height='100' border='0' alt='Catalogue - 7k' align='left' vspace='2' hspace='10'><font face='Verdana, sans-serif, helvetica, arial' ><b>nbxsl</b> - XML
<p><a href="http://www.japisoft.com/nbxslt/">JAPISoft</a> has released nbxsl v1.0 which is a new module for editing XSLT with fast result view and XPath evaluation. Follow <a href="http://plugins.netbeans.org/">here</a> for more information including a link to the free evaluation.</p>

<b>RefactorIt</b>
<p>In other module news RefactorIT 2.0 RC2 (build 1.9.15) is now available. 2.0 RC2 now works well with the NetBeans IDE 3.6. Here is what's new: 
<ul><li>4 all new Quality Metrics: DIP, DCYC, EP, LSP (whereas, every single Metric has a recommended interval and violations are colored appropriately in the results table)</li>
<li>"Freeze" option was added to the Draw Dependencies</li>
<li>many bug fixes and usability improvements</li></ul>

For more information on RefactorIT 2.0 RC2 please visit our <a href="https://netbeans.org/community/news/index.html#448">news entry</a> on NetBeans.org or <a href="http://www.refactorit.com">www.refactorit.com</a>.</p>

</font></td>
      <td><IMG SRC='/images_www/pixel.gif' WIDTH='12' HEIGHT='1' ALT=''></td>
      </tr>
      <tr class='tabler' bgcolor='#ffffff'><td colspan='4'>&nbsp;</td></tr>
      <tr class='tabler' bgcolor='#ffffff'>
      <TD  VALIGN='bottom' class='tabler' bgcolor='#ffffff'><IMG SRC='/images_www/pixel.gif' WIDTH='1' HEIGHT='1' ALT=''></TD>
      <td><font face='Verdana, sans-serif, helvetica, arial' >[<a href='https://netbeans.org/catalogue' target='new'>module catalogue</a>]</font>&nbsp;</td>
      <td align='right'><font face='Verdana, sans-serif, helvetica, arial' >&nbsp;</font></td>
      <TD  VALIGN='bottom' class='tabler' bgcolor='#ffffff'><IMG SRC='/images_www/pixel.gif' WIDTH='1' HEIGHT='1' ALT=''></TD>
      </tr>
      <tr class='tabler' bgcolor='#ffffff'>
      <TD  VALIGN='bottom' class='tabler' bgcolor='#ffffff'><IMG SRC='/images_www/marketing_newsletter/template/bottom-left.gif' WIDTH='12' HEIGHT='17' ALT=''></TD>
      <TD  colspan='2' VALIGN='bottom' class='tabler' bgcolor='#ffffff'><IMG SRC='/images_www/pixel.gif' WIDTH='1' HEIGHT='1' ALT=''></TD>
      <TD  aligm='right' VALIGN='bottom' class='tabler' bgcolor='#ffffff'><IMG SRC='/images_www/marketing_newsletter/template/bottom-right.gif' WIDTH='12' HEIGHT='17' ALT=''></TD>
      </tr>
      </table><img src='/images_www/pixel.gif' width='1' height='4' bolder='0'><table border='0' cellpadding='0' cellspacing='0' width='98%'>
      <tr class='tabler' bgcolor='#ffffff'>
      <TD  VALIGN='TOP' class='tabler' bgcolor='#ffffff'><IMG SRC='/images_www/marketing_newsletter/template/top-left.gif' WIDTH='12' HEIGHT='17' ALT=''></TD>
      <td>&nbsp;</td>
      <td align='right'>&nbsp;</td>
      <TD  VALIGN='TOP' class='tabler' align='right' bgcolor='#ffffff'><IMG SRC='/images_www/marketing_newsletter/template/top-right.gif' WIDTH='12' HEIGHT='17' ALT=''></TD>
      </tr>
      <tr class='tabler' bgcolor='#ffffff'>
      <td class='tabler' bgcolor='#ffffff'><IMG SRC='/images_www/pixel.gif' WIDTH='12' HEIGHT='1' ALT=''></td>
      <td colspan='2'><a name='s188'></a><font face='Verdana, sans-serif, helvetica, arial' color='#FF0F12' class='titlec'><b>New Articles</b></font><br>&nbsp;<br><font face='Verdana, sans-serif, helvetica, arial' >The <a href="https://netbeans.org/kb/archive/index.html">Midnight Cookie Web Apps Tutorial</a> illustrates the use of a Front Controller servlet and a composite view within a page created with the JavaServer Pages technology (JSP). The JSP pages in this application use JavaServer Pages Standard Tag Library (JSTL).  For the tutuorial you may use the NetBeans IDE 3.5 or 3.6 and J2SE 1.3 or 1.4.

<p>Building Web Modules With NetBeans: Transitioning from 3.5 to 3.6 - This article discusses the new features in NetBeans 3.6 for building web modules. It then discusses changes to previously existing features that might affect the way you do your work. Last, it lists known bugs and provides some tips.</p>

<p><a href="https://netbeans.org/kb/archive/index.html">Web Module Quick Start Guide</a> - This document takes you through the basics of developing, testing, and debugging a web module by creating a simple coin toss application. This document is designed to get you going as quickly as possible.</p>

<p><a href="https://netbeans.org/community/releases/36/J2ME_Support.html">Adding J2ME Platform Support to the NetBeans IDE</a> - Updating the NetBeans IDE with the Mobility Modules for NetBeans integrates support for developing and testing applications for mobile devices that use the Java 2, Micro Edition (J2ME) platform. 

<p><a href="https://netbeans.org/kb/articles/j2me_tutorial.html">Mobility Modules Tutorial</a> - The Mobility Modules Tutorial guides you through the process of creating and debugging a MIDP/CLDC application, or "MIDLet," using the Mobility Modules and the NetBeans IDE. Click the following link to open the tutorial:


</font></td>
      <td><IMG SRC='/images_www/pixel.gif' WIDTH='12' HEIGHT='1' ALT=''></td>
      </tr>
      <tr class='tabler' bgcolor='#ffffff'><td colspan='4'>&nbsp;</td></tr>
      <tr class='tabler' bgcolor='#ffffff'>
      <TD  VALIGN='bottom' class='tabler' bgcolor='#ffffff'><IMG SRC='/images_www/pixel.gif' WIDTH='1' HEIGHT='1' ALT=''></TD>
      <td><font face='Verdana, sans-serif, helvetica, arial' >[<a href='https://netbeans.org/kb/kb.html' target='new'>more articles</a>]</font>&nbsp;</td>
      <td align='right'><font face='Verdana, sans-serif, helvetica, arial' >&nbsp;</font></td>
      <TD  VALIGN='bottom' class='tabler' bgcolor='#ffffff'><IMG SRC='/images_www/pixel.gif' WIDTH='1' HEIGHT='1' ALT=''></TD>
      </tr>
      <tr class='tabler' bgcolor='#ffffff'>
      <TD  VALIGN='bottom' class='tabler' bgcolor='#ffffff'><IMG SRC='/images_www/marketing_newsletter/template/bottom-left.gif' WIDTH='12' HEIGHT='17' ALT=''></TD>
      <TD  colspan='2' VALIGN='bottom' class='tabler' bgcolor='#ffffff'><IMG SRC='/images_www/pixel.gif' WIDTH='1' HEIGHT='1' ALT=''></TD>
      <TD  aligm='right' VALIGN='bottom' class='tabler' bgcolor='#ffffff'><IMG SRC='/images_www/marketing_newsletter/template/bottom-right.gif' WIDTH='12' HEIGHT='17' ALT=''></TD>
      </tr>
      </table><img src='/images_www/pixel.gif' width='1' height='4' bolder='0'></td>
  </tr>
  </table>
	</td>
	<TD width="1" bgcolor="#205481"><IMG SRG="/images_www/pixel.gif" width="1" height="850" src="/images_www/pixel.gif" border="0" alt=""></TD>
</tr>
<tr>
<td height='5' bgcolor="#205481"><img src='/images_www/marketing_newsletter/template/sprout_b_l.gif' width='5' height='5' border='0' alt='-'></td>
<td colspan='2' height='5' align='right' background='/images_www/marketing_newsletter/template/sprout_b_c.gif'><img src='/images_www/marketing_newsletter/template/sprout_b_r.gif' width='5' height='5' border='0' alt='-'></td>
</tr>

</table>
</center>
</BODY>
</HTML>
