<HTML>
<HEAD>

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

<title>NetBeans Edge - Issue 26 - April 2005</title>
<meta NAME="description" CONTENT="The NetBeans Edge monthly newsletter, Issue 26, April 2005">
<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 2005 02-May 12:42 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-40.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='http://plugins.netbeans.org/' 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&p=1' style='color:white'><font face='Verdana, sans-serif, helvetica, arial' size='1' color='#FFFFFF'>NetBeans IDE 4.0</font></a>
<font face='Verdana, sans-serif, helvetica, arial' color='#FFFFFF' size='1'> Available for download<br></font> </td></tr><td><a href='https://netbeans.org/community/releases/41/' style='color:white'><font face='Verdana, sans-serif, helvetica, arial' size='1' color='#FFFFFF'>NetBeans IDE 4.1 Release Candidate</font></a>
<font face='Verdana, sans-serif, helvetica, arial' color='#FFFFFF' size='1'> Upcoming NetBeans release<br></font> </td></tr><td><a href='http://developers.sun.com/prodtech/javatools/jsenterprise/index.html' style='color:white'><font face='Verdana, sans-serif, helvetica, arial' size='1' color='#FFFFFF'>Sun Java Studio Enterprise</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'>nbusers</font></td>
        </tr><tr>
              <td><a href='https://netbeans.org/servlets/ReadMsg?msgId=51964&listName=nbusers' style='color:#FFFFFF;'><font face='Verdana, sans-serif, helvetica, arial' color='#FFFFFF' style='font-size:11px;' size='1'>Debate: Why not make "Fix Imports" automatic</font></a></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><a href='https://netbeans.org/servlets/ReadMsg?msgId=52405&listName=nbusers' style='color:#FFFFFF;'><font face='Verdana, sans-serif, helvetica, arial' color='#FFFFFF' style='font-size:11px;' size='1'>NetBeans hang</font></a></td>
              <td align='right' valign='top'><font face='Verdana, sans-serif, helvetica, arial' style='font-size:11px;' size='1' color='#FFFFFF'>19</font></td>
              </tr><tr>
              <td><a href='https://netbeans.org/servlets/ReadMsg?msgId=51652&listName=nbusers' style='color:#FFFFFF;'><font face='Verdana, sans-serif, helvetica, arial' color='#FFFFFF' style='font-size:11px;' size='1'>Netbeans 5.0</font></a></td>
              <td align='right' valign='top'><font face='Verdana, sans-serif, helvetica, arial' style='font-size:11px;' size='1' color='#FFFFFF'>16</font></td>
              </tr>
<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=29890&listName=nbdev' style='color:#FFFFFF;'><font face='Verdana, sans-serif, helvetica, arial' color='#FFFFFF' style='font-size:11px;' size='1'>Split of openide into smaller logical pieces</font></a></td>
              <td align='right' valign='top'><font face='Verdana, sans-serif, helvetica, arial' style='font-size:11px;' size='1' color='#FFFFFF'>24</font></td>
              </tr>
<tr>
        <td colspan='2' valign='top'><font face='Verdana, sans-serif, helvetica, arial' style='font-size:11px;' size='1' color='#FF9542'>openide</font></td>
        </tr><tr>
              <td><a href='https://netbeans.org/servlets/ReadMsg?msgId=15459&listName=openide' style='color:#FFFFFF;'><font face='Verdana, sans-serif, helvetica, arial' color='#FFFFFF' style='font-size:11px;' size='1'>Detecting first run?</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>
	</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'>183</font></td>
				</tr><tr><td><font face='Verdana, sans-serif, helvetica, arial' style='font-size:11px;' size='1' color='#FFFFFF'>Chuck Davis</font></td>
				<td align='right' valign='top'><font face='Verdana, sans-serif, helvetica, arial' style='font-size:11px;' size='1' color='#FFFFFF'>48</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'>45</font></td>
				</tr><tr><td><font face='Verdana, sans-serif, helvetica, arial' style='font-size:11px;' size='1' color='#FFFFFF'>Rich Unger</font></td>
				<td align='right' valign='top'><font face='Verdana, sans-serif, helvetica, arial' style='font-size:11px;' size='1' color='#FFFFFF'>43</font></td>
				</tr><tr><td><font face='Verdana, sans-serif, helvetica, arial' style='font-size:11px;' size='1' color='#FFFFFF'>Chuck Williams</font></td>
				<td align='right' valign='top'><font face='Verdana, sans-serif, helvetica, arial' style='font-size:11px;' size='1' color='#FFFFFF'>35</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: 2,200,466; +66,234</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: 90,187; +2,316</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: 0; +-194,921</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'>+1,217</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-26_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-26_nl.html'><img src='/images_www/flags/nl_small.gif' width='20' height='13' alt='Dutch Edition' border='0'></a>&nbsp;</td>  <td align='right'><font face='Verdana, sans-serif, helvetica, arial' ><b>Issue 26</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='s222'></a><font face='Verdana, sans-serif, helvetica, arial' color='#FF0F12' class='titlec'><b>NetBeans Edge, Issue 26</b></font><br>&nbsp;<br><font face='Verdana, sans-serif, helvetica, arial' ><p>The NetBeans.org project is kicking into high gear. Building on the success of the 4.0 release, NetBeans IDE 4.1 Release Candidate is now available with the final version coming in mid-May. Take it for a test run and share your thoughts with the rest of the community on the NetBeans <a href="https://netbeans.org/community/lists/top.html">mailing lists</a>.

