<HTML>
<HEAD>

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

<title>NetBeans Edge - Editie 22 - April 2004</title>
<meta NAME="description" CONTENT="The NetBeans Edge monthly newsletter, Editie 22, 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 19-May 16:59 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 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 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'>Nieuw! NetBeans IDE 3.6</font></a>
<font face='Verdana, sans-serif, helvetica, arial' color='#FFFFFF' size='1'> Beschikbaar voor download<br></font> </td></tr><td><a href='http://developers.sun.com/prodtech/javatools/jsstandard/index.html' style='color:white'><font face='Verdana, sans-serif, helvetica, arial' size='1' color='#FFFFFF'>Sun Java Studio Portal</font></a>
<font face='Verdana, sans-serif, helvetica, arial' color='#FFFFFF' size='1'> NetBeans 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-22.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-22_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-22_pt.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-22_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 22</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='s186'></a><font face='Verdana, sans-serif, helvetica, arial' color='#FF0F12' class='titlec'><b>NetBeans Edge, Editie 22</b></font><br>&nbsp;<br><font face='Verdana, sans-serif, helvetica, arial' >Wees Betrokken!
<br/>
Door Steve Wilson, Engineering Director, Sun Microsystems
<p>
De NetBeans gemeenschap groeit explosief. In de afgelopen zes maanden is
het aantal ingeschrevenen op onze mailing lijsten gegroeid van ongeveer 5.000
naar 40.000!  Met zoveel nieuwe leden van de gemeenschap dacht ik dat het de
moeite waard zou zijn om te spreken over hoe je beter betrokken kan zijn in
wat er aan de gang is. Er zijn op dit moment een aantal manieren om betrokken
te zijn en we werken aan zelfs nog andere opties, ongeacht van de tijd die je
er wil insteken.
<p>
Gebruik de IDE en Vertel een Vriend!<br/>
Ons doel is om zo veel gebruikers als mogelijk is te krijgen voor de technologie
geproduceerd op NetBeans.org.   De makkelijkste manier om deel te nemen in de
gemeenschap is door mensen te laten weten dat je de technologie goed vindt.
<p>
Discussieer over de Toekomst!<br/>
De meeste mensen die zijn ingeschreven op onze mailing lijsten zijn ingeschreven
op de "announce" lijst -- en dat is slecht communicatie een kant op.  Er zijn
echter een behoorlijk aantal lijsten waar gebruikers en developers discussieren
over een verschillende onderwerpen. Voor een lijst van interessante lijsten kan
je gaan naar:
<p>
<a
href="https://netbeans.org/community/lists/top.html">https://netbeans.org/community/lists/top.html</a>
<p>
De "nbdiscuss" lijst is een goede plaats om je stem te laten horen over zaken
die je wil dat gaan gebeuren in de gemeenschap die voorwaarts gaat. Discussies
op "nbusers" en "nbdev" hebben recentelijk een grote impact gehad op het design
van NetBeans 4.0 features, zoals het nieuwe build systeem. Laat je stem horen.
<p>
Spring er gelijk in!<br/>
Als je NetBeans gebruikt dan ben je een Java developer.  De IDE is modulair
ontworpen zodat mensen features en functionaliteit kunnen toevoegen zonder
de code IDE te hoeven hacken.  Recentelijk heeft het team dat Web Apps support
programmeert hulp gevraagd bij het implementeren van een feature om het
compileren van JSP pagina's te testen.  Ontwikkelaar Illy Kysil heeft aangeboden
om te helpen en heeft een initiele versie van deze module gemaakt die gebruikers
nu kunnen proberen.  Bedankt Illya!
<p>
Wat Volgt?<br/>
In de komende maanden zullen we meer en betere manieren uitrollen om betrokken
te zijn.  We willen het makkelijker maken om bij te dragen zodat iedereen een
betere ervaring kan hebben.  Als je een suggesties hebt over hoe we dat kunnen
verbeteren mail naar nbdiscuss en laat ons je ideetjes horen.</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;Steve Wilson</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='s189'></a><font face='Verdana, sans-serif, helvetica, arial' color='#FF0F12' class='titlec'><b>NetBeans One</b></font><br>&nbsp;<br><font face='Verdana, sans-serif, helvetica, arial' >De Eerste NetBeans One conferentie die plaats heeft bij JavaOne.
<p>
Op Dinsdag, 29 Juni, 2004, zullen we een event hebben tegelijkertijd met Java
One dat het NetBeans project zal uitdragen inclusief een preview van de laatste
release, binnenin NetBeans technologie en ook als feature key NetBeans Partners.
<p>
De keynote zal gedaan worden door James Gosling over Tools en de toekomst. En
als je James ooit hebt zien praten, dan weet je dat er grote verrassingen zullen
zijn. Dit wil je niet missen!
<p>
Voor diegene die JavaOne bezoeken, is NetBeans One gratis. Voor diegenen die
JavaOne niet bezoeken is NetBeans One ook gratis, maar zij krijgen een
toegevoegde bonus van een gratis JavaOne Pavilion Pass samen met een $200
korting op een volledige JavaOne registratie.
<p>
Dit is een goede tijd om te horen van de Sun technische staff die het NetBeans
project managen, om te leren over de technologie en de routekaart. Daarenboven
zullen we NetBeans partners introduceren die NetBeans tot een levendig product
maken. Ontmoet je NetBeans collega's en verkrijg die onschatbare tips door het
delen van kennis.
<p>
We zullen de conferentie hebben in het Yerba Buena Theater dat nast het
Moscone Convention Centers ligt. Het voorgestelde schema van events is als
volgt:
<p>
<table cellpadding="2" cellspacing="2">

