<HTML>
<HEAD>
<title>NetBeans Edge - Número 21 - Abril 2004</title>
<meta NAME="description" CONTENT="The NetBeans Edge monthly newsletter, Número 21, Abril 2004 /Portuguese Edition">
<meta http-equiv="content-language" content="pt">
<meta http-equiv="content-type" content="text/html;  charset=utf-8">


<link rel="stylesheet" type="text/css" href="/netbeans.css">
<!-- ------------------------------------------------------ -->
<!-- Please do not edit this file by hand, it is rebuilt    -->
<!-- automatically and your changes will be lost.           -->
<!-- Contact webmaster@netbeans.org for details             -->
<!-- Rebuilt at 2004 05-May 16:06 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>Confira</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'>Catálogo de Módulos</font></a>
<font face='Verdana, sans-serif, helvetica, arial' color='#FFFFFF' size='1'> Catalogo de incrementos gratúitos e comerciais disponíveis para seu 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'> Comunidade central Java onde o NetBeans é um membro federado<br></font> </td></tr><td><a href='http://' style='color:white'><font face='Verdana, sans-serif, helvetica, arial' size='1' color='#FFFFFF'></font></a>
<font face='Verdana, sans-serif, helvetica, arial' color='#FFFFFF' size='1'> <br></font> </td></tr><td><a href='http://developers.sun.com/prodtech/javatools/jsstandard/index.html' style='color:white'><font face='Verdana, sans-serif, helvetica, arial' size='1' color='#FFFFFF'>Portal Sun Java Studio</font></a>
<font face='Verdana, sans-serif, helvetica, arial' color='#FFFFFF' size='1'> Recursos NetBeans relacionados<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>Temas Quentes</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>Remetente mais ativo</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>Estatísticas: Abril</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'>Downloads do IDE</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'>Downloads de Plateforma</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'>Assinantes</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'>Postadas</font></td>
</tr>
<tr>
<td colspan='2' valign='top'><font face='Verdana, sans-serif, helvetica, arial' style='font-size:11px;' size='1' color='#FFFFFF'>+4,008</font></td>
</tr>
		</table>
		</td>
	</tr>
	<tr>
		<td valign="top" height="26" background="/images_www/marketing_newsletter/template/transparent_bottom_menu_l.gif"><img src="/images_www/pixel.gif" width="170" height="26" border="0" alt=""></td>
	</tr>
</table>

	<!-- left menu -->




	</td>

<!--
	<td valign="top" height='82' colspan="2" align="right"><img src="/images_www/marketing_newsletter/template/banner.jpg" width="411" height="82" border="0" alt="Banner" hspace="0" vspace="0"></td>
</tr>
<tr>
-->

	<td bgcolor="#FFF0D4" width="410" valign='top'>

	<table border='0' width="100%">
	<tr>
  <td><a href='/community/news/edge-21_fr.html'><img src='/images_www/flags/fr_small.gif' width='20' height='13' alt='French Edition' border='0'></a>&nbsp;<a href='/community/news/edge-21_ru.html'><img src='/images_www/flags/ru_small.gif' width='20' height='13' alt='Russian Edition' border='0'></a>&nbsp;<a href='/community/news/edge-21_nl.html'><img src='/images_www/flags/nl_small.gif' width='20' height='13' alt='Dutch Edition' border='0'></a>&nbsp;<a href='/community/news/edge-21.html'><img src='/images_www/flags/uk_small.gif' width='20' height='13' alt='English Edition' border='0'></a>&nbsp;</td>  <td align='right'><font face='Verdana, sans-serif, helvetica, arial' ><b>Número 21</b></font></td></tr>
	</table>

	<table border='0' width='100%' cellspacing='3' cellpadding='3'>
  <tr>
  <td align='center'><table border='0' cellpadding='0' cellspacing='0' width='98%'>
      <tr class='tabler' bgcolor='#ffffff'>
      <TD  VALIGN='TOP' class='tabler' bgcolor='#ffffff'><IMG SRC='/images_www/marketing_newsletter/template/top-left.gif' WIDTH='12' HEIGHT='17' ALT=''></TD>
      <td>&nbsp;</td>
      <td align='right'>&nbsp;</td>
      <TD  VALIGN='TOP' class='tabler' align='right' bgcolor='#ffffff'><IMG SRC='/images_www/marketing_newsletter/template/top-right.gif' WIDTH='12' HEIGHT='17' ALT=''></TD>
      </tr>
      <tr class='tabler' bgcolor='#ffffff'>
      <td class='tabler' bgcolor='#ffffff'><IMG SRC='/images_www/pixel.gif' WIDTH='12' HEIGHT='1' ALT=''></td>
      <td colspan='2'><a name='s177'></a><font face='Verdana, sans-serif, helvetica, arial' color='#FF0F12' class='titlec'><b>NetBeans Edge, Edição 21</b></font><br>&nbsp;<br><font face='Verdana, sans-serif, helvetica, arial' ><p>Bem
vindo a edição vinte e um do jornal mensal do NetBeans. Depois de 20
edições do jornal sob o nome Sprout decidimos que era hora de para
algo novo. Eu apresento a vocês NetBeans Edge!</p>