<p>In this issue learn how to Unleash the Power of NetBeans. NetBeans IDE 4.1 Release Candidate / Sun Java System Application Server PE 8.1 Bundle + NetBeans Mobility Pack 4.1 Release Candidate + NetBeans Profiler Milestone 6 = One hell of a development tool!

<p>First, I would like to take this opportunity to share some of the other news going on around the NetBeans.org project. There are several contributors who have been making waves.
<ul>
<li><a href="http://blogs.sun.com/roller/page/roumen/">Roman Strobl</a> has come into his own with blog entries such as NetBeans Quality in Numbers and Scanning Classpath Performance Tips.
<li><a href="http://blogs.sun.com/roller/page/geertjan/">Geertjan Wielenga</a> has also become a strong resource with his entries Monitor HTTP Requests on JBoss 4 from NetBeans IDE 4.1 and NetBeans IDE 4.1, Ant, and Demi Moore. 
<li><a href="http://weblogs.java.net/blog/vbrabant/archive/2005/04/wink_is_great_1.html">Vincent Brabant</a> has put together a nice presentation on how to have more room to edit your code in NetBeans 4.1. 
<li>And <a href="http://cld.blog-city.com/">Charles Ditzel</a> continues to propel NetBeans into the limelight through his blog with numerous NetBeans entries and the very valuable <a href="http://files.blog-city.com/files/aa/1263/b/NetBeansWorking.html">NetBeans Quick Links page</a>.</li></ul>

<p>There have been other contributions that are worthy of mention and your time:
<ul>
<li><a href="https://netbeans.org/kb/articles/ebay-sdk-api-calls-demo.html">Launching the eBay Java SDK API Calls Demo Sample Application from NetBeans 4.0</a> by Brian Leonard.
<li><a href="https://netbeans.org/kb/archive/index.html">Building and Running Project Looking Glass with NetBeans</a> by Charlie Hunt</li></ul>

Last but not least to the people who had their submissions published in the <a href="https://netbeans.org/competition/win-with-netbeans.html">Win with NetBeans</a> competition: Rich Unger, Ben Suter, Jason Stapley, Randahl Fink Isaksen, Raguraman Krishnamurthy, Vincent Brabant, Gregg Sporar, Miki Shimizu, Tommi Laukkanen, Zsolt Kiss, Travis Romney, Ryoji Sawa, Arthur Cheng and Jean-Baptiste Renaux. Congratulations!

<p>Your comments and thoughts are always appreciated and we are listening. Send your feedback, comments or news <a href="mailto:nbmarketing@netbeans.org">here</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>&nbsp;</td>
      <td align='right'><font face='Verdana, sans-serif, helvetica, arial' >&nbsp;Robert Demmer</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='s233'></a><font face='Verdana, sans-serif, helvetica, arial' color='#FF0F12' class='titlec'><b>NetBeans<sup><small>TM</small></sup> Software Day at 2005 JavaOne</b></font><br>&nbsp;<br><img src='/images_www/marketing_newsletter/109.png' widht='125' height='125' border='0' alt='NetBeans Day 05 - 23k' align='left' vspace='2' hspace='10'><font face='Verdana, sans-serif, helvetica, arial' >On Sunday afternoon, June 26, the day before the 2005 JavaOne Conference, the 
