<HTML>
<HEAD>

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

<title>NetBeans Edge - Editie 26 - April 2005</title>
<meta NAME="description" CONTENT="The NetBeans Edge monthly newsletter, Editie 26, April 2005 /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 2005 02-May 12:30 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>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='http://plugins.netbeans.org/' style='color:white'><font face='Verdana, sans-serif, helvetica, arial' size='1' color='#FFFFFF'>Module Catalogus</font></a>
<font face='Verdana, sans-serif, helvetica, arial' color='#FFFFFF' size='1'> Catalogus van vrije en commerciele add-on modules beschikbaar 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 gefedereerd lid is<br></font> </td></tr><td><a href='http://http://services.netbeans.org/downloads/download.php?a=bp=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'> Beschikbaar voor 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'> Opkomende 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 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'>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>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'>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>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: 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'>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: 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'>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'>+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.html'><img src='/images_www/flags/uk_small.gif' width='20' height='13' alt='English Edition' border='0'></a>&nbsp;<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;</td>  <td align='right'><font face='Verdana, sans-serif, helvetica, arial' ><b>Editie 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, Editie 26</b></font><br>&nbsp;<br><font face='Verdana, sans-serif, helvetica, arial' ><p>Het NetBeans.org project schakelt in hoge versnelling. Bouwend op het succes
van de 4.0 release, is nu NetBeans 4.1 Release Candidate beschikbaar met de 
opkomende release versie in het midden van Mei. Doe een test run en deel je 
ervaringen met de rest van de gemeenschap op een van de NetBeans <a
href="https://netbeans.org/community/lists/top.html">mailing lijsten</a>.

<p>In deze editie leer je over de Kracht van 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 = Een 
development tool zonder weerga!

<p>Ten eerste, wil ik van deze gelegenheid gebruik maken om wat nieuws te 
delen rond het NetBeans.org project. Er zijn verscheidene participanten die
grote golven gemaakt hebben.
<ul>
<li><a href="http://blogs.sun.com/roller/page/roumen/">Roman Strobl</a> heeft
in zijn blog gegevens over de NetBeans Qaulity in Numbers en Scanning 
Classpath Performance Tips.
<li><a href="http://blogs.sun.com/roller/page/geertjan/">Geertjan Wielenga</a>
is ook een goede resource met zijn gegevens over Monitor HTTP Requests op 
JBoss 4 met de NetBeans IDE 4.1 en de NetBeans IDE 4.1, Ant, en Demi Moore.
<li><a 
href="http://weblogs.java.net/blog/vbrabant/archive/2005/04/wink_is_great_1.html">Vincent
Brabant</a> heeft een mooie presentatie gemaakt over hoe je meer ruimte kan 
make om je code te bewerken in NetBeans 4.1.
<li>En <a href="http://cld.blog-city.com/">Charles Ditzel</a> maakt NetBeans
meer zichtbaar in zijn blog met verscheidene NetBeans gegevens en zijn zeer
waardevolle <a 
href="http://files.blog-city.com/files/aa/1263/b/NetBeansWorking.html">NetBeans
Quick Links pagina</a>.</li</ul>

<p>Er zijn andere contributies die het waard zijn om vermeld te worden:
<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> door
Brian Leonard.
<li><a href="https://netbeans.org/kb/archive/index.html">Building and
Running Project Looking Glass with NetBeans</a> door Charlie Hunt</li></li>

En daarnaast de mensen die hun inzending gepubliceerd zagen in de <a
href="https://netbeans.org/competition/win-with-netbeans.html">Win met NetBeans</a>
competitie: 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. Gefeleciteerd!

