<HTML>
<HEAD>
<title>NetBeans Edge - Issue 21 - April 2004</title>
<meta NAME="description" CONTENT="The NetBeans Edge monthly newsletter, Issue 21, 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 05-May 16:20 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-21_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-21_pt_BR.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-21_ru.html'><img src='/images_www/flags/ru_small.gif' width='20' height='13' alt='Russian Edition' border='0'></a>&nbsp;<a href='/community/news/edge-21_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 21</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='s177'></a><font face='Verdana, sans-serif, helvetica, arial' color='#FF0F12' class='titlec'><b>NetBeans Edge, Issue 21</b></font><br>&nbsp;<br><font face='Verdana, sans-serif, helvetica, arial' ><p>Welcome to the twenty-first issue of the NetBeans monthly newsletter. After 20 issues of the newsletter under the name of Sprout we have decided it was time for something new. I present to you the NetBeans Edge!</p>

<p>To no surprise, the release of the NetBeans IDE 3.6 is the highlight of this issue. Congratulations to all NetBeans.org community members for another outstanding effort in providing the latest release of the original, free and open source IDE; the NetBeans IDE 3.6!

<p>This month the NetBeans Edge highlights the resources that will help you get started in using the NetBeans IDE 3.6 and pushing your development further. So NetBeans 3.6 has hit the shelf what's next? The 3.6 release will be available in more languages and included in various cobundles. Get the details in this issue.</p>

<p>And in other news concerning 3.6, the NetCAT program came to a successful close. Results of the Customer Acceptance survey can now be <a href="http://qa.netbeans.org/processes/cat/36/results/ca_results.html">viewed</a>. There was 86 % participation from the NetCAT members who were entitled to vote in the survey. And another notable outcome was that Refactoring support was elected as the feature of choice for the next release. Great job!

<p>To understand where NetBeans is today and where NetBeans is headed tomorrow Vincent Brabant interviews Steve Wilson, Director for NetBeans Technology. 

<p>As the future NetBeans 4.0 release begins to materialize the Edge takes you into the horizons where we get a glimpse: Refactoring, the new Project System and other planned features for 4.0. If you wish to take a look back before moving forward view some of our <a href="https://netbeans.org/about/press/awards.html">latest awards</a>.</p>

<p>We have a great issue for you put together by the nbmarketing team but don't hesitate to <a href="mailto:infok@netbeans.org">drop a suggestion</a> or <a href="mailto:nbmarketing@netbeans.org">get involved</a> in a new story.</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;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='s178'></a><font face='Verdana, sans-serif, helvetica, arial' color='#FF0F12' class='titlec'><b>NetBeans IDE 3.6 Release & Resources</b></font><br>&nbsp;<br><font face='Verdana, sans-serif, helvetica, arial' >NetBeans 3.6, is now available for immediate <a href="http://services.netbeans.org/downloads/download.php?a=b&amp;p=1">download</a>. The latest release increases the breadth of code productivity features, improves the 'look and feel' and provides developers with better integration to build web, rich desktop and mobile Java applications.</p>

<hr>
Resources

<p><b>NetBeans Online Help</b> - The documentation included in NetBeans IDE itself. Press F1 to open the online help.</p>

<p><a href="https://netbeans.org/community/releases/36/Whats_New.html">What's New in NetBeans 3.6</a> - Read about the latest and greatest features waiting to be unlocked.

<p><a href="https://netbeans.org/community/releases/36/relnotes.html">Release Notes</a> - Want to know what has changed since the 3.5.1 release? This is your document.

<p><a href="https://netbeans.org/kb/archive/index.html">NetBeans IDE 3.6 Quick Start Guide</a> - This document takes you through the basics of using NetBeans IDE 3.6 by creating a simple Hello World application and is designed to get you going as quickly as possible.</p>

<p><a href="https://netbeans.org/kb/archive/index.html">Using NetBeans IDE 3.6 with JDK 1.5 (Tiger)</a> - A quick Howto to get you started using NetBeans 3.6 with JDK 1.5.

<p><a href="https://netbeans.org/kb/archive/index.html">Using NetBeans IDE 3.6</a> - This guide is designed to give you a more detailed introduction to the IDE than available in the Quick Start Guide. Various aspects of the IDE are explored in detail.</p>

<p><a href="https://netbeans.org/kb/archive/index.html">GUI Building in NetBeans IDE 3.6</a> - This short tutorial guides you through the process of creating an application called ColorSwitch. You will build a simple program that enables you to switch the color of a panel from light gray to medium gray to black.</p> 

<p>NetBeans PhotoAlbum Demo - Highlights some of the functionality in NetBeans relating to web, desktop and mobile applications. A Flash demo is shown using the NetBeans IDE 3.5.1 but you may download the a complete package including: source code, demo script and installation instructions for use with NetBeans 3.6.