<p>Sem sombra de dúvida, a versão NetBeans IDE 3.6 é o tema principal
desta edição. Parabéns a todos os membros da comunidade NetBeans.org
por outro fantástico esforço em prover a última versão do IDE
original, gratúito e open source; o NetBeans IDE 3.6!<p>Este mês, o NetBeans Edge
irá focar os recursos que irão ajudá-lo a se iniciar no uso do NetBeans IDE 3.6
e alavancando seu desenvolvimento mais e mais. Então, o quem vem a
seguir em relação ao NetBeans 3.6? A versão 3.6 estará disponível
em mais idiomas e incluido em vários pacotes. Tenha mais detalhes nesta
edição.</p>

<p>Em outra matéria em relação a versão 3.6, o programa NetCAT
tornou-se um sucesso rapidamente. Resultados da pesquisa de Aceitação
do Público podem agora ser <a
href="http://qa.netbeans.org/processes/cat/36/results/ca_results.html">vistas</a>.
Existem 86 % de participação de membros do NetCAT que decidiram votar
na pesquisa, e outro notável resultado foi o suporte a Refactoring ter
sido eleito como característica para a próxima versão. Ótimo
trabalho!

<p>Para entender onde o NetBeans está hoje e onde estará amanhã Vincent Brabant
entrevista Steve Wilson, Diretor da tecnologia NetBeans.<p>Como a futura versão NetBeans 4.0
começa a se materializar o Edge leva você para dentro dos horizontes
vislumbrados por nós: Refactoring, o novo projeto e outras características
planejadas para a versão 4.0. Se você deseja dar uma olhada antes de
seguir adiante, veja algumas de nossas <a
href="https://netbeans.org/about/press/awards.html">últimas
premiações</a>.</p>

<p>Nós temos uma grande edição para pormos em pática pela nossa
equipe de marketing más não hesite em <a href="mailto:info@netbeans.org">enviar
uma sugestão</a> ou <a href="mailto:nbmarketing@netbeans.org">se
envolver</a> em uma nova história.</p></font></td>
      <td><IMG SRC='/images_www/pixel.gif' WIDTH='12' HEIGHT='1' ALT=''></td>
      </tr>
      <tr class='tabler' bgcolor='#ffffff'><td colspan='4'>&nbsp;</td></tr>
      <tr class='tabler' bgcolor='#ffffff'>
      <TD  VALIGN='bottom' class='tabler' bgcolor='#ffffff'><IMG SRC='/images_www/pixel.gif' WIDTH='1' HEIGHT='1' ALT=''></TD>
      <td>&nbsp;</td>
      <td align='right'><font face='Verdana, sans-serif, helvetica, arial' >&nbsp;Robert Demmer</font></td>
      <TD  VALIGN='bottom' class='tabler' bgcolor='#ffffff'><IMG SRC='/images_www/pixel.gif' WIDTH='1' HEIGHT='1' ALT=''></TD>
      </tr>
      <tr class='tabler' bgcolor='#ffffff'>
      <TD  VALIGN='bottom' class='tabler' bgcolor='#ffffff'><IMG SRC='/images_www/marketing_newsletter/template/bottom-left.gif' WIDTH='12' HEIGHT='17' ALT=''></TD>
      <TD  colspan='2' VALIGN='bottom' class='tabler' bgcolor='#ffffff'><IMG SRC='/images_www/pixel.gif' WIDTH='1' HEIGHT='1' ALT=''></TD>
      <TD  aligm='right' VALIGN='bottom' class='tabler' bgcolor='#ffffff'><IMG SRC='/images_www/marketing_newsletter/template/bottom-right.gif' WIDTH='12' HEIGHT='17' ALT=''></TD>
      </tr>
      </table><img src='/images_www/pixel.gif' width='1' height='4' bolder='0'><table border='0' cellpadding='0' cellspacing='0' width='98%'>
      <tr class='tabler' bgcolor='#ffffff'>
      <TD  VALIGN='TOP' class='tabler' bgcolor='#ffffff'><IMG SRC='/images_www/marketing_newsletter/template/top-left.gif' WIDTH='12' HEIGHT='17' ALT=''></TD>
      <td>&nbsp;</td>
      <td align='right'>&nbsp;</td>
      <TD  VALIGN='TOP' class='tabler' align='right' bgcolor='#ffffff'><IMG SRC='/images_www/marketing_newsletter/template/top-right.gif' WIDTH='12' HEIGHT='17' ALT=''></TD>
      </tr>
      <tr class='tabler' bgcolor='#ffffff'>
      <td class='tabler' bgcolor='#ffffff'><IMG SRC='/images_www/pixel.gif' WIDTH='12' HEIGHT='1' ALT=''></td>
      <td colspan='2'><a name='s178'></a><font face='Verdana, sans-serif, helvetica, arial' color='#FF0F12' class='titlec'><b>Versão NetBeans IDE 3.6 & Recursos de Aprendizado</b></font><br>&nbsp;<br><font face='Verdana, sans-serif, helvetica, arial' >O
NetBeans 3.6, está agora disponível para imediato <a
href="http://services.netbeans.org/downloads/download.php?a=b&amp;p=1">download</a>.
A última versão melhora a capacidade de produtividade do código,
melhora no visual e provê aos desenvolvedores uma melhor integração
para construir aplicações para a web, ricas aplicações desktop e móveis.

<hr>
Recursos

<p><b>Ajuda Online NetBeans </b> - A documentação inclusa no próprio NetBeans IDE.
Pressione F1 para abrir a ajuda online.</p>