NetBeans Software Team is hosting a FREE companion event at The Argent Hotel 
near Moscone Center.  Learn from the experts what's happening with the 
NetBeans<sup><small>TM</small></sup> IDE and other Sun tools. James Gosling, the 
father of Java<sup><small>TM</small></sup>,  will discuss the future of Java 
developer tools.  Advances in tools technology will have a dramatic impact on 
developers building solutions with Java J2SE<sup><small>TM</small></sup>, 
J2EE<sup><small>TM</small></sup> and J2ME<sup><small>TM</small></sup> 
technology.  These new technologies will offer increases in developer 
productivity, as well as application quality and performance. There will also be 
keynotes by software leaders at Sun:

<p><table>
<tr>
	<td>Sun Fellow</td>
	<td>Graham Hamilton</td>
</tr>
<tr>
	<td>Sun Distinguished Engineer</td>
	<td>Bill Shannon</td>
</tr>
<tr>
	<td>Sun Distinguished Engineer</td>
	<td>Bob Brewin</td>
</tr>
<tr>
	<td>Sun Distinguished Engineer</td>
	<td>Tim Lindholm</td>
</tr>
<tr>
	<td>Director of Web Technologies</td>
	<td>Tim Bray</td>
</tr>

</table>
<p>Stay tuned for other special guests.  

<p>All attendees will get a copy of the just-off-the-press NetBeans Field Guide.

<p>For more information on the agenda, speaker bios and registration link follow the link below
</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/community/articles/javaone/2005/nb-day.html' target='new'>NetBeans Software Day Home</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='s231'></a><font face='Verdana, sans-serif, helvetica, arial' color='#FF0F12' class='titlec'><b>NetBeans IDE 4.1 Release Candidate</b></font><br>&nbsp;<br><font face='Verdana, sans-serif, helvetica, arial' >Get the latest and greatest version of the upcoming NetBeans IDE 4.1 release.

<p>Choose between the standalone NetBeans IDE 4.1 Release Candidate and the bundle with Sun Java System Application Server PE 8.1. Select which download you would like on the second screen after clicking on the below link.

<ul><li><a href="http://services.netbeans.org/downloads/download.php?type=4.1rc1">Download NetBeans IDE 4.1 Release Candidate</a>
</ul>

Work done on the 4.1 Release Candidate consists mainly of stabilization of the core and on performance. We are asking for your help in testing the release and providing your feedback. We are getting close to the final release which is scheduled for mid-May.

<p>For more information on the NetBeans 4.1 Release visit:
<ul><li><a href="https://netbeans.org/community/releases/41/relnotes.html">Release Notes</a>
<li><a href="https://netbeans.org/kb/archive/index.html">4.1 Docs & Support</a></li></ul>

Thanks and we are looking forward to your feedback. Enjoy!</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/community/releases/41/index.html' target='new'>more information</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='s226'></a><font face='Verdana, sans-serif, helvetica, arial' color='#FF0F12' class='titlec'><b>NetBeans Mobility Pack 4.1 Release Candidate</b></font><br>&nbsp;<br><font face='Verdana, sans-serif, helvetica, arial' >The mobility pack release candidate build is now available on NetBeans.org.

<ul><li><a href="http://services.netbeans.org/downloads/download.php?type=4.1rc1">Take me to the download</a></li></ul>

<b>New Features Include:</b>

<ul><li><b>Visual Design Editor</b> - Visually lay out your MIDlet's workflow, and design and code the GUI using drag and drop elements.

<li><b>End-to-end support for enterprise applications</b> - Wizard support for creating J2ME-J2EE applications. Enables you to quickly create J2ME client/server applications.

<li><b>Improved configuration support</b> - User-defined Abilities allow greater flexibility when creating configuration specific code blocks. Also, you can now use project templates to create a configuration once and use it in multiple projects.

<li><b>Improved obfuscation configuration</b> - Now you have greater control over your obfuscation settings.

<li><b>Improved user attributes support</b> - Create custom attributes and choose their location, whether in your JAD file, JAR manifest file, or both files.</li>

</ul>

<b>Resources:</b>
<ul><li><a href="https://netbeans.org/kb/archive/index.html">J2ME MIDP Development for NetBeans IDE 4.1</a> (Includes high level features)
<li><a href="https://netbeans.org/kb/archive/index.html">Quick start guide for J2ME developers</a>
<li><a href="http://blogs.sun.com/roller/resources/lukas/me-screenshot-rc1.png" Target="_blank">Screenshot</a>
</li></ul>

You must have NetBeans IDE 4.1 and the NetBeans Mobility Pack 4.1 installed before you can start J2ME MIDP development. See the J2ME MIDP Development page above for instructions on downloading and installing the complete environment.