<hr>For more support you may <a href="https://netbeans.org/community/lists/top.html">subscribe</a> to the nbusers@netbeans.org mailing list where you will find amateurs and expert alike to help you with your questions.</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 and 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='s182'></a><font face='Verdana, sans-serif, helvetica, arial' color='#FF0F12' class='titlec'><b>Multilingual Releases and Cobundles</b></font><br>&nbsp;<br><font face='Verdana, sans-serif, helvetica, arial' >Now that the English version of the IDE has been released it is time to take a look forward at what is still to come concerning the 3.6 release.

<ul>
<li>April 22: Java 2 Standard Edition / NetBeans IDE 3.6 English Cobundle</li>
<li>May 12: NetBeans IDE 3.6 Multilingual Release (Chinese & Japanese)</li>
<li>May 12: Sun Java System Application Server 8 Platform Edition / NetBeans IDE 3.6 English Cobundle</li>
<li>May 18: Java 2 Standard Edition / NetBeans IDE 3.6 Multilingual (Chinese & Japanese) Cobundle</li>
<li>June 9: Sun Java System Application Server 8 Platform Edition / NetBeans IDE Multilingual (Chinese & Japanese) Cobundle</li></ul>

More information on <a href="http://java.sun.com/j2se/index.jsp">Java 2 Standard Edition</a> or <a href="http://wwws.sun.com/software/products/appsrvr_pe/index.html">Sun Java System Application Server 8</a>,  Platform Edition.</p>

<p>Also in the works are community contributed localisation's of the NetBeans IDE 3.6 in : Dutch, French and Russian. They are currently available in dev builds only but are expected to become available in May or June. Please stay tuned for more details.</p>

<p>If you wish to contribute to language efforts are start  your own please visit <a href="https://netbeans.org/community/contribute/localise.html">the  Localising Quickstart</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;</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='s179'></a><font face='Verdana, sans-serif, helvetica, arial' color='#FF0F12' class='titlec'><b>NetBeans Spotlight: Steve Wilson</b></font><br>&nbsp;<br><a href="" onClick='window.open("/images_www/marketing_newsletter/99_big.jpg", "", "width=820, height=820, toolbar=no, location=no, directories=no, status=no")'><img src='/images_www/marketing_newsletter/99.jpg' widht='100' height='150' border='0' alt='Steve Wilson - 5k' align='left' vspace='2' hspace='10'></a><font face='Verdana, sans-serif, helvetica, arial' >In an exclusive interview for the Edge, Vincent Brabant has a Q&A session with Steve Wilson. Steve is currently pulling double duty as Sun's Engineering Director for the Core Developer Platform (CDP) and Director for NetBeans Technology. 

<p>Here is what you can expect:
<hr>
<i>Vincent</i>:  Tell us about collaboration between the NetBeans.org team, Sun Java Studio Enterprise team and Sun Java Studio Creator team?

<p><i>Steve</i>:  Having these two commercial products built on top of the NetBeans code-base is a big challenge, but leads to a much improved NetBeans. These teams both have specific demands in terms of functionality their users want and we try to provide for that in the basic IDE. At the same time, we often get back suggestions, bug fixes and even new features from these teams that we incorporate into the open source base.
<hr>

Other topics covered in the interview include: the logic behind the NetBeans 3.6 release before the previously planned 4.0, what is in the works for a NetBeans 4.0 (Refactoring, the new Project system) and what may lie beyond NetBeans 4.0. This is an interview not to be missed.

</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/interviews/steve_wilson.html' target='new'>complete interview</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='s184'></a><font face='Verdana, sans-serif, helvetica, arial' color='#FF0F12' class='titlec'><b>Java Studio Mobility Pack For NetBeans</b></font><br>&nbsp;<br><a href="" onClick='window.open("/images_www/marketing_newsletter/102_big.jpg", "", "width=820, height=820, toolbar=no, location=no, directories=no, status=no")'><img src='/images_www/marketing_newsletter/102.jpg' widht='100' height='267' border='0' alt='Mobile - 10k' align='left' vspace='2' hspace='10'></a><font face='Verdana, sans-serif, helvetica, arial' >The Java Studio Mobility modules pack have been released for the NetBeans IDE. The Java Studio Mobility pack is used for developing applications that can be deployed to Java technology-enabled mobile devices. With features optimized for Mobile Information Device Profile (MIDP)/Connected Limited Device Configuration (CLDC) development, application developers using Java 2 Platform, J2ME technology will benefit from the rapid application development capabilities developing J2ME MIDP applications. 