<p><a href="https://netbeans.org/community/releases/36/Whats_New.html">O que
há de novo no NetBeans 3.6</a> - Leia sobre as últimas e grandes características
esperando para serem habilitadas.<p><a
href="https://netbeans.org/community/releases/36/relnotes.html">Notas
da Versão</a> - Quer saber o que mudou desde a versão 3.5.1? Este é o
documento.<p><a href="https://netbeans.org/kb/archive/index.html">Guia
de Início Rápido NetBeans IDE 3.6</a> - Este documento leva-o através
do úso básico do NetBeans IDE 3.6 criando uma simples aplicação&nbsp;
Alô Mundo e foi desenhada para lhe levar a este mundo o mais rápido
possível.</p>

<p><a href="https://netbeans.org/kb/archive/index.html">Usando
o NetBeans IDE 3.6 com o JDK 1.5 (Tiger)</a> - Um rápido Howto para lhe iniciar
no uso do NetBeans 3.6 com o JDK 1.5.<p><a
href="https://netbeans.org/kb/archive/index.html">Usando
o NetBeans IDE 3.6</a> - Este guia é feito para lhe dar uma introdução
mais detalhada ao IDE do que a diponível no Giua de Início Rápido. Vários
aspectos da IDE são exploradas com detalhes.</p>

<p><a href="https://netbeans.org/kb/archive/index.html">Construção
de GUI no NetBeans IDE 3.6</a> - Este tutorial rápido guia você através
do processo de criação de uma aplicação chamada ColorSwitch (troca
de cores). Você irá construir uma aplicação simples que habilita você
a mudar a cor de um painel de cinza claro para cinza médio até preto.</p>

<p>Demo
- Álbum de Fotos NetBeans  - Ilustra algumas das funcionalidade do NetBeans
em relação a aplicações web, desktop e móveis. Um demo Flash é
mostrado no uso do NetBeans IDE 3.5.1 mas pode ser baixado completamente
o pacote incluindo: código fonte, script demo e instruções de instalação
para serem usados com o NetBeans 3.6.

<hr>Para mais suporte você pode <a
href="https://netbeans.org/community/lists/top.html">inscrever-se</a>
na lista de usuários <a href="mailto:nbusers@netbeans.org"> nbusers@netbeans.org</a>,
onde você pode encontrar amadores e experts dispostos a ajudarem em
seus questionamentos.</font></td>
      <td><IMG SRC='/images_www/pixel.gif' WIDTH='12' HEIGHT='1' ALT=''></td>
      </tr>
      <tr class='tabler' bgcolor='#ffffff'><td colspan='4'>&nbsp;</td></tr>
      <tr class='tabler' bgcolor='#ffffff'>
      <TD  VALIGN='bottom' class='tabler' bgcolor='#ffffff'><IMG SRC='/images_www/pixel.gif' WIDTH='1' HEIGHT='1' ALT=''></TD>
      <td><font face='Verdana, sans-serif, helvetica, arial' >[<a href='https://netbeans.org/kb/' target='new'>suporte e documentação</a>]</font>&nbsp;</td>
      <td align='right'><font face='Verdana, sans-serif, helvetica, arial' >&nbsp;</font></td>
      <TD  VALIGN='bottom' class='tabler' bgcolor='#ffffff'><IMG SRC='/images_www/pixel.gif' WIDTH='1' HEIGHT='1' ALT=''></TD>
      </tr>
      <tr class='tabler' bgcolor='#ffffff'>
      <TD  VALIGN='bottom' class='tabler' bgcolor='#ffffff'><IMG SRC='/images_www/marketing_newsletter/template/bottom-left.gif' WIDTH='12' HEIGHT='17' ALT=''></TD>
      <TD  colspan='2' VALIGN='bottom' class='tabler' bgcolor='#ffffff'><IMG SRC='/images_www/pixel.gif' WIDTH='1' HEIGHT='1' ALT=''></TD>
      <TD  aligm='right' VALIGN='bottom' class='tabler' bgcolor='#ffffff'><IMG SRC='/images_www/marketing_newsletter/template/bottom-right.gif' WIDTH='12' HEIGHT='17' ALT=''></TD>
      </tr>
      </table><img src='/images_www/pixel.gif' width='1' height='4' bolder='0'><table border='0' cellpadding='0' cellspacing='0' width='98%'>
      <tr class='tabler' bgcolor='#ffffff'>
      <TD  VALIGN='TOP' class='tabler' bgcolor='#ffffff'><IMG SRC='/images_www/marketing_newsletter/template/top-left.gif' WIDTH='12' HEIGHT='17' ALT=''></TD>
      <td>&nbsp;</td>
      <td align='right'>&nbsp;</td>
      <TD  VALIGN='TOP' class='tabler' align='right' bgcolor='#ffffff'><IMG SRC='/images_www/marketing_newsletter/template/top-right.gif' WIDTH='12' HEIGHT='17' ALT=''></TD>
      </tr>
      <tr class='tabler' bgcolor='#ffffff'>
      <td class='tabler' bgcolor='#ffffff'><IMG SRC='/images_www/pixel.gif' WIDTH='12' HEIGHT='1' ALT=''></td>
      <td colspan='2'><a name='s182'></a><font face='Verdana, sans-serif, helvetica, arial' color='#FF0F12' class='titlec'><b>Vesões Multilíngua e Pacotes</b></font><br>&nbsp;<br><font face='Verdana, sans-serif, helvetica, arial' >Agora
que a versão em Inglês da IDE foi lançada é hora de dar uma olhada a
diante para o que ainda vem sobre a versão 3.6.

