<HTML>
<HEAD>
<title>NetBeans Edge - Editie 21 - April 2004</title>
<meta NAME="description" CONTENT="The NetBeans Edge monthly newsletter, Editie 21, April 2004 /Dutch Edition">
<meta http-equiv="content-language" content="nl">
<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:10 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>Kijk hier eens naar</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'> Catalogus van vrije en commerciele add-on modules beschikbaar als download voor  jouw 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 waar NetBeans een federated lid is<br></font> </td></tr><td><a href='http://' style='color:white'><font face='Verdana, sans-serif, helvetica, arial' size='1' color='#FFFFFF'></font></a>
<font face='Verdana, sans-serif, helvetica, arial' color='#FFFFFF' size='1'> <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 gerelateerde 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>Warme 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>Meest Actieve 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>Statistiek: 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'>Ingeschrevenen</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'>Berichten Gepost</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.html'><img src='/images_www/flags/uk_small.gif' width='20' height='13' alt='English Edition' border='0'></a>&nbsp;</td>  <td align='right'><font face='Verdana, sans-serif, helvetica, arial' ><b>Editie 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, Editie 21</b></font><br>&nbsp;<br><font face='Verdana, sans-serif, helvetica, arial' > <p>Welkom bij de twee en twintigste editie van de NetBeans maandelijks nieuwsbrief. Na  20 edities onder de naam van Sprout hebben we besloten dat het tijd is voor iets nieuws  en met de release van de NetBeans IDE 3.6 konden we geen beter tijdstip hebben om de  gelegenheid te baat te nemen om de rest voor te blijven, en de NetBeans Edge te   krijgen!</p>   <p>Het zal als geen verrassing komen dat de release van de NetBeans IDE 3.6 het belangrijkste  onderdeel is van deze editie. Felicitaties aan alle NetBeans.org gemeenschapsleden voor wederom   uitstekende inzet voor deze release van de originele, gratis en open source IDE; de   NetBeans IDE 3.6!   <p>Deze maand zal de NetBeans Edge de artikelen aanstippen die je zullen helpen om   de NetBeans IDE 3.6 te gaan gebruiken en om je NetBeans uit te breiden om je ontwikkelingen  op een hoger niveau te brengen. Dus nu NetBeans 3.6 op de planken ligt, wat volgt er?  De 3.6 zal beschikbaar zijn in meer talen en in een verschillende co-bundles. Zie deze  editie voor meer details.</p>   <p>En er is ook ander nieuws met betrekking tot 3.6, het NetCAT programma heeft een   succesvol slot gehad. De resultaten van de Gebruikers Acceptatie onderzoek kunnen  nu <a href="http://qa.netbeans.org/processes/cat/36/results/ca_results.html">bekeken</a>  worden. Er was een 86% participatie van de NetCAT leden die mochten stemmen in het   onderzoek. Een andere andere uitkomst van het onderzoek was dat Refactoring support  gekozen is als meest gewilde feature voor de volgende release.    <p>Om te begrijpen waar NetBeans vandaag is en waar NetBeans morgen naar toe gaat  interviewt Vincent Brabant, Steve Wilson, Director for NetBeans Technology.   <p>Nu de toekomstige NetBeans 4.0 release vorm begint te krijgen neemt de Edge  je verder om te zien van wat we gaan krijgen: Refactoring, een nieuw Project Systeem  en andere geplande features voor 4.0. Als je terug wil kijken voordat je voorwaarts   gaat, bekijk dan onze <a href="https://netbeans.org/about/press/awards.html">  laatste prijzen</a>.</p>    <p>We hebben een fantastische editie voor je samengesteld door het nbmarketing team,  maar <a href="mailto:info@netbeans.org">stuur ons een suggestie</a> of <a  href="mailto:nbmarketing@netbeans.org">help mee</a> met een nieuwe story item.</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><br><font class='smalltext'><i>Translated by: Manfred Riem</i></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 beschikbaar voor <a  href="http://services.netbeans.org/downloads/download.php?a=b&amp;p=1">download</a>. De nieuwe editie verhoogt de hoeveelheid van code productiviteit features, verbetert de 'look and feel' en levert ontwikkelaars bettere integratie om web, desktop en mobiele Java applicaties te bouwen.</p>  <hr> Resources  <p><b>NetBeans Online Help</b> - De documentatie die onderdeel is van de NetBeans IDE. Druk op F1 om de online help te krijgen.  <p><a  href="https://netbeans.org/community/releases/36/Whats_New.html">What is Nieuw in NetBeans 3.6</a> - Lees over de nieuwe en beste features die op je wachten om gebruikt te worden.  <p><a href="https://netbeans.org/community/releases/36/relnotes.html">Release Notes</a> - Wil je weten wat er verandert is sinds de 3.5.1 release? Lees dan dit document.  <p><a href="https://netbeans.org/kb/archive/index.html">NetBeans IDE 3.6 Quick Start Guide</a> - Dit document loopt je door de basics van het gebruik van NetBeans IDE 3.6 door een simpele Hello World applicatie te creeren en is ontwikkeld om je zo snel mogelijk aan de slag te helpen.</p>  <p><a href="https://netbeans.org/kb/archive/index.html">Using NetBeans IDE 3.6 with JDK 1.5 (Tiger)</a> - Een snelle Howot die je helpt om NetBeans 3.6 te gebruiken met JDK 1.5.  <p><a href="https://netbeans.org/kb/archive/index.html">Using NetBeans IDE 3.6</a> - Deze guide is ontwikkeld om je een meer gedetailleerde introductie te geven van de IDE dan in de Quick Start Guide. Verscheidene aspecten van de IDE worden in meer detail bekeken.</p>  <p><a href="https://netbeans.org/kb/archive/index.html">GUI Building in NetBeans IDE 3.6</a> - Deze korte tutorial loodst je door het proces van het creeren van een applicatie genaamd ColorSwitch. Je zal een  simpel programma maken dat je instaat stelt om de kleur in te stellen van licht grijs naar donker grijs naar zwart.</p>   <p>NetBeans PhotoAlbum Demo - stipt wat van de functionaliteit in NetBeans relating to web, desktop and mobile applications. A Flash demo wordt getoond die de NetBeans IDE 3.5.1 gebruikt maar je kan ook een complete package downloaden die het volgende bevat: source code, demo script en installatie instructies voor het gebruik in NetBeans 3.6.  <hr>Voor meer ondersteuning kun je je <a href="https://netbeans.org/community/lists/top.html">inschrijven</a> op de nbusers@netbeans.org mailing lijst waar je amateurs en expersts kan vinden die je kunnen helpen met het beantwoorden van je vragen.</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'>ondersteuning en documentatie</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>Meertalige Releases en Cobundles</b></font><br>&nbsp;<br><font face='Verdana, sans-serif, helvetica, arial' >Nu dat de Engelse versie van de IDE beschikbaar is, is het tijd om vooruit te kijken naar wat er nog meer komt met betrekking tot de 3.6 versie.  <ul> <li>April 22: Java 2 Standaard Editie / NetBeans IDE 3.6 Engelse Cobundle</li> <li>May 12: NetBeans IDE 3.6 Meertalige Versie (Chinees  Japans)</li> <li>May 12: Sun Java Systeem Applicatie Server 8 Platform Editie / NetBeans IDE 3.6 Engelse Cobundle</li> <li>May 18: Java 2 Standard Editie / NetBeans IDE 3.6 Meertalige (Chinees  Japans) Cobundle</li> <li>June 9: Sun Java System Applicatie Server 8 Platform Editie / NetBeans IDE Meertalig (Chinees  Japans) Cobundle</li></ul>  Meer informatie over de <a href="http://java.sun.com/j2se/index.jsp">Java 2 Standaard Editie</a> of de <a href="http://wwws.sun.com/software/products/appsrvr_pe/index.html">Sun Java Systeem Applicatie Server 8 Platform Editie</a>.</p>  <p>Ook in de pijpleiding zijn localisaties bijgedragen door de gemeenschap voor de NetBeans IDE 3.6 in de volgende talen : Frans, Nederlands en Russisch. Deze  zijn nu alleen nog beschikbaar als developer builds maar zullen waarschijnlijk beschikbaar voor download komen in Mei of Juni. Let op nadere details.</p>  <p>Als je wil bijdragen aan de vertalingen of je eigen wil beginnen,  bezoek dan  <a href="https://netbeans.org/community/contribute/localise.html">Localiseren van de NetBeans IDE en/of Vertalen van Web Site Inhoud</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 een exclusief interview voor de Edge heeft Vincent Brabant een VA sessie gehad  met Steve Wilson. Steve is op dit moment zowel Sun's Engineering Directory for  the Core Developer Platform (CDP) als Director for NetBeans Technology.   <p>Hier is wat je kan verwachten:  <hr>  <i>Vincent</i>: Vertel ons over de samenwerking tussen het NetBeans.org team,  het Sun Java Studio Enterprise team en het Sun Java Studio Creator team?   <p><i>Steve</i>: Om deze twee commerciele producten te bouwen bovenop de   NetBeans code-base is een grote uitdaging, maar leidt tot een zeer verbeterde  NetBeans. Beide teams hebben specifieke vereisten met betrekking tot functionaliteit  voor hun gebruikers en we proberen dat te leveren in de basic IDE. Daarnaast krijgen we  ook vaak suggesties, bug fixes en zelfs nieuwe features terug van deze teams die we dan   weer terugvoeren in de open source base.  <hr>   Andere onderwerpen die besproken worden in het interview omvatten: de logica achter de  NetBeans 3.6 versie voor de eerder geplande 4.0 versie, wat is er gepland voor de NetBeans  4.0 versie (Refactoring, het nieuwe Project systeem) en wat er achter de horizon van   NetBeans 4.0 ligt. Dit is een interview dat je niet mag missen.</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 voor 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' >Het Java Studio Mobility modules pack is beschikbaar voor de NetBeans IDE. Dit pack kan je gebruiken om applicaties te ontwikkelen voor Java technology-enabled mobiele apparaten. Met features geoptimalizeerd voor het Mobile Information Device Profile (MIDP)/Connected Limited Device Configuration (CLDC) ontwikkeling zullen  applicatie ontwikkelaars die het Java 2 Platform, J2ME technologie gebruiken baat hebben bij rapid application development mogelijkheden voor het ontwikkelen van J2ME MIDP applicaties.  <p>De modules zijn nu beschikbaar op de NetBeans IDE 3.6 Auto Update Center in de 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>Een Update Center Verandering</b></font><br>&nbsp;<br><font face='Verdana, sans-serif, helvetica, arial' >Een gesprek op de aumasters@netbeans.org mailing lijst alias heeft geleid tot een nieuw concept dat geimplementeerd zal worden voor de NetBeans 3.6 versie. De bedoeling is om de kwaliteit van NetBeans op een hoger plan te brengen door de NetBeans Update Centers inzichtelijker te maken.  <p>Het plan is om vijf types van update centers te hebben die verschillend zijn voor elke NetBeans versie (bijv. Development for 3.6 zal verschillend zijn ten opzichte van 4.0): <ul>  <li>Development: Alleen gebruikt in de development fase, niet bedoeld voor eind-gebruikers.  Bestemd voor modules die niet onderdeel zijn van de standaard distributie, maar dagelijks  gebouwd.</li>  <li>Beta: voor releases die van Beta kwaliteit zijn. Wordt gebruikt voor Beta en Release  Candidate voor modules die niet onderdeel zijn van de standaard distributie.</li>  <li>Stable: Gebruikt voor modules die conformeren aan stabiele module criteria voor de  gegeven release</li>  <li>Third Party: Gebruikt voor module die conformeren aan stabiele module criteria voor  modules geleverd door een derde partij (bijv. niet door netbeans.org).</li>  <li>Hotfixes: Gebruikt voor het leveren van snelle kleine fixes, die conformeren  aan release kwaliteit criteria.</li> </ul> Voor meer informatie over deze veranderingen of om feedback te leveren zie de <a href="https://netbeans.org/servlets/ReadMsg?msgId=722647listName=nbusers">originele boodschap</a> die gestuurd was naar 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 Over NetBeans 4.0 Activiteiten</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>Voor het geval dat je het gemist hebt kan je de Refactoring Alpha preview for NetBeans 4.0 download om er mee te spelen. Features zoals Rename Package/ Class/Method/Field, Change Method Parameters of Encapsulate Field.</p>  <p>Als je deel wil worden van de ontwikkelaars gemeenschap rond Refactoring, schrijf je dan in op de developer lijst (dev@refactoring.netbeans.org) op de project mailing lijst <a href="https://netbeans.org/projects/refactoring/lists">pagina</a> en stuur je commentaar over deze alpha release naar dev@refactoring.netbeans.org alias.</p>  <p>Voor meer informatie over Refactoring in NetBeans 4.0 plus de alpha preview download,  geplande Refactoring features en een roadmap  bezoek <ul><li><a href="http://refactoring.netbeans.org">http://refactoring.netbeans.org</a></li></ul>  <p><b>Nieuw Project Systeem gebaseerd op Apache Ant</b></p>  <p>Een compleet nieuw project systeem gebaseerd op Apache Ant, een bewezen de-facto open source standaard bouw tool voor het ontwikkelen van applicaties met behulp van java technologien. Dit nieuw systeem zal een open architectuur hebben, die third-party modules kunnen gebruiken om huidige en toekomstige types van Java applicaties te ondersteunen. NetBeans zal standaard project types bevatten voor J2SE desktop en two-tier web applicaties (JSPs, servlets, tag libraries). De gebruiker hoeft niet bang te zijn om in een proprietary project systeem vast te zitten. <ul>  <li><a href="http://projects.netbeans.org/buildsys/projects_quickstart.html">http://projects.netbeans.org</a></li></ul>  * De integratie van Refactoring features met het nieuwe Projects Systeem en het  mergen naar de trunk is vastgesteld voor het einde van April. Het is ook gewenst om de Refactoring API te publiceren, zodat je je eigen favoriete Refactoring feature  kan implementeren.</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> Wist Je Dat ...</b></font><br>&nbsp;<br><font face='Verdana, sans-serif, helvetica, arial' ><b>er een nieuwe manier is om een JDBC driver in NB 3.6 te registreren?</b><br/> Nu is het mogelijk om een driver van elke locatie te laden, het is niet nodig om ze in de <nb>/lib/ext directory te plaatsen. Je moet alleen de driver registreren in de IDE. Om dat te doen moet je rechts-clicken op de Drivers node en de actie Toevoegen (Add) kiezen. Specificeer de benodigde informatie en je driver zal  te voorschijn komen on de drivers node.  <p>Voor meer informatie, zie de Database Explorer help in de IDE of <a href="http://db.netbeans.org/uispecs/db_jdbc_driver_manager.html">kijk hier</a>.  <p>Tip geleverd door: Radko . Najman @ Sun . com  <p><b>je de debugger kan vragen om te stoppen op exceptions?</b><br/> Ga naar het breakpoints window, rechter-click, Nieuw Breakpoint, in de dropdown aan de rechterkan kies Exception, verander de optie naar thrown of caught, en selecteer je exception class. Als je op alles wil stoppen, kies "Throwable".  <p>Tip geleverd door: Torbjorn . Norbye @ Sun . COM  <p><b>dat er NetBeans mailing lijsten zijn in het Chinees, Frans, Japans en Russisch? <a href="https://netbeans.org/community/lists/top.html">Schrijf je hier in!</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>