<p>Je commentaar is zoals altijd welkom en we luisteren er zeker naar. Stuur
je feedback, commentaar en nieuws naar <a 
href="mailto:nbmarketing@netbeans.org">ons</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><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='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' >Op Zondag middag, 26 Juni, de dag voor de 2005 JavaOne conferentie, zal het
NetBeans Software Team een GRATIS companion event hosten in The Argent Hotel
nabij het Moscone Center. Leer van de experts wat er aan het gebeuren met 
NetBeans<sup><small>TM</small></sup> IDE en andere Sun tools. James Gosling,
de
vader van Java<sup><small>TM</small></sup>, zal over de toekomst van Java
developer tools spreken. Vooruitgang in de tools technologie heeft een 
dramatische impact op developers die oplossing bouwen met Java
J2SE<sup><small>TM</small></sup>, J2EE<sup><small>TM</small></sup> en
J2ME<sup><small>TM</small></sup> technologie. Deze nieuwe technologien leveren
een verbetering in developer productiviteit, alsmede een verbetering in 
applicatie kwaliteit en performance. Er zullen ook keynotes worden gegeven
door software leiders van 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>Let op voor andere speciale gasten.

<p>Alle deelnemers zullen een copie krijgen van de heet-van-de-pers NetBeans
Field Guide.

<p>Voor meer informatie over de agenda, sprekers biografien en een registratie
link volg de link hieronder.
</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' >Download de nieuwste versie van de opkomende NetBeans IDE 4.1 release.

<p>Kies tussen de alleenstaande NetBeans IDE 4.1 Release Candidate en de
bundle met de Sun Java System Application Server PE 8.1. Selecteer welke 
download op het tweede scherm na het klikken op de link hieronder

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

Het werk gedaan aan de 4.1 Release Candidate bestaat hoofdzakelijk uit het
stabilizering van core en het verbeteren van performance. We vragen jullie
help in het testen van deze versie en om je feedback. We zijn dichtbij de
final release die gepland is voor midden Mei.

<p>Voor meer informatie over de NetBeans 4.1 Release bezoek:
<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>

Bedankt en we kijken uit naar je feedback. Veel plezier!</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'>meer informatie</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' >De mobility pack release candidate build is nu beschikbaar op NetBeans.org.

<ul><li><a
href="http://services.netbeans.org/downloads/download.php?type=4.1rc1">Ga naar 
de download</a></li></ul>

<b>Nieuwe Features zijn o.a:</b>

<ul><li><b>Visual Design Editor</b> - Layout de MIDlet's workflow visueel,
en ontwerp en code de GUI door middel van drag en drop elementen.

<li><b>Eind-to-eind support voor enterprise applicaties</b> - Wizard support
voor het creeren van J2ME-J2EE applicaties. Maakt het mogelijk om snel J2ME
client/server applicaties te creeren.

<li><b>Verbeterd configuratie support</b> - User-gedefinieerd Abilities maakt
grotere flexibiliteit mogelijk wanneer je configuratie specifiek code nodig
hebt. Ook, je kan nu ook project templates die je kan hergebruiken in meerdere
projecten.

<li><b>Verbeterde obfuscation configuratie</b> - Nu heb je betere controle over
je obfuscation instellingen.

<li><b>Verbeterde user attributes support</b> - Creer custom attributes en
kies je locatie, in je JAD file, in je JAR manifest, of beide files.</li>

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

Je moet NetBeans IDE 4.1 en de NetBeans Mobility Pack 4.1 geinstalleerd hebben
voordat je met J2ME MIDP development kan beginnen. Zie de J2ME MIDP Development
pagina hierboven voor instructies voor downloaden en installeren van de
complete omgeving.

<p>Voor meer informatie over de <b>NetBeans Mobility Pack 4.0</b> zie <a
href="https://netbeans.org/kb/articles/mobility.html">hier</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' >De NetBeans Profiler is een project dat integreert de JFluid profiling 
technologie van Sun Labs, in NetBeans IDE. Het doel van dit project is om
een krachtige en flexibele profiling oplossing te leveren die geintegreerd
is in de IDE workflow. De laatste NetBeans Profiler Release (Milestone 6)
werkt met NetBeans IDE 4.0 en 4.1.