<ul>
<li>22 de Abril: Pacote Java 2 Standard Edition / NetBeans IDE 3.6 em Inglês</li>
<li>12 de Maio: Versão Multilíngua NetBeans IDE 3.6 (Chinês &amp; Japonês)</li>
<li>12 de Maio: Pacote Sun Java System Application Server 8 Platform Edition / NetBeans IDE 3.6
em Inglês</li>
<li>18 de Maio: Pacote Java 2 Standard Edition / NetBeans IDE 3.6 Multilingual
(Chinês & Japonês)</li>
<li>9 de Junho: Pacote Sun Java System Application Server 8 Platform Edition / NetBeans IDE
Multilíngua (Chinês & Japonês)&nbsp;</li></ul>

Mais informações em <a href="http://java.sun.com/j2se/index.jsp">Java 2 Standard Edition</a>
ou <a href="http://wwws.sun.com/software/products/appsrvr_pe/index.html">Sun Java System
Application Server 8</a>,  Platform Edition.<p>Também
está trabalhando a comunidade na tradução do NetBeans IDE 3.6 em:
Alemão, Francês e Russo. Eles estão disponíveis atualmente apenas em
versões de desenvolvimento, mas é esperado que se tornem disponíveis
em Maio e Junho. Por favor, esteja ligado para mais detalhes.</p>

<p>Se você deseja contribuir no esforço de tradução vosote p sote <a
href="https://netbeans.org/community/contribute/localise.html">Início
Rápido na Localização</a>.</font></td>
      <td><IMG SRC='/images_www/pixel.gif' WIDTH='12' HEIGHT='1' ALT=''></td>
      </tr>
      <tr class='tabler' bgcolor='#ffffff'><td colspan='4'>&nbsp;</td></tr>
      <tr class='tabler' bgcolor='#ffffff'>
      <TD  VALIGN='bottom' class='tabler' bgcolor='#ffffff'><IMG SRC='/images_www/pixel.gif' WIDTH='1' HEIGHT='1' ALT=''></TD>
      <td>&nbsp;</td>
      <td align='right'><font face='Verdana, sans-serif, helvetica, arial' >&nbsp;</font></td>
      <TD  VALIGN='bottom' class='tabler' bgcolor='#ffffff'><IMG SRC='/images_www/pixel.gif' WIDTH='1' HEIGHT='1' ALT=''></TD>
      </tr>
      <tr class='tabler' bgcolor='#ffffff'>
      <TD  VALIGN='bottom' class='tabler' bgcolor='#ffffff'><IMG SRC='/images_www/marketing_newsletter/template/bottom-left.gif' WIDTH='12' HEIGHT='17' ALT=''></TD>
      <TD  colspan='2' VALIGN='bottom' class='tabler' bgcolor='#ffffff'><IMG SRC='/images_www/pixel.gif' WIDTH='1' HEIGHT='1' ALT=''></TD>
      <TD  aligm='right' VALIGN='bottom' class='tabler' bgcolor='#ffffff'><IMG SRC='/images_www/marketing_newsletter/template/bottom-right.gif' WIDTH='12' HEIGHT='17' ALT=''></TD>
      </tr>
      </table><img src='/images_www/pixel.gif' width='1' height='4' bolder='0'><table border='0' cellpadding='0' cellspacing='0' width='98%'>
      <tr class='tabler' bgcolor='#ffffff'>
      <TD  VALIGN='TOP' class='tabler' bgcolor='#ffffff'><IMG SRC='/images_www/marketing_newsletter/template/top-left.gif' WIDTH='12' HEIGHT='17' ALT=''></TD>
      <td>&nbsp;</td>
      <td align='right'>&nbsp;</td>
      <TD  VALIGN='TOP' class='tabler' align='right' bgcolor='#ffffff'><IMG SRC='/images_www/marketing_newsletter/template/top-right.gif' WIDTH='12' HEIGHT='17' ALT=''></TD>
      </tr>
      <tr class='tabler' bgcolor='#ffffff'>
      <td class='tabler' bgcolor='#ffffff'><IMG SRC='/images_www/pixel.gif' WIDTH='12' HEIGHT='1' ALT=''></td>
      <td colspan='2'><a name='s179'></a><font face='Verdana, sans-serif, helvetica, arial' color='#FF0F12' class='titlec'><b>Apresentando o NetBeans: Steve Wilson</b></font><br>&nbsp;<br><a href="" onClick='window.open("/images_www/marketing_newsletter/99_big.jpg", "", "width=820, height=820, toolbar=no, location=no, directories=no, status=no")'><img src='/images_www/marketing_newsletter/99.jpg' widht='100' height='150' border='0' alt='Steve Wilson - 5k' align='left' vspace='2' hspace='10'></a><font face='Verdana, sans-serif, helvetica, arial' >Em
uam entrevista exclusiva para o Edge, Vincent Brabant faz uma seção de
perguntas e respostas com Steve Wilson. Steve está atualmente incubido
de uma dupla tarefa, a de ser Diretor de Engenharia da Sun para o
Desenvolvimento do Núcleo da Plataforma (CDP) e Diretor de Tecnologia
da NetBeans.

<p>Veja aqui o que você pode esperar:
<hr>
<i>Vincent</i>: Fale-nos sobre a colaboração entre os times NetBeans.org, Sun Java Studio
Enterprise
e Sun Java Studio Creator?<p><i>Steve</i>: É um grande desafio ter
esses dois produtos comerciais no topo da produção do código base do
Netbeans, mas leva-nos a um NetBeans muito melhor. Esses times têm
demandas específicas em termos de funcionalidade para seus usuários e
tentamos prover isso em uma IDE básica. Ao mesmo tempo nós recebemos
sugestões, correções de bugsAt e até mesmo novas características
desses times que incorporamos ao fonte do open source.
<hr>