<tr class="tablerbg">
<td class="smalltext"><B>Tijd</b></td>
<td class="smalltext"><B>Titel</b></td>
<td class="smalltext"><B>Sprekers</b></td>
</tr>

<tr class="tablersh">
<td class="smalltext">9:00 AM</td>
<td class="smalltext">Registratie</td>
<td class="smalltext"> </td>

<tr>
<td class="smalltext">10:00 AM</td>
<td class="smalltext">Keynote: De Toekomst van Open Source Dev Tools</td>
<td class="smalltext">James Gosling, Steve Wilson</td>
</tr>

<tr class="tablersh">
<td class="smalltext">11:00 AM</td>
<td class="smalltext">Vooruitgangen in NetBeans Technologie</td>
<td class="smalltext">Ian Formanek, Tim Boudreau, Jesse Glick</td>
</tr>

<tr>
<td class="smalltext">12:00 PM</td>
<td class="smalltext">NetBeans Plug-in Development brownbag</td>
<td class="smalltext">Jesse Glick, Tim Boudreau</td>
</tr>

<tr class="tablersh">
<td class="smalltext">1:00 PM</td>
<td class="smalltext">NetBeans Oplossingen  I</td>
<td class="smalltext">Moderator + Partners</td>
</tr>

<tr>
<td class="smalltext">2:00 PM</td>
<td class="smalltext">Het bouwen van Web Applicaties met NetBeans</td>
<td class="smalltext">Anna Von Klopp, Pavel Buzek, Chris Kutler</td>
</tr>

<tr class="tablersh">
<td class="smalltext">3:00 PM</td>
<td class="smalltext">NetBeans Oplossingen  II</td>
<td class="smalltext">Moderator + Partners</td>
</tr>

<tr>
<td class="smalltext">4:00 PM</td>
<td class="smalltext">Het bouwen van Mobiele Applicaties met NetBeans</td>
<td class="smalltext">Martin Ryzl</td>
</tr>

<tr class="tablersh">
<td class="smalltext">5:00 PM</td>
<td class="smalltext">BOF: NetBeans Community Development en Marketing</td>
<td class="smalltext">Zaheda Bhorat, Larry Baron, Robert Demmer</td>
</tr>

<tr>
<td class="smalltext">6:00-8:00 PM</td>
<td class="smalltext">Sun Tools Event</td>
<td class="smalltext">Versnaperingen, awards, demos en meer</td>
</tr>

</table></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;Larry Baron</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='s191'></a><font face='Verdana, sans-serif, helvetica, arial' color='#FF0F12' class='titlec'><b>NetBeans IDE 3.6 Meertalige Cobundle</b></font><br>&nbsp;<br><font face='Verdana, sans-serif, helvetica, arial' >De Chinese en Japanese NetBeans IDE 3.6 meertalige editie is <a
href="http://services.netbeans.org/downloads/download.php?a=b&amp;p=1">nu beschikbaar
voor download</a>.

<p>De volgende documenten zijn gelocalizeerd in Chinees en Japans om je te
helpen:

<p>Installation Guide: <a
href="https://netbeans.org/community/releases/36/install_zh_CN.html">Chinese</a>,
<a href="https://netbeans.org/community/releases/36/install_ja.html">Japanese</a>

<br>Release Notes: <a
href="https://netbeans.org/community/releases/36/relnotes_zh_CN.html">Chinese</a>,
<a href="https://netbeans.org/community/releases/36/relnotes_ja.html">Japanese</a>

<br>What's New in NetBeans 3.6? <a
href="https://netbeans.org/community/releases/36/Whats_New_zh_CN.html">Chinese</a>,
<a href="https://netbeans.org/community/releases/36/Whats_New_ja.html">Japanese</a>