<p>The modules are now available on the NetBeans IDE 3.6 Auto Update Center in the J2ME Wireless folder. </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/community/releases/36/mobility_features.html' target='new'>features & benefits</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='s183'></a><font face='Verdana, sans-serif, helvetica, arial' color='#FF0F12' class='titlec'><b>An Update Center Change</b></font><br>&nbsp;<br><font face='Verdana, sans-serif, helvetica, arial' >A conversation on the aumasters@netbeans.org mailing list alias has led to a new concept which is to be implemented for the NetBeans 3.6 release. This aims to raise the NetBeans quality bar by improving the NetBeans Update Centers structure and content clarity.

<p>The plan is to have five types of update centers that would be distinct for each release (i.e. Development for 3.6 would be different than Development for 4.0):
<ul>
<li>Development: Only used in development phase, not for end-user use. To be used for modules not part of standard distribution, but built daily</li>
<li>Beta: In final releases used for modules in Beta quality, in Betas and Release </li>Candidates used for all modules not part of standard distribution</li>
<li>Stable: Used for modules that meet stable module criteria for given release</li>
<li>Third Party: Used for modules that meet stable module criteria for given release, provided by 3rd parties (i.e. not netbeans.org)</li>
<li>HotFixes: Used for delivery of quick small fixes, that meet release-quality criteria</li>
</ul>
For more information on these changes or to provide feedback please view the <a href="https://netbeans.org/servlets/ReadMsg?msgId=722647&listName=nbusers">original message</a> sent to nbusers.
</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='s185'></a><font face='Verdana, sans-serif, helvetica, arial' color='#FF0F12' class='titlec'><b>Update On NetBeans 4.0 Activities</b></font><br>&nbsp;<br><a href="" onClick='window.open("/images_www/marketing_newsletter/98_big.png", "", "width=820, height=820, toolbar=no, location=no, directories=no, status=no")'><img src='/images_www/marketing_newsletter/98.png' widht='150' height='105' border='0' alt='Refactoring 4.0 - 14k' align='left' vspace='2' hspace='10'></a><font face='Verdana, sans-serif, helvetica, arial' ><b>NetBeans 4.0 Refactoring Alpha Preview</b> 
<p>In case you have missed it the Refactoring Alpha preview for NetBeans 4.0 is now available on NetBeans.org! You can download the build and play with features like Rename Package/
Class/Method/Field, Change Method Parameters or Encapsulate Field.</p>

<p>If you want to join the developer community around Refactoring, please subscribe to the developer list (dev@refactoring.netbeans.org) at on the projects mailing <a href="https://netbeans.org/projects/refactoring/lists">list page</a> and send your comments regarding this alpha release to dev@refactoring.netbeans.org alias.</p>

<p>For more information concerning Refactoring in NetBeans 4.0 including the alpha preview download, planned Refactoring features and roadmap please visit<ul><li><a href="http://refactoring.netbeans.org">http://refactoring.netbeans.org</a></li></ul>

<p><b>New Project System based on Apache Ant</b></p>

<p>A completely new project system based on Apache Ant, a proven de-facto open source standard build tool for developing applications using java technologies. This new system will have an open architecture, which third-party modules can extend to support current and future types of Java applications. NetBeans will include project types for J2SE desktop and two-tier web applications (JSPs, servlets, tag libraries) out of the box. The users will not have to fear of being locked into a proprietary project system.<ul>
<li><a href="http://projects.netbeans.org/buildsys/projects_quickstart.html">http://projects.netbeans.org</a></li></ul>

* The integration of Refactoring features with the new Projects System and the merging to the trunk is targeted for the end of April. It is also desired to publish the Refactoring API,  so you can write and contribute your favorite Refactoring features.</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/community/releases/40/nb40_features.html' target='new'>NetBeans 4.0 Release Plan</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='s180'></a><font face='Verdana, sans-serif, helvetica, arial' color='#FF0F12' class='titlec'><b>Did You Know...</b></font><br>&nbsp;<br><font face='Verdana, sans-serif, helvetica, arial' ><b>there is a new way to register JDBC driver in NB 3.6?</b><br>
Now it is possible to load the driver from any location, it is not necessary to put it to the <nb>/lib/ext directory anymore. You just need to register the driver within the IDE. To do that right-click Drivers node and choose Add driver action. Specify required information and your driver will appear under drivers node.

<p>For more information, see Database Explorer help in the IDE or <a href="http://db.netbeans.org/uispecs/db_jdbc_driver_manager.html">look here</a>.

<p>Tip provided by: Radko . Najman @ Sun . com

<p><b>you can ask to debugger to stop on exceptions?</b><br>
Go to the breakpoints window, right click, New Breakpoint, in the dropdown on the right choose Exception, change option below to thrown or caught, and pick your exception class. If you want everything, choose "Throwable".

<p>Tip provided by: Torbjorn . Norbye @ Sun . COM

<p><b>that there are NetBeans mailing list in Chinese, French, Japanese and Russian? <a href="https://netbeans.org/community/lists/top.html">Get your subscription 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;Vincent Brabant</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>