Outro tópico coberto na entrevista inclui: a lógica por trás da versão
NetBeans 3.6 antes da versão anteriormente planejada, a&nbsp; 4.0, o
que está sendo trabalhado para o NetBeans 4.0 (Refactoring, o novo
sistema de Projeto) e o que pode ser deixado para além do NetBeans 4.0.
Esta é uma entrevista que não pode ser esquecida.
</font></td>
      <td><IMG SRC='/images_www/pixel.gif' WIDTH='12' HEIGHT='1' ALT=''></td>
      </tr>
      <tr class='tabler' bgcolor='#ffffff'><td colspan='4'>&nbsp;</td></tr>
      <tr class='tabler' bgcolor='#ffffff'>
      <TD  VALIGN='bottom' class='tabler' bgcolor='#ffffff'><IMG SRC='/images_www/pixel.gif' WIDTH='1' HEIGHT='1' ALT=''></TD>
      <td><font face='Verdana, sans-serif, helvetica, arial' >[<a href='https://netbeans.org/community/articles/interviews/steve_wilson.html' target='new'>entrevista completa</a>]</font>&nbsp;</td>
      <td align='right'><font face='Verdana, sans-serif, helvetica, arial' >&nbsp;</font></td>
      <TD  VALIGN='bottom' class='tabler' bgcolor='#ffffff'><IMG SRC='/images_www/pixel.gif' WIDTH='1' HEIGHT='1' ALT=''></TD>
      </tr>
      <tr class='tabler' bgcolor='#ffffff'>
      <TD  VALIGN='bottom' class='tabler' bgcolor='#ffffff'><IMG SRC='/images_www/marketing_newsletter/template/bottom-left.gif' WIDTH='12' HEIGHT='17' ALT=''></TD>
      <TD  colspan='2' VALIGN='bottom' class='tabler' bgcolor='#ffffff'><IMG SRC='/images_www/pixel.gif' WIDTH='1' HEIGHT='1' ALT=''></TD>
      <TD  aligm='right' VALIGN='bottom' class='tabler' bgcolor='#ffffff'><IMG SRC='/images_www/marketing_newsletter/template/bottom-right.gif' WIDTH='12' HEIGHT='17' ALT=''></TD>
      </tr>
      </table><img src='/images_www/pixel.gif' width='1' height='4' bolder='0'><table border='0' cellpadding='0' cellspacing='0' width='98%'>
      <tr class='tabler' bgcolor='#ffffff'>
      <TD  VALIGN='TOP' class='tabler' bgcolor='#ffffff'><IMG SRC='/images_www/marketing_newsletter/template/top-left.gif' WIDTH='12' HEIGHT='17' ALT=''></TD>
      <td>&nbsp;</td>
      <td align='right'>&nbsp;</td>
      <TD  VALIGN='TOP' class='tabler' align='right' bgcolor='#ffffff'><IMG SRC='/images_www/marketing_newsletter/template/top-right.gif' WIDTH='12' HEIGHT='17' ALT=''></TD>
      </tr>
      <tr class='tabler' bgcolor='#ffffff'>
      <td class='tabler' bgcolor='#ffffff'><IMG SRC='/images_www/pixel.gif' WIDTH='12' HEIGHT='1' ALT=''></td>
      <td colspan='2'><a name='s184'></a><font face='Verdana, sans-serif, helvetica, arial' color='#FF0F12' class='titlec'><b>Pacote Java Studio Mobility para o NetBeans</b></font><br>&nbsp;<br><a href="" onClick='window.open("/images_www/marketing_newsletter/102_big.jpg", "", "width=820, height=820, toolbar=no, location=no, directories=no, status=no")'><img src='/images_www/marketing_newsletter/102.jpg' widht='100' height='267' border='0' alt='Mobile - 10k' align='left' vspace='2' hspace='10'></a><font face='Verdana, sans-serif, helvetica, arial' >O
módulo Java Studio Mobility foi lançado para o NetBeans IDE. Ele é
usado para o desenvolvimento de aplicaçõe sque podem ser distribuidas
em dispositivos móveis habilitados para o Java. Com características
otimizadas para Dispositivos de Perfil de Informações Móveis&nbsp;
(MIDP)/desenvolvimento em Configurações de Dispositivos Limitados(CLDC),
desenvolvedores de aplicações que usam a ecnologia J2ME irão se
beneficiar da capacidade de desenvolvimento rápido de aplicações J2ME MIDP.

<p>Os módulos estão agora disponíveis na Auto Atualização do NetBeans IDE 3.6
na pasta J2ME Wireless.</font></td>
      <td><IMG SRC='/images_www/pixel.gif' WIDTH='12' HEIGHT='1' ALT=''></td>
      </tr>
      <tr class='tabler' bgcolor='#ffffff'><td colspan='4'>&nbsp;</td></tr>
      <tr class='tabler' bgcolor='#ffffff'>
      <TD  VALIGN='bottom' class='tabler' bgcolor='#ffffff'><IMG SRC='/images_www/pixel.gif' WIDTH='1' HEIGHT='1' ALT=''></TD>
      <td><font face='Verdana, sans-serif, helvetica, arial' >[<a href='https://netbeans.org/community/releases/36/mobility_features.html' target='new'>características & benefícios</a>]</font>&nbsp;</td>
      <td align='right'><font face='Verdana, sans-serif, helvetica, arial' >&nbsp;</font></td>
      <TD  VALIGN='bottom' class='tabler' bgcolor='#ffffff'><IMG SRC='/images_www/pixel.gif' WIDTH='1' HEIGHT='1' ALT=''></TD>
      </tr>
      <tr class='tabler' bgcolor='#ffffff'>
      <TD  VALIGN='bottom' class='tabler' bgcolor='#ffffff'><IMG SRC='/images_www/marketing_newsletter/template/bottom-left.gif' WIDTH='12' HEIGHT='17' ALT=''></TD>
      <TD  colspan='2' VALIGN='bottom' class='tabler' bgcolor='#ffffff'><IMG SRC='/images_www/pixel.gif' WIDTH='1' HEIGHT='1' ALT=''></TD>
      <TD  aligm='right' VALIGN='bottom' class='tabler' bgcolor='#ffffff'><IMG SRC='/images_www/marketing_newsletter/template/bottom-right.gif' WIDTH='12' HEIGHT='17' ALT=''></TD>
      </tr>
      </table><img src='/images_www/pixel.gif' width='1' height='4' bolder='0'><table border='0' cellpadding='0' cellspacing='0' width='98%'>
      <tr class='tabler' bgcolor='#ffffff'>
      <TD  VALIGN='TOP' class='tabler' bgcolor='#ffffff'><IMG SRC='/images_www/marketing_newsletter/template/top-left.gif' WIDTH='12' HEIGHT='17' ALT=''></TD>
      <td>&nbsp;</td>
      <td align='right'>&nbsp;</td>
      <TD  VALIGN='TOP' class='tabler' align='right' bgcolor='#ffffff'><IMG SRC='/images_www/marketing_newsletter/template/top-right.gif' WIDTH='12' HEIGHT='17' ALT=''></TD>
      </tr>
      <tr class='tabler' bgcolor='#ffffff'>
      <td class='tabler' bgcolor='#ffffff'><IMG SRC='/images_www/pixel.gif' WIDTH='12' HEIGHT='1' ALT=''></td>
      <td colspan='2'><a name='s183'></a><font face='Verdana, sans-serif, helvetica, arial' color='#FF0F12' class='titlec'><b>Mudança no Centro de Atualizaçõe</b></font><br>&nbsp;<br><font face='Verdana, sans-serif, helvetica, arial' >Uma
conversa na lista aumasters@netbeans.org levou a um novo conceito que
está sendo implementado na versão NetBeans 3.6. Isto aponta para um
incremento de qualidade do NetBeans melhorando a estrutura do Centro de
Atualização e clareza de seu conteúdo.

<p>O plano é ter conco tipos de centros de atualização que seriam distintas
para cada versão (ex. Desenvolvimento para a 3.6 seria diferente da
Desenvolvimento para a 4.0):
<ul>
<li>Desenvolvimento: Apenas usada para a fase de desenvolvimento, não para o
usuário final. Usados para módulos que não fazem parte da distribuição
padrão, más para versões construidas diariamente</li>
<li>Beta: Usadas em finais de versão em qualidade de Beta EM Betas e Versões
Candidatas usadas para todos os módulos que não fazem parte da distribuição
padrão </li>
<li>Estável: Usada para módulos que atendem critérios de estáveis&nbsp;&nbsp;</li>
<li>De Terceiros: Usados para módulos que atendem critérios de estável das
versões dadas, providos por terceiros (ex. não netbeans.org)</li>
<li>CorreçõesQuentes: Usados para enviar pequenas correções que atendem ao
critério de qualidade da versão</li>
</ul>
Para mais informações dessas mudanças ou para promover um feedback
por favor veja a <a
href="https://netbeans.org/servlets/ReadMsg?msgId=722647&listName=nbusers">menságem
original</a> enviada por usuários Netbeans.</font></td>
      <td><IMG SRC='/images_www/pixel.gif' WIDTH='12' HEIGHT='1' ALT=''></td>
      </tr>
      <tr class='tabler' bgcolor='#ffffff'><td colspan='4'>&nbsp;</td></tr>
      <tr class='tabler' bgcolor='#ffffff'>
      <TD  VALIGN='bottom' class='tabler' bgcolor='#ffffff'><IMG SRC='/images_www/pixel.gif' WIDTH='1' HEIGHT='1' ALT=''></TD>
      <td>&nbsp;</td>
      <td align='right'><font face='Verdana, sans-serif, helvetica, arial' >&nbsp;</font></td>
      <TD  VALIGN='bottom' class='tabler' bgcolor='#ffffff'><IMG SRC='/images_www/pixel.gif' WIDTH='1' HEIGHT='1' ALT=''></TD>
      </tr>
      <tr class='tabler' bgcolor='#ffffff'>
      <TD  VALIGN='bottom' class='tabler' bgcolor='#ffffff'><IMG SRC='/images_www/marketing_newsletter/template/bottom-left.gif' WIDTH='12' HEIGHT='17' ALT=''></TD>
      <TD  colspan='2' VALIGN='bottom' class='tabler' bgcolor='#ffffff'><IMG SRC='/images_www/pixel.gif' WIDTH='1' HEIGHT='1' ALT=''></TD>
      <TD  aligm='right' VALIGN='bottom' class='tabler' bgcolor='#ffffff'><IMG SRC='/images_www/marketing_newsletter/template/bottom-right.gif' WIDTH='12' HEIGHT='17' ALT=''></TD>
      </tr>
      </table><img src='/images_www/pixel.gif' width='1' height='4' bolder='0'><table border='0' cellpadding='0' cellspacing='0' width='98%'>
      <tr class='tabler' bgcolor='#ffffff'>
      <TD  VALIGN='TOP' class='tabler' bgcolor='#ffffff'><IMG SRC='/images_www/marketing_newsletter/template/top-left.gif' WIDTH='12' HEIGHT='17' ALT=''></TD>
      <td>&nbsp;</td>
      <td align='right'>&nbsp;</td>
      <TD  VALIGN='TOP' class='tabler' align='right' bgcolor='#ffffff'><IMG SRC='/images_www/marketing_newsletter/template/top-right.gif' WIDTH='12' HEIGHT='17' ALT=''></TD>
      </tr>
      <tr class='tabler' bgcolor='#ffffff'>
      <td class='tabler' bgcolor='#ffffff'><IMG SRC='/images_www/pixel.gif' WIDTH='12' HEIGHT='1' ALT=''></td>
      <td colspan='2'><a name='s185'></a><font face='Verdana, sans-serif, helvetica, arial' color='#FF0F12' class='titlec'><b>Atividades de Atualização no NetBeans 4.0</b></font><br>&nbsp;<br><a href="" onClick='window.open("/images_www/marketing_newsletter/98_big.png", "", "width=820, height=820, toolbar=no, location=no, directories=no, status=no")'><img src='/images_www/marketing_newsletter/98.png' widht='150' height='105' border='0' alt='Refactoring 4.0 - 14k' align='left' vspace='2' hspace='10'></a><font face='Verdana, sans-serif, helvetica, arial' >Preview
Alfa do Refactoring no NetBeans 4.0</b>
<p>No caso de você ter perdido o preview do Refactoring Alpha para o NetBeans 4.0
agora ele está disponível no NetBeans.org! Você pode baixar agora e
usar com as características como Renomear Pacote/Classe/Método/Campo,
Mudar Parâmetros de Métodos ou campo Encapsulado.</p>

<p>Se você quiser unir-se à comunidade de desenvolvedores em relação
a Refactoring, por favor inscreva-se à lista de desenvolvedores (dev@refactoring.netbeans.org)
na <a href="https://netbeans.org/projects/refactoring/lists">página
da lista</a> de e-mail e envie seus comentários sobre esta versão alfa
para dev@refactoring.netbeans.org.</p>

<p>Para mais informações sobre Refactoring no NetBeans 4.0 incluindo o
preview do alpha, características planejadas e mapa do caminho por
favor visite<ul><li><a
href="http://refactoring.netbeans.org">http://refactoring.netbeans.org</a></li></ul>

<p><b>Novo Sistema de Projetos baseados no Apache Ant</b></p>

<p>Um sistema de projeto completamente novo baseado em Apache Ant, um
ferramenta open source aprovada de fato para o desenvolvimento de aplicações
usando tecnologia java. Este novo sistema terá uma arquitetura aberta,
que módulos de terceiros podem suportar correntes e futuros tipos de
aplicações Java. O NetBeans incluirá tipos de projetos para desktop J2SE
e aplicações de duas camadas para web (JSPs, servlets, bibliotecas tag).
Os usuários não terão que ter medo de estarem presos denro de um
sistema de projeto proprietário.<ul>
<li><a
href="http://projects.netbeans.org/buildsys/projects_quickstart.html">http://projects.netbeans.org</a></li></ul>

* A integração da característica de de Refactoring com o novo Sistema de
Projetos e seu elo está programado para o final de Abril. É também
desejado a publicação da API do Refactoring, então você pode
escrever e contribuir dizendo qual sua caraterística favorita
encontrada no Refactoring.</font></td>
      <td><IMG SRC='/images_www/pixel.gif' WIDTH='12' HEIGHT='1' ALT=''></td>
      </tr>
      <tr class='tabler' bgcolor='#ffffff'><td colspan='4'>&nbsp;</td></tr>
      <tr class='tabler' bgcolor='#ffffff'>
      <TD  VALIGN='bottom' class='tabler' bgcolor='#ffffff'><IMG SRC='/images_www/pixel.gif' WIDTH='1' HEIGHT='1' ALT=''></TD>
      <td><font face='Verdana, sans-serif, helvetica, arial' >[<a href='https://netbeans.org/community/releases/40/nb40_features.html' target='new'>Planos para a Versão NetBeans 4.0</a>]</font>&nbsp;</td>
      <td align='right'><font face='Verdana, sans-serif, helvetica, arial' >&nbsp;</font></td>
      <TD  VALIGN='bottom' class='tabler' bgcolor='#ffffff'><IMG SRC='/images_www/pixel.gif' WIDTH='1' HEIGHT='1' ALT=''></TD>
      </tr>
      <tr class='tabler' bgcolor='#ffffff'>
      <TD  VALIGN='bottom' class='tabler' bgcolor='#ffffff'><IMG SRC='/images_www/marketing_newsletter/template/bottom-left.gif' WIDTH='12' HEIGHT='17' ALT=''></TD>
      <TD  colspan='2' VALIGN='bottom' class='tabler' bgcolor='#ffffff'><IMG SRC='/images_www/pixel.gif' WIDTH='1' HEIGHT='1' ALT=''></TD>
      <TD  aligm='right' VALIGN='bottom' class='tabler' bgcolor='#ffffff'><IMG SRC='/images_www/marketing_newsletter/template/bottom-right.gif' WIDTH='12' HEIGHT='17' ALT=''></TD>
      </tr>
      </table><img src='/images_www/pixel.gif' width='1' height='4' bolder='0'><table border='0' cellpadding='0' cellspacing='0' width='98%'>
      <tr class='tabler' bgcolor='#ffffff'>
      <TD  VALIGN='TOP' class='tabler' bgcolor='#ffffff'><IMG SRC='/images_www/marketing_newsletter/template/top-left.gif' WIDTH='12' HEIGHT='17' ALT=''></TD>
      <td>&nbsp;</td>
      <td align='right'>&nbsp;</td>
      <TD  VALIGN='TOP' class='tabler' align='right' bgcolor='#ffffff'><IMG SRC='/images_www/marketing_newsletter/template/top-right.gif' WIDTH='12' HEIGHT='17' ALT=''></TD>
      </tr>
      <tr class='tabler' bgcolor='#ffffff'>
      <td class='tabler' bgcolor='#ffffff'><IMG SRC='/images_www/pixel.gif' WIDTH='12' HEIGHT='1' ALT=''></td>
      <td colspan='2'><a name='s180'></a><font face='Verdana, sans-serif, helvetica, arial' color='#FF0F12' class='titlec'><b>Você sabia...</b></font><br>&nbsp;<br><font face='Verdana, sans-serif, helvetica, arial' ><b>existe
uma nova forma de registrar um drive JDBC no NB 3.6?</b><br>
Agora é possível carregar o driver de qualquer local,&nbsp; não é
necessário colocá-lo no diretório /lib/ext mais. Você apenas precisa
registrar o driver dentro da IDE. Para fazer isto clique com o botão
direito no nó Drivers e escolha e escolha Add driver. Especifique a
informação requerida e seu driver irá aparecer sob o nó de drivers.</font>

<p><font face='Verdana, sans-serif, helvetica, arial' >Para mais informações,
veja a ajuda do Database Explorer no IDE ou <a
href="http://db.netbeans.org/uispecs/db_jdbc_driver_manager.html">olhe
aqui</a>.

<p>Dica dada por: Radko . Najman @ Sun . com

<p><b>você pode pedir ao debugador para parar em excessões?</b><br>
Vá a janela de breakpoints, clique com o botão direito, New Breakpoint, no dropdown
a direita escolha Exception, mude a opção abaixo para thrown or caught, e
pegue sua excessão. Se você quiser tudo escolha "Throwable".

<p>Dica dada por: Torbjorn . Norbye @ Sun . COM

<p><b>lá existe uma lista de usuários NetBeans em Chinês, Francês, Japonês
e Russo ? <a href="https://netbeans.org/community/lists/top.html">Inscreva-se
aqui!</a></b></font></td>
      <td><IMG SRC='/images_www/pixel.gif' WIDTH='12' HEIGHT='1' ALT=''></td>
      </tr>
      <tr class='tabler' bgcolor='#ffffff'><td colspan='4'>&nbsp;</td></tr>
      <tr class='tabler' bgcolor='#ffffff'>
      <TD  VALIGN='bottom' class='tabler' bgcolor='#ffffff'><IMG SRC='/images_www/pixel.gif' WIDTH='1' HEIGHT='1' ALT=''></TD>
      <td>&nbsp;</td>
      <td align='right'><font face='Verdana, sans-serif, helvetica, arial' >&nbsp;Vincent Brabant</font></td>
      <TD  VALIGN='bottom' class='tabler' bgcolor='#ffffff'><IMG SRC='/images_www/pixel.gif' WIDTH='1' HEIGHT='1' ALT=''></TD>
      </tr>
      <tr class='tabler' bgcolor='#ffffff'>
      <TD  VALIGN='bottom' class='tabler' bgcolor='#ffffff'><IMG SRC='/images_www/marketing_newsletter/template/bottom-left.gif' WIDTH='12' HEIGHT='17' ALT=''></TD>
      <TD  colspan='2' VALIGN='bottom' class='tabler' bgcolor='#ffffff'><IMG SRC='/images_www/pixel.gif' WIDTH='1' HEIGHT='1' ALT=''></TD>
      <TD  aligm='right' VALIGN='bottom' class='tabler' bgcolor='#ffffff'><IMG SRC='/images_www/marketing_newsletter/template/bottom-right.gif' WIDTH='12' HEIGHT='17' ALT=''></TD>
      </tr>
      </table><img src='/images_www/pixel.gif' width='1' height='4' bolder='0'></td>
  </tr>
  </table>
	</td>
	<TD width="1" bgcolor="#205481"><IMG SRG="/images_www/pixel.gif" width="1" height="850" src="/images_www/pixel.gif" border="0" alt=""></TD>
</tr>
<tr>
<td height='5' bgcolor="#205481"><img src='/images_www/marketing_newsletter/template/sprout_b_l.gif' width='5' height='5' border='0' alt='-'></td>
<td colspan='2' height='5' align='right' background='/images_www/marketing_newsletter/template/sprout_b_c.gif'><img src='/images_www/marketing_newsletter/template/sprout_b_r.gif' width='5' height='5' border='0' alt='-'></td>
</tr>

</table>
</center>
</BODY>
</HTML>