<br>GUI Building in NetBeans IDE 3.6: <a
href="https://netbeans.org/kb/archive/index.html">Chinese</a>,
<a href="https://netbeans.org/kb/archive/index.html">Japanese</a>

<br>NetBeans IDE 3.6 Quick Start Guide: <a
href="https://netbeans.org/kb/archive/index.html">Chinese</a>,
<a href="https://netbeans.org/kb/archive/index.html">Japanese</a>

<brUsing NetBeans 3.6: <a
href="https://netbeans.org/kb/archive/index.html">Chinese</a>,
<a href="https://netbeans.org/kb/archive/index.html">Japanese</a>

<p>Je kan je ook <a
href="mailto:nbdiscuss_zh-subscribe@netbeans.org">inschrijven</a> op de chinese
discussie lijst: nbdiscuss_zh@netbeans.org</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='s187'></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>nbxsl</b> - XML
<p><a href="http://www.japisoft.com/nbxslt/">JAPISoft</a> heeft nbxsl
v1.0 uitgebracht, een nieuwe module voor het editen van XSLT met een snel
resultaat view en XPath evaluatie. Volg de <a
href="http://plugins.netbeans.org/">link</a> voor meer
informatie plus een link voor vrije evaluatie.
</p>

<b>RefactorIt</b>
<p>Daarnaast is ook RefactorIT 2.0 RC2 (build 1.9.15) beschikbaar. 2.0
RC2 werkt goed in de NetBeans IDE 3.6. Hiet is wat nieuw is toegevoegd:
<ul><li>4 nieuwe Quality Metrics: DIP, DCYC, EP, LSP (elke enkele
Metric heeft een aanbevolen interval en alle overtredingen zijn gekleurd
in de resultaat tabel)</li>
<li>"Freeze" optie was toegevoegd om Draw Dependencies</li>
<li>vele bug fixes en bruikbaarheid verbeteringen</li></ul>

Voor meer informatie over RefactorIT 2.0 RC2 bezoek onze <a
href="https://netbeans.org/community/news/index.html#448">nieuws entry</a> op
NetBeans.org of <a
href="http://www.refactorit.com">www.refactorit.com</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><font face='Verdana, sans-serif, helvetica, arial' >[<a href='https://netbeans.org/catalogue' target='new'>module catalogus</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='s188'></a><font face='Verdana, sans-serif, helvetica, arial' color='#FF0F12' class='titlec'><b>Nieuwe Artikelen</b></font><br>&nbsp;<br><font face='Verdana, sans-serif, helvetica, arial' >De <a href="https://netbeans.org/kb/archive/index.html">Midnight Cookie
Web Apps Tutorial</a> illustreert het gebruik van een Front Controller servlet
en een composite view binnen een pagina gecreerd met JavaServer Pages
technologie (JSP). De JSP pagina's in deze applicatie gebruiken JavaServer Pages
Standard Tag Library (JSTL).  Voor de tutorial kan je the NetBeans IDE 3.5 of
3.6 en J2SE 1.3 of 1.4 gebruiken.

<p>Het Bouwen van Web Modules Met NetBeans: Overstappen van 3.5 naar 3.6 - Dit
artikel beschrijft de nieuwe features in NetBeans 3.6 voor het bouwen van
web modules. Het bespreekt veranderingen in voorheen bestaande features die een
impact hebben op de manier waarop je je werk doet. Als laatste, het geeft een
lijst van een aantal bekende bugs en levert enkele tips.</p>

<p><a href="https://netbeans.org/kb/archive/index.html">Web Module
Quick Start Guide</a> - Dit document doorloopt de basis stappen van het
ontwikkelen, testen en debuggen van een web module door het creeren van een
simpel coin toss applicatie. Dit document is bedoeld om je zo snel als mogelijk
aan de slag te krijgen.</p>

<p><a
href="https://netbeans.org/community/releases/36/J2ME_Support.html">Toevoegen
van J2ME Platform Support aan de NetBeans IDE</a> - Beschrijft het updaten van
de NetBeans IDE met Mobility Modules voor NetBeans om support voor het
ontwikkelen en testen van applicaties voor mobiele devices, die het Java 2,
Micro Edition (J2ME) platform gebruiken, te integreren.

<p><a href="https://netbeans.org/kb/articles/j2me_tutorial.html">Mobility
Modules Tutorial</a> - De Mobility Modules Tutorial is een gids voor het creeren
en debuggen van een MIDP/CLDC application, oftewel "MIDLet," door middel van
de Mobility Modules en de NetBeans IDE.
</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/kb.html' target='new'>meer artikelen</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>