<p>For information on the <b>NetBeans Mobility Pack 4.0</b> please <a href="https://netbeans.org/kb/articles/mobility.html">continue here</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>&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='s223'></a><font face='Verdana, sans-serif, helvetica, arial' color='#FF0F12' class='titlec'><b>NetBeans Profiler Milestone 6 Released</b></font><br>&nbsp;<br><font face='Verdana, sans-serif, helvetica, arial' >NetBeans Profiler is a project to integrate the JFluid profiling technology, originating from Sun Labs, into the NetBeans IDE. The aim of this project is to provide a powerful and flexible profiling solution that is tightly integrated into the IDE workflow. The latest NetBeans Profiler Release (Milestone 6) works with NetBeans IDE 4.0 and 4.1.

<p>Visit <a href="http://profiler.netbeans.org">http://profiler.netbeans.org</a> to download the latest release or for more information.

<p><b>Key features in Milestone 6:</b>
<ul><li>Support for JDK 1.4.2 and JDK 6.0 (Mustang) (more below in What's new)
<li>Tight integration into the IDE workflow
<li>Low overhead profiling utilizing the JFluid technology
<li>Task-based approach to simplify profiling
<li>CPU Performance profiling
<li>Memory profiling & memory leak detection
<li>Attaching to running (deployed) application
<li>Threads profiling</li></ul>

<b>What's new in the Milestone 6 release:</b><ul>

<li>Support for Tiger (5.0) and Mustang (6.0) JDKs - the profiler supports profiling in Mustang builds now (the Mustang builds can be downloaded from <a href="https://mustang.dev.java.net">https://mustang.dev.java.net</a>). JDK 5.0 will be supported starting with the 5.0_04 release (planned to be released around the end of
  June)
<li>New profiler control panel
<li>Significant performance and UI responsiveness enhancements, including
  even smaller profiling overhead in Monitoring mode

<li>New installer that simplifies the installation process

<li>(As always) Large number of bugfixes</li></ul>

The complete list of new features, enhancements and bugfixes can be found
here.

In other Profiler news:
<ul><li>If you missed it there was a very informative and interesting interview; <a href="http://java.sun.com/developer/technicalArticles/Interviews/Dmitriev_qa.html">Better Profiling through Code Hotswapping: A Conversation with JFluid Project Lead, Misha Dmitriev</a>
<li>An updated version of <a href="https://netbeans.org/kb/articles/nb-profiler-tutor-6.html">NetBeans IDE 4.0 Profiler Tutorial</a> is now available for Milestone 6.</li></ul>

The Profiler team also develops tools related to profiling. The first such tool available is an integration of Visual GC into NetBeans IDE. For more details see the <a href="http://profiler.netbeans.org/visualgc/index.html">Visual GC Integration Module homepage</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' >[<a href='http://profiler.netbeans.org' target='new'>more information and download</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='s234'></a><font face='Verdana, sans-serif, helvetica, arial' color='#FF0F12' class='titlec'><b>Project Coyote</b></font><br>&nbsp;<br><img src='/images_www/marketing_newsletter/110.jpg' widht='100' height='125' border='0' alt='Coyote - 18k' align='left' vspace='2' hspace='10'><font face='Verdana, sans-serif, helvetica, arial' >The goal of this project is to develop a set of NetBeans modules to help developers write code in dynamic languages using the NetBeans IDE. Initially, they are targeting the <a href="http://groovy.codehaus.org">Groovy</a> and <a href="http://www.jython.org">Jython</a> languages, but we anticipate a common framework allowing support for more languages.</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='http://coyote.dev.java.net/' target='new'>learn more</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='s225'></a><font face='Verdana, sans-serif, helvetica, arial' color='#FF0F12' class='titlec'><b>NetBeans Switch</b></font><br>&nbsp;<br><font face='Verdana, sans-serif, helvetica, arial' >More and more developers are interested in switching to NetBeans IDE and taking advantage of all the features available right out-of-the-box. That's why we, the NetBeans community, launched the "Switch" website. Read developers' stories and learn why they switched to NetBeans IDE. Learn how NetBeans IDE improves developer productivity and how easy it is to make the switch. Part of the Switch program NetBeans offers the Eclipse Project Import Module for a simple, easy-to-implement transition of Eclipse-based projects to the NetBeans IDE.

<p>Help spread the word and convert your friends and colleagues by showing them what the new NetBeans has to offer! While you're at it grab some of the <a href="https://netbeans.org/community/teams/marketing/collateral.html">cool NetBeans graphics</a> and post them around the Internet or in your email signature. </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/switch/index.html' target='new'>switch to NetBeans</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='s235'></a><font face='Verdana, sans-serif, helvetica, arial' color='#FF0F12' class='titlec'><b>NetBeans Needs You - Please Vote!</b></font><br>&nbsp;<br><font face='Verdana, sans-serif, helvetica, arial' >The Java Developer's Journal, LinuxWorld Magazine, and the Web Services Journal are holding their annual Readers' Choice awards.  NetBeans has been nominated in all three! <p>Please take a few minutes and vote for your favourite IDE!  The voting period runs through July 31st.

<p>Cast your vote for NetBeans in the following categories of the JDJ awards:
<ul><li><b>Best Java Debugging Tool</b> (Page 8) - NetBeans 
<li><b>Best Java IDE Environment</b> (Page 9) - NetBeans/Java Studio Enterprise</li></ul>

[<a href="http://jdj.sys-con.com/general/readerschoice.htm">JDJ Readers' Choice Awards Voting</a>]

<p>Cast your vote for NetBeans at LinuxWorld Magazine awards. NetBeans has been nominated in the following categories:
<ul><li><b>Best Linux Developer Tool</b> (Page 3) - NetBeans/Java Studio Enterprise
<li><b>Best Linux Programming Environment</b> (Page 10) - NetBeans/Java Studio Enterprise</li></ul>

[<a href="http://linux.sys-con.com/general/readerschoice.htm">LinuxWorld Magazine Readers' Choice Awards Voting</a>]

<p>Last but not least vote for NetBeans at the Web Services Journal:
<ul><li><b>Best Web Services IDE</b> (Page 12) - NetBeans/Java Studio Enterprise</li></ul>

[<a href="http://webservices.sys-con.com/general/readerschoice.htm">Web Services Journal Readers' Choice Awards Voting</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>&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='s228'></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' >There are many plugins available for the NetBeans IDE 4.0. In this section we take a look at some of the highlights.

<p><a href="http://www.insitechinc.com/">XTT v5.0 - Smart Web Clients for Java</a> - XTT - Smart Web Clients for Java is a leading Java-based, RAD development framework for building and deploying distributable, Rich, Ultra-thin, Swing based web applications. You can also check out the nice <a href="http://www.insitechinc.com/demo.php3">demo by InsiTech</a>.

<p><a href="http://www.refactorit.com/?id=5327">RefactorIT 2.5 Update 7</a> - Aqris Software has released version 2.5 Update 7 of RefactorIT. 2.5 Update 7 integrates seamlessly with version 4.0+ of NetBeans and it supports CVS mounted file-systems for all its transformations. RefactorIT fully supports J2SE 5.0 and features numerous improvements on the ever so popular graphical dependency analyzer. 

<p><a href="http://www.visual-paradigm.com/sdenb.php">SDE 2.1</a> - SDE 2.1 for NetBeans provides a full UML 2.1 support for your NetBeans, you can model your application the latest UML notations and diagrams. Visual Paradigm's modelling environment is seamlessly integrated with NetBeans; therefore you can perform analysis, design, implementation and deployment in single platform. You code and documentation is always kept in synch. You can discuss your design with colleague by sketching the UML diagrams inside the NetBeans IDE.

<p><a href="http://sourceforge.net/project/showfiles.php?group_id=56262&package_id=63621">PMD Plugin</a> - A new version of the PMD plugin that works with NetBeans IDE 4.0 and bundles the latest available version of PMD tools is now available. PMD is a tool that scans Java source code and looks for potential problems. The plugin allows running it from the IDE and hyperlinks produced output.

<p><a href="http://mevenide.codehaus.org/mevenide-netbeans-project/">Mevenide 0.6</a> - The project's aim is to provide Maven project type support for the NetBeans IDE 4.0. The features include recognition of Maven projects, setup of the project in the IDE, running Maven, editor support for configuration files etc. Changes in this version include:
<ul><li>Added remote and local repository browser. Allow to download artifacts from remote repository.
<li>Added dependency editing in visual project customizer.
<li>Link findbugs report output with the IDE's editor. Add annotations into editor.</li></ul>

<a href="http://www.appperfect.com/index.html">AppPerfect</a> has updated three NetBeans offerings: AppPerfect JVM Profiler, AppPerfect Unit Tester and AppPerfect Code Analyzer. 

</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='http://plugins.netbeans.org/' 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'></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>