<HTML>
<HEAD>

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

<title>NetBeans Edge - Editie 25 - Oktober 2004</title>
<meta NAME="description" CONTENT="The NetBeans Edge monthly newsletter, Editie 25, Oktober 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 19-Nov 14:52 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 Catalogus</font></a>
<font face='Verdana, sans-serif, helvetica, arial' color='#FFFFFF' size='1'> Catalogus van vrije en commerciele add-on modules beschikbaar voor de 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 member is<br></font> </td></tr><td><a href='http://services.netbeans.org/downloads/download.php?a=b&amp;p=1' style='color:white'><font face='Verdana, sans-serif, helvetica, arial' size='1' color='#FFFFFF'>NetBeans IDE 3.6</font></a>
<font face='Verdana, sans-serif, helvetica, arial' color='#FFFFFF' size='1'> Beschikbaar als download<br></font> </td></tr><td><a href='https://netbeans.org/community/releases/40/index.html' style='color:white'><font face='Verdana, sans-serif, helvetica, arial' size='1' color='#FFFFFF'>Nieuw! NetBeans IDE 4.0 Beta</font></a>
<font face='Verdana, sans-serif, helvetica, arial' color='#FFFFFF' size='1'> De aankomende 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'>openide</font></td>
        </tr><tr>
              <td><a href='https://netbeans.org/servlets/ReadMsg?msgId=835872&listName=openide' style='color:#FFFFFF;'><font face='Verdana, sans-serif, helvetica, arial' color='#FFFFFF' style='font-size:11px;' size='1'>3.5.1 to 4.0</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 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=850096&listName=nbusers' style='color:#FFFFFF;'><font face='Verdana, sans-serif, helvetica, arial' color='#FFFFFF' style='font-size:11px;' size='1'>Re: [TECHNOLOGY] - JAVA + NetBeans + ??? = easy & scalable production!</font></a></td>
              <td align='right' valign='top'><font face='Verdana, sans-serif, helvetica, arial' style='font-size:11px;' size='1' color='#FFFFFF'>23</font></td>
              </tr><tr>
              <td><a href='https://netbeans.org/servlets/ReadMsg?msgId=843332&listName=nbusers' style='color:#FFFFFF;'><font face='Verdana, sans-serif, helvetica, arial' color='#FFFFFF' style='font-size:11px;' size='1'>Re: Is NB4.0 really ready for J2SE 5 ?</font></a></td>
              <td align='right' valign='top'><font face='Verdana, sans-serif, helvetica, arial' style='font-size:11px;' size='1' color='#FFFFFF'>21</font></td>
              </tr><tr>
              <td><a href='https://netbeans.org/servlets/ReadMsg?msgId=849314&listName=nbusers' style='color:#FFFFFF;'><font face='Verdana, sans-serif, helvetica, arial' color='#FFFFFF' style='font-size:11px;' size='1'>Re: Mainclass attribute in Jar-manifest</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=849416&listName=nbusers' style='color:#FFFFFF;'><font face='Verdana, sans-serif, helvetica, arial' color='#FFFFFF' style='font-size:11px;' size='1'>List cvs modules</font></a></td>
              <td align='right' valign='top'><font face='Verdana, sans-serif, helvetica, arial' style='font-size:11px;' size='1' color='#FFFFFF'>18</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'>95</font></td>
				</tr><tr><td><font face='Verdana, sans-serif, helvetica, arial' style='font-size:11px;' size='1' color='#FFFFFF'>Tim Boudreau</font></td>
				<td align='right' valign='top'><font face='Verdana, sans-serif, helvetica, arial' style='font-size:11px;' size='1' color='#FFFFFF'>92</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'>69</font></td>
				</tr><tr><td><font face='Verdana, sans-serif, helvetica, arial' style='font-size:11px;' size='1' color='#FFFFFF'>Peter Nabbefeld</font></td>
				<td align='right' valign='top'><font face='Verdana, sans-serif, helvetica, arial' style='font-size:11px;' size='1' color='#FFFFFF'>44</font></td>
				</tr><tr><td><font face='Verdana, sans-serif, helvetica, arial' style='font-size:11px;' size='1' color='#FFFFFF'>Ilias Lazaridis</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>		</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: Oktober</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,722,087; +51,409</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: 71,314; +3,287</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: 124,680; +12,604</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'>+3,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-25.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-25_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-25_ru.html'><img src='/images_www/flags/ru_small.gif' width='20' height='13' alt='Russian Edition' border='0'></a>&nbsp;</td>  <td align='right'><font face='Verdana, sans-serif, helvetica, arial' ><b>Editie 25</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='s208'></a><font face='Verdana, sans-serif, helvetica, arial' color='#FF0F12' class='titlec'><b>NetBeans Edge, Editie 25</b></font><br>&nbsp;<br><font face='Verdana, sans-serif, helvetica, arial' >Welkom bij editie 25 van de NetBeans Edge!

<p>De belangrijkste nieuws van de maand Augustus is de aangekondigde beschikbaarheid
van de NetBeans IDE 4.0 Beta en de NetBeans Platform 4.0 Beta downloads!

<p>Grijp je kans en test de nieuwste en beste NetBeans
IDE 4.0 Beta release die reeds goede reviews krijgt, wereldwijd developers
overhaald en de NetBeans community blij maakt. Om een quote te lenen van James
Goslings blog, "<i><a href="http://blogs.sun.com/jag/">NetBeans 4.0
Rocks!</a></i>"

<p>Het nieuwe NetBeans 4.0 NetCAT programma (<a
href="http://qa.netbeans.org/processes/cat/40/index.html">wat is NetCAT?</a>)
draait nu. In de eerste 48 uur van de vraag voor participanten werden meer
dan 260 geldige aaanvragen ingestuurd. De verwachting van de NetBeans IDE
4.0 release is enorm!

<p>In deze edition zal je het NetBeans 4.0 release schema vinden, download
links, en een schare aan resources om je te laten starten.

<p>Neem wat koffie, leun achterover en lees meer over NetBeans 4.0 Beta 1 en
wat het voor jou betekent. Vergeet de mailing lijst nbusers@netbeans.org niet
waar je vragen kan stellen over het gebruik van de IDE. Er is een grote groep
mensen die altijd gewillig zijn om je vragen te beantwoorden en je goede tips
leveren. <a href="https://netbeans.org/community/lists/top.html">Schrijf in 
of lees het archief</a>. Je kan ook de laatste release promoten door het 
plaatsen van een <a
href="https://netbeans.org/community/teams/marketing/movetheneedle.html">NetBeans
graphic</a> on je webpage of het officiele <a
href="https://netbeans.org/community/teams/marketing/collateral.html">NetBeans logo</a>.

<p>Je commentaar en suggesties worden altijd gewaardeerd en we luisteren. Stuur
je feedback, commentaar of 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></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='s209'></a><font face='Verdana, sans-serif, helvetica, arial' color='#FF0F12' class='titlec'><b>NetBeans IDE 4.0 Beta 1</b></font><br>&nbsp;<br><font face='Verdana, sans-serif, helvetica, arial' >We zijn verheugd om de NetBeans IDE en NetBeans Platform 4.0 Beta 1 te kunnen
aankondigen. <a
href="https://netbeans.org/downloads/index.html">Downloads</a>

<p><b>Een aantal van de belangrijkste features zijn:</b>
<ul>
<li><b>Tiger (J2SE 5.0) ondersteuning</b> - Java 2 Platform, Standaard Editie 5.0
language feature ondersteuning
<li><b>Ant-gebaseerd project systeem</b> - Een nieuw project systeem gebaseerd op Open
Source Apache Ant technologies
<li><b>J2ME MIDP support</b> Java 2 Platform, Micro Editie (J2ME) Mobile
Information Device Profile (MIDP) development ondersteuning
<li>Java refactoring - inclusief: renames (class/method/field), move class,
rename package, change method parameters, encapsulate field and find
references
<li><b>J2EE verbeterde ondersteuning</b> - Java 2 Platform, Enterprise Editie (J2EE)
development ondersteuning voor NetBeans IDE 4.x (Early Access beschikbaar in October)
<li>Performance Profiler (binnenkort beschikbaar)</li></ul>

De initiele Early Access van de Performance Profiler is NU beschikbaar als een 
separate module collection download voor NetBeans IDE 3.6. De beta versie zal
beschikbaar zijn als een additionele download voor de production versie van de 
NetBeans IDE 4.0 in December. <a href="http://profiler.netbeans.org/">Meer
informatie</a>.

<p>Het NetBeans IDE 4.0 release schedule:
<ul>
<li>September 22 - 4.0 Beta 2 Released Gebaseerd op Beta 1 Feedback
<li>Eind September - High Resistance Mode
<li>Mid November - Release Candidate Build Testing
<li>Eind November - Customer Acceptance Survey Launched
<li>Mid December - Final Release Versie
<li>Mid December - J2EE Module Collection 
</li></ul></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/index.html' target='new'>complete 4.0 details</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='s210'></a><font face='Verdana, sans-serif, helvetica, arial' color='#FF0F12' class='titlec'><b>Documentatie Lijst voor NetBeans IDE 4.0 Beta</b></font><br>&nbsp;<br><font face='Verdana, sans-serif, helvetica, arial' ><b>Quick Start Guides</b>

<p><a href="https://netbeans.org/kb/archive/index.html">NetBeans
IDE 4.0 Quick Start Guide</a> - Levert je een snelle tour van de IDE die je
gidst door middel van het creeren van een simpele applicatie. Dit document 
vergt minder dan 20 minuten om te verwerken.

<p><a
href="https://netbeans.org/kb/articles/quickstart-webapps-40.html">NetBeans
IDE 4.0 Beta Quick Start Guide voor Web Applicaties</a> - Zoomt in op de 
basics van het creeren van een simpele web module door middel van de NetBeans
IDE.

<p><a
href="https://netbeans.org/kb/articles/quickstart-mobility-40.html">J2ME
MIDP Development voor NetBeans IDE 4.0 Beta Quick Start Guide</a> - Levert je
de basics om NetBeans IDE 4.0 te gebruiken voor het ontwikkelen voor Java 2 
Platform, Micro Editioe  (J2ME platform), Mobile Information Device Profile 
(MIDP). 

<p><b>Import en Migratie Guides</b>

<p><a href="https://netbeans.org/kb/articles/import_j2se_40.html">Importing
Existing Java Source Code into NetBeans IDE 4.0 Beta</a> - Legt je uit hoe
je een bestaande Java desktop applicatie kan importeren in NetBeans IDE 4.0.

<p><a href="https://netbeans.org/kb/articles/import_web_40.html">Importing
Existing Web Applications into NetBeans IDE 4.0 Beta</a> - Legt je uit hoe je
bestaande web module projecten kan importeren in NetBeans IDE 4.0.

<p><a
href="https://netbeans.org/kb/archive/index.html">Importing
Existing J2ME MIDP Source Code into NetBeans IDE 4.0</a> - Legt je uit hoe je
bestaande J2ME platform source code kan importeren in een NetBeans IDE 4.0 project.

<p><a
href="https://netbeans.org/kb/articles/transition-40.html">Transitioning
from NetBeans IDE 3.6 to 4.0 Beta</a> - Helpt je over te schakalen van 
NetBeans IDE 3.6 naar NetBeans IDE 4.0.

<p><b>Tutorials en  Andere Artikelen</b>

<p><a
href="https://netbeans.org/kb/articles/freeform-config-40.html">Advanced
Freeform Project Configuration</a> - Toont je hoe jee een freeform project kan
configureren om de IDE te integreren in jouw bedrijf's build process.
Bevat information over het aansluiten van Ant targets op IDE commands en het
schrijven van targets om je applicatie te debuggen.

<p><a
href="https://netbeans.org/kb/archive/index.html">NetBeans
IDE 4.0 Beta Coin Flip Tutorial</a> - Toont je hoe je web applicatie kan
bouwen die data opslaat door middel van een JavaBeans component, die data 
verwerkt door middel van een servlet, en data weergeeft door middel van JavaServer 
Page technologie. Deze tutorial vergt ongeveer 30 minuten.

<p><a
href="https://netbeans.org/kb/archive/index.html">NetBeans
IDE 4.0 Beta Midnight Cookie Company Tutorial</a> - Toont hoe je de NetBeans
IDE kan gebruiken om een web applicatie, die JSP paginas en servlets bevat en 
tags gebruikt van de JSTL tag library, te bouwen, deployen, en executeren. 
Toont eveneens hoe je de HTTP monitor kan gebruiken om de requests
en responses tussen server en web browser te monitoren.</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/articles/doclist-40beta.htm' target='new'>online lijst</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='s211'></a><font face='Verdana, sans-serif, helvetica, arial' color='#FF0F12' class='titlec'><b>NetBeans Wordt Groovy</b></font><br>&nbsp;<br><font face='Verdana, sans-serif, helvetica, arial' >Sinds 1 September is de CVS versie van de module die scripting ondersteunt
door middel van de <a
href="http://groovy.codehaus.org/" Target="_Blank">groovy</a> language beschikbaar. 
Checkout de scripting module uit van CVS: cvs -d
:pserver:anoncvs@cvs.netbeans.org:/cvs co scripting standard en voer dan 
ant -f scripting/build.xml all-scripting uit om een aantal NBM files te genereren
in subdirectories, dan kan je ze installeren in de NetBeans 4.0 IDE Beta or Dev
versies.</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://scripting.netbeans.org/' target='new'>scripting module website</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='s212'></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' ><b><a href="http://plugins.netbeans.org/">MagicDraw UML
8.0</a></b> - De Nieuwe MagicDraw UML 8.0 presenteert een visueel beeldvan
bestaande applicaties door middel van zijn nieuwe feature: Java reverse 
engineering van code naar sequence diagrams. MagicDraw UML 8.0 importeert
ook UML models van elke bron
� een XMI import of een reverse engineering operatie � en geeft het visueel
weer.
Een nieuw diagram layout engine levert zeven layout opties die automatisch
de gegenereerde diagrammen aligned voor een professionele look en feel.

<p><b><a
href="http://plugins.netbeans.org/">turbosql</a></b> -
Switchen tussen console en IDE kan vervelend zijn als je software ontwikkelt. 
Door middel van turbosql, kan je Postgresql bedienen vanuit NetBeans snel
en visueel, en daardoor verbeter je de productiviteit van de developer. Features 
creeren, aanpassen, verwijderen en browsen van databases en tabellen.</font></td>
      <td><IMG SRC='/images_www/pixel.gif' WIDTH='12' HEIGHT='1' ALT=''></td>
      </tr>
      <tr class='tabler' bgcolor='#ffffff'><td colspan='4'>&nbsp;</td></tr>
      <tr class='tabler' bgcolor='#ffffff'>
      <TD  VALIGN='bottom' class='tabler' bgcolor='#ffffff'><IMG SRC='/images_www/pixel.gif' WIDTH='1' HEIGHT='1' ALT=''></TD>
      <td><font face='Verdana, sans-serif, helvetica, arial' >[<a href='https://netbeans.org/catalogue' target='new'>module catalogue</a>]</font>&nbsp;</td>
      <td align='right'><font face='Verdana, sans-serif, helvetica, arial' >&nbsp;</font></td>
      <TD  VALIGN='bottom' class='tabler' bgcolor='#ffffff'><IMG SRC='/images_www/pixel.gif' WIDTH='1' HEIGHT='1' ALT=''></TD>
      </tr>
      <tr class='tabler' bgcolor='#ffffff'>
      <TD  VALIGN='bottom' class='tabler' bgcolor='#ffffff'><IMG SRC='/images_www/marketing_newsletter/template/bottom-left.gif' WIDTH='12' HEIGHT='17' ALT=''></TD>
      <TD  colspan='2' VALIGN='bottom' class='tabler' bgcolor='#ffffff'><IMG SRC='/images_www/pixel.gif' WIDTH='1' HEIGHT='1' ALT=''></TD>
      <TD  aligm='right' VALIGN='bottom' class='tabler' bgcolor='#ffffff'><IMG SRC='/images_www/marketing_newsletter/template/bottom-right.gif' WIDTH='12' HEIGHT='17' ALT=''></TD>
      </tr>
      </table><img src='/images_www/pixel.gif' width='1' height='4' bolder='0'><table border='0' cellpadding='0' cellspacing='0' width='98%'>
      <tr class='tabler' bgcolor='#ffffff'>
      <TD  VALIGN='TOP' class='tabler' bgcolor='#ffffff'><IMG SRC='/images_www/marketing_newsletter/template/top-left.gif' WIDTH='12' HEIGHT='17' ALT=''></TD>
      <td>&nbsp;</td>
      <td align='right'>&nbsp;</td>
      <TD  VALIGN='TOP' class='tabler' align='right' bgcolor='#ffffff'><IMG SRC='/images_www/marketing_newsletter/template/top-right.gif' WIDTH='12' HEIGHT='17' ALT=''></TD>
      </tr>
      <tr class='tabler' bgcolor='#ffffff'>
      <td class='tabler' bgcolor='#ffffff'><IMG SRC='/images_www/pixel.gif' WIDTH='12' HEIGHT='1' ALT=''></td>
      <td colspan='2'><a name='s213'></a><font face='Verdana, sans-serif, helvetica, arial' color='#FF0F12' class='titlec'><b>In de Pers</b></font><br>&nbsp;<br><img src='/images_www/marketing_newsletter/3.jpg' widht='100' height='106' border='0' alt='Press - 2k' align='left' vspace='2' hspace='10'><font face='Verdana, sans-serif, helvetica, arial' >Hoofd Items:

<p><a href="https://netbeans.org/community/releases/40/index.html">NetBeans 
IDE 4.0 Beta 1 Uitgebracht</a> - NetBeans.org
<br/>De NetBeans IDE 4.0 Beta levert een aantal belangrijke upgrades, zoals:
ondersteuning voor Tiger (J2SE 5.0), een herschreven Ant-gebaseerd project 
systeem, en Java refactoring.

<p><a
href="http://java.sun.com/developer/technicalArticles/JavaLP/netbeans40/">NetBeans
IDE: What's Nieuw in de NetBeans 4.0 IDE</a> - java.sun.com - Om je te helpen om
te bepalen of de NetBeans IDE er is voor jou, geeft dit artikel een overview van
de NetBeans IDE, stipt de nieuwe features in de NetBeans 3.6 IDE, en de komende
features in NetBeans 4.0 IDE aan. Het artikel levert een vergelijk tussen de 
NetBeans IDE and Eclipse.

<p><a
href="http://www.builderau.com.au/program/work/0,39024650,39130644,00.htm">Java
Developers krijgen NetBeans preview</a> - Builder.AU - De beta release van NetBeans
4.0 toont waar cross-platform development naar toe gaat.

<p>Andere News Blogs:

<p><a href="http://weblogs.java.net/blog/campbell/archive/2004/09/netbeans_40_per.html">NetBeans 4.0: Perfect Genoeg
voor de Luien en de Veel-eisenden</a>

<p><a
href="http://nwc.linuxpipeline.com/showArticle.jhtml?articleID=32100001">NetBeans
Levert Version 4.0 Beta</a> 

<p><a href="http://www.infoworld.com/article/04/08/26/HNide_1.html">NetBeans
IDE beta uitgegeven</a> 

<p>NetBeans 4.0 beta1
ziet er inderdaad veel belovend uit 

<p><a href="http://blogs.sun.com/roller/page/swinger/20040903#netbeans_4_0_beta_is">NetBeans
 4.0 Beta is Cool!</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='https://netbeans.org/about/press/index.html' target='new'>pers archieven</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>