<p>Bezoek <a
href="http://profiler.netbeans.org">http://profiler.netbeans.org</a> om
de laatste versie te downloaden of voor meer informatie.

<p><b>Key features in Milestone 6:</b>
<ul><li>Ondersteuning voor JDK 1.4.2 en JDK 6.0 (Mustang) (zie onderaan bij
Wat is nieuwe)
<li>Goede integratie in de IDE workflow
<li>Lage overhead profiling door gebruik van JFluid technologie
<li>Task-gebaseerde approach om profiling te vergemakkelijken
<li>CPU Performance profiling
<li>Memory profiling, memory leak detectie
<li>Attachen aan (gedeployde) runnende applicatie
<li>Threads profiling</li></ul>

<b>Wat is nieuw in de Milestone 6 release:</b></ul>

<li>Ondersteuning voor Tiger (5.0) en Mustang (6.0) JDKs - de profiler 
ondersteunt in Mustang builds (de Mustang builds kunnen gedownload worden van
<a href="https://mustang.dev.java.net">http://mustang.dev.java.net</a>). JDK
5.0 zal worden ondersteund vanaf release 5.0_04 (gepland om te worden 
gereleased rond het eind van Juni)
<li>Nieuwe profiler control panel
<li>Significante performance en UI responsiveness verbeteringen, inclusief
kleiner profiling overhead in Monitoring mode
<li>Nieuwe installer die het installatie proces vergemakkelijkt
<li>(Zoals altijd) een groot aantal bugfixes</li></ul>

De complete lijst van nieuwe features, verbeteringen en bugfixes kunnen worden
hier
gevonden worden.

En ander Profiler nieuws:
<ul><li>Als je dit interview gemist hebt; <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>Een geupdate versie van <a
href="https://netbeans.org/kb/articles/nb-profiler-tutor-6.html">NetBeans
IDE 4.0 Profiler Tutorial</a> is nu beschikbaar voor Milestone 6.</li></ul>

Het Profiler team ontwikkelt ook tools gerelateerd aan profiling. De eerste
van zo'n tool dat beschikbaar is is een integratie van Visual GC in de NetBeans
IDE. Voor meer details zie de <a 
href="http://profiler.netbeans/visualgc/index.html">Visual GC
Integration Module homepagina</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'>meer informatie en 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' >Het doel van dit project is om een set van NetBeans modules te ontwikkelen
die je helpen om code te schrijven in een dynamische talen in de NetBeans
IDE. Voor nu is het <a href="http://groovy.codehaus.org">Groovy</a> en 
<a href="http://www.jython.org">Jython</a> waar ze zich op concentreren,
maar we verwachten een gemeenschappelijk framework voor meerdere talen.</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'>leer meer</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' >Meer en meer developers zijn geinteresseerd om over te schakelen naar de 
NetBeans IDE om voordeel te halen uit alle features die out-of-the-box
beschikbaar zijn. Dat is waarom we, de NetBeans gemeenschap, de "Switch" 
website gestart zijn. Lees developers' verhalen en leer waarom zij zijn
overgeschakeld naar de NetBeans IDE. Leer hoe de NetBeans IDE developer
productiviteit verbetert en hoe gemakkelijk het is om over te schakelen.
Als onderdeel van het Switch programma levert NetBeans de Eclipse Project
Import Module voor een eenvoudige, gemakkelijk te implementeren overschakeling
van Eclipse-gebaseerd projecten naar een de NetBeans IDE.

<p>Help het woord te verspreiden en haal je vrienden en collega's over naar
de nieuwe NetBeans IDE door te tonen wat de NetBeans IDE levert! En gebruik
een aantal <a 
href="https://netbeans.org/community/teams/marketing/collateral.html">cool
NetBeans graphics</a> en post ze op het Internet of gebruik ze in je 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'>schakel over naar 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 Heeft Je Nodig - Stem!</b></font><br>&nbsp;<br><font face='Verdana, sans-serif, helvetica, arial' >De Java Developer's Journal, LinuxWorld Magazine, en de Web Services Journal
houden hun run voor de jaarlijkse Readers' Choice awards. NetBeans is 
genomineerd door alle drie! <p>Neem een moment en stem voor je favoriete IDE!
De stem period loopt tot 31 Juli.

<p>Stem voor NetBeans in de volgende categorien van de 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>Stem voor de NetBeans IDE bij LinuxWorld Magazine awards. NetBeans is 
genomineerd in de volgende categorien:
<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>Als laatste maar niet de minste stem voor NetBeans bij de Web Services 
Journal: 
<ul><li>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 Catalogus</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' >Er zijn meerder plugins beschikbaar voor de NetBeans IDE 4.0. In deze sectie 
bekijken we naar een aantal van de highlights.

<p><a href="http://www.insitechinc.com/">XTT v5.0 - Smart Web Clients for
Java</a> - XTT - Smart Web Clients for Java is een leidende Java-gebaseerde,
RAD ontwikkelings framework voor het bouwen en deployen van gedistribueerde,
Rich, Ultra-thin, Swing gebaseerde web applicaties. Je kan de <a
href="http://www.insitechinc.com/demo.php3">demo by InsiTech</a> bekijken.

<p><a href="http://www.refactorit.com/?id=5327">RefactorIT 2.5 Update 7</a> -
Agris Software heeft versie 2.5 Update 7 voor RefactorIT gereleased. De 2.5
Update 7 integreert zich in NetBeans versie 4.0+ en het ondersteunt CVS 
gemounte file-systemen voor al de transformaties. RefactorIT ondersteunt J2SE
5.0 en levert verscheidene verbeteringen op de populaire grafische dependency
analyzer.

<p><a href="http://www.visual-paradigm.com/sbenb.php">SDE 2.1</a> - SDE 2.1 
voor NetBeans levert volledige UML 2.1 ondersteuning voor je NetBeans, je kan
je applicatie modelleren in de laatste UML notaties en diagrammen. Visual
Paradigm's modelling environment integreert zich met NetBeans; je kan analyse,
design, implementatie en deployment doen vanuit &eacute;&eacute;n platform.
Je code en documentatie is altijd gesynchronizeerd. Je kan je design bespreken
met je collega door middel van de geschetste UML diagrammen in de NetBeans IDE.

<p><a 
href="http://sourceforge.net/project/showfiles.php?group_id=56262&package_id=63621">PMD
Plugin</a> - Een nieuwe versie van de PMD plugin werkt met de NetBeans
IDE 4.0 en bundelt de laatste beschikbare versie is nu beschikbaar. PMD is een
tool die je Java source code scant en die zoekt naar mogelijk problemen. De 
plugin kan gerund worden vanuit de IDE en levert uitvoer met hyperlinks.

<p><a href="http://mevenide.codehaus.org/mevenide-netbeans-project/">Meveide
0.6</a> - Het doel van het project is om Maven project type support te leveren
voor de NetBeans IDE 4.0. De features zijn o.a. herkenning van Maven projecten,
setup van het project in de IDE, runnen van Maven, editor support voor 
configuratie files etc. Veranderingen is deze versie zijn o.a:
<ul><li>Lokaal en Remote browser support toegevoegd. Maakt het mogelijk om
artifacten te downloaden van een remote repository.
<li>Dependency editing in visual project customizer toegevoegd.
<li>Link findbugs report output met de IDE's editor. Voeg annotaties toe aan 
de editor.</li></ul>

<a href="http://www.appperfect.com/index.html">AppPerfect</a> heeft drie 
geupdate aanbiedingen: AppPerfect JVM Profiler, AppPerfect Unit Tester en
de 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>
