<HTML>
<HEAD>

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

<title>NetBeans Edge - Número 22 - Abril 2004</title>
<meta NAME="description" CONTENT="The NetBeans Edge monthly newsletter, Número 22, 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 19-May 17:03 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='https://netbeans.org/catalogue' 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'> Catálogo de módulos free e comercial 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'> Central da Comunidade Java onde o NetBeans é um membro federado<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'>Novo! NetBeans IDE 3.6</font></a>
<font face='Verdana, sans-serif, helvetica, arial' color='#FFFFFF' size='1'> Disponível para 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'>Portal Sun Java Studio</font></a>
<font face='Verdana, sans-serif, helvetica, arial' color='#FFFFFF' size='1'> Recursos relacionados do NetBeans<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-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_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-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>Número 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, Edição 22</b></font><br>&nbsp;<br><font face='Verdana, sans-serif, helvetica, arial' >Envolva-se!

<p>Por Steve Wilson, Diretor de Engenharia, Sun Microsystems
<p>
A comunidade Netbeans está crescendo e saltando além dos limites. Nos últimos seis meses,
o número de inscrições nas nossas listas de discussão tem crescido entre 5.000 até
40.000! Com estes novos membros da comunidade eu acho será um trabalho falar sobre
todas as formas em que você pode se envolver melhor com o que esta acontecendo.
Existem enúmeras formas em que você pode se envolver hoje e estamos trabalhando em
muitas outras formas, não importa o nível de tempo que você têm para prover.
<p>
Use o IDE e Diga a um Amigo <br/>
Nosso objetivo é ter quantas maneiras possíveis forem necessárias, usando a
tecnologia para produzí-la no Netbeans.org. A maneira mais básica em que você pode fazer
parte e deixar as pessoas sabendo que você gosta da tecnologia.
<p>
Discuta o Futuro! <br/>
A maioria das pessoas nas nossas listas de discussão estão inscritas na lista
"announce"(anúncios) -- que é apenas uma maneira de comunicação de uma via. Entretanto,
existem numerosas listas onde usuários e desenvolvedores discutem uma gama enorme de tópicos.
Para uma lista de algumas das listas mais interessantes você pode ir em:
<p>
<a
href="https://netbeans.org/community/lists/top.html">https://netbeans.org/community/lists/top.html</a>
<p>
A lista "nbdiscuss" é um ótimo lugar para fazer sua voz ser ouvida em coisas que você gostaria
que acontecesse com esta comunidade a diante. Discussões no "nbdiscuss" e "nbdev" têm tido
um grande impacto no desenho do NetBeans 4.0, como o novo sistema de construção. Faza a sua
voz ser ouvida.
<p>
Mergulhe bem!<br/>
Se você está usando o NetBeans então você é um desenvolvedor Java. A IDE é desenhada para
ser modular, então pessoas podem adicionar características e funcionalidades sem mecher no
núcleo da IDE. Recentemente o time que desenvolve suporte a Aplicações Web solicitaram por
ajuda para implementar uma função para testar e compilar páginas JSP. O desenvolvedor
Illya Kysil ofereceu-se para construir uma versão inicial deste módulo para que usuários
possam testar. Obrigado Illya!
<p>
O que vem a seguir? <br/>
Nos próximos meses estaremos levantando mais e melhores formas de nos tornar envolvidos.
Nós queremos fazer isto ficar fácil para você contribuir e então todos termos uma experiência
melhor. Se você tem sugestões sobre como podemos melhorar, então porquê não nos envia
uma mensagem para a lista nbdiscuss e deixe nós conhecermos sua idéia.</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: Ezequias Rodrigues da Rocha</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>NetBenas One</b></font><br>&nbsp;<br><font face='Verdana, sans-serif, helvetica, arial' >A primeira conferencia NetBeans One estará acontecendo no JavaOne.
<p>
Na terça, 29 de Junho de 2004, estaremos em companhia do evento Java One,
que exibirá os Projetos do NetBeans, incluindo um preview da última versão
dentro da tecnologia NetBeans e mostrará também os Parceiros Chave do NetBeans.
<p>
O keynote trará James Gosling falando sobre Ferramentas e o futuro. Se você têm
visto James falando, saberá que haverá grandes surpresas. Essa não dá pra perder!
<p>
Para os inscritos no JavaOne, a entrada no NetBeans One é grátis. Para os não
inscritos no JavaOne, a entrada no NetBeans One ainda é grátis, más eles estão
dando bonus no Passe Pavilion JavaOne com um disconto de $200 caso se registrem
no evento JavaOne todo.
<p>
Esta é um grande momento para ouvir os técnicos da Sun que gerenciam o projeto
NetBeans, para aprender sobre a tecnologia e o caminho da estrada. Adicionalmente
mostraremos os parceiros do NetBeans, que ajudam a torná-lo um sistema tão próspero.
Encontre seu colega entusiasmado pelo NetBeans e aprenda um pouco de suas dicas
incomensuráveis.
<p>
Estaremos convenientemente localizados no Yerba Buena Theater que é adjacente a
entrada do Moscone Convention Centers. A agenda proposta dos eventos:
<p>
<table cellpadding="2" cellspacing="2">

<tr class="tablerbg">
<td class="smalltext"><B>Tempo</b></td>
<td class="smalltext"><B>Titulo</b></td>
<td class="smalltext"><B>Oradores</b></td>
</tr>

<tr class="tablersh">
<td class="smalltext">9:00 AM</td>
<td class="smalltext">Inscrição</td>
<td class="smalltext"> </td>

<tr>
<td class="smalltext">10:00 AM</td>
<td class="smalltext">Keynote: O Futuro das Ferramentas de Desenvolvimento Open Source</td>
<td class="smalltext">James Gosling, Steve Wilson</td>
</tr>

<tr class="tablersh">
<td class="smalltext">11:00 AM</td>
<td class="smalltext">Avanços na Tecnologia NetBeans</td>
<td class="smalltext">Ian Formanek, Tim Boudreau, Jesse Glick</td>
</tr>

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

<tr class="tablersh">
<td class="smalltext">1:00 PM</td>
<td class="smalltext">Soluções NetBeans I</td>
<td class="smalltext">Moderador + Parceiros</td>
</tr>

<tr>
<td class="smalltext">2:00 PM</td>
<td class="smalltext">Construindo Aplicações Web com o 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">Soluções NetBeans II</td>
<td class="smalltext">Moderador + Parceiros</td>
</tr>

<tr>
<td class="smalltext">4:00 PM</td>
<td class="smalltext">Construindo uma Aplicação Móvel com o NetBeans</td>
<td class="smalltext">Martin Ryzl</td>
</tr>

<tr class="tablersh">
<td class="smalltext">5:00 PM</td>
<td class="smalltext">BOF: Comunidade de Desenvolvimento NetBeans e Márketing</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">Evento de Ferramentas da Sun </td>
<td class="smalltext">Lembranças, prêmios, demonstrações e mais</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>Pacote Multilingual NetBeans 3.6</b></font><br>&nbsp;<br><font face='Verdana, sans-serif, helvetica, arial' >Versão Chinesa e Japonesa do NetBeans 3.6 esta agora <a
href="http://services.netbeans.org/downloads/download.php?a=b&amp;p=1">disponível
para download imediato</a>.

<p>Os documentos a seguir foram traduzidos para o Chinês e Japonês para
ajudá-lo a se iniciar:

<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>Você pode também <a
href="mailto:nbdiscuss_zh-subscribe@netbeans.org">subscribe</a> para a lista
de discussão chinesa: 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>Catálogo de Módulos</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> disponibilisou nbxsl
v1.0 que é um novo módulo para editar XSLT com visualização de resultados rapidos e
avaliação de XPath. Siga <a
href="http://plugins.netbeans.org/">aqui</a> para mais informações
incluindo um link para avaliação grátis.</p>

<b>RefactorIt</b>
<p>Em outra novidade o módulo RefactorIT 2.0 RC2 (build 1.9.15) está disponível. O 2.0
RC2 agora trabalha bem com o NetBeans IDE 3.6. Aqui o que há de novoH:
<ul><li>Para todas as novas Métricas de Qualidade: DIP, DCYC, EP, LSP (visto que, cada simples
Metrica tem um intervalo recomendado e violações sao coloridas apropriadamente na tabela de
resultados)</li>
<li>A opção "Freeze" foi adicionada para Desenhar Dependências</li>
<li>muitos bugs foram corrigidos e melhoramentos de usabilidade</li></ul>

Para mais informações em RefactorIT 2.0 RC2 por favor visite nossas <a
href="https://netbeans.org/community/news/index.html#448">notícias</a> em
NetBeans.org ou <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'>catálogo de módulos
mucho</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>Novos Artigos</b></font><br>&nbsp;<br><font face='Verdana, sans-serif, helvetica, arial' >O <a href="https://netbeans.org/kb/archive/index.html"> Tutotial Midnight Cookie
Web Apps</a> ilustra o uso do servidor Front Controller e uma visão composta dentro de
uma página criada com a tecnologia JavaServer Pages (JSP). As páginas JSP na aplicação
usam o Padrão de Biblioteca de Tags JavaServer Pages (JSTL). Para o tutorial você pode
usar o NetBeans IDE 3.5 or 3.6 e o J2SE 1.3 or 1.4.

<p>Construindo
Web Modules com o NetBeans: Transição do 3.5 para 3.6 - Este artigo discussa sobre
as novas características no NetBeans 3.6 para contruir web modules. Ele fala das mudanças
das características já existentes que podem afetar a maneira como você trabalha. Por ultimo,
lista os bugs conhecidos e dá algumas dicas.</p>

<p><a href="https://netbeans.org/kb/archive/index.html">Guia de Início Rápido em
Web Module</a> - Este documento leva você através do desenvolvimeto, testes e debugs básicos
de um web module criando uma aplicação simples de cara e coroa. Este documento é
feito para lhe levar o mais rápido possivel ao mundo dos Web Mudules.</p>

<p><a
href="https://netbeans.org/community/releases/36/J2ME_Support.html">Adicionando o Suporte
a Plataforma J2ME ao NetBeans IDE</a> - Atualizado o NetBeans IDE com os módulos de mobilidade
para NetBeans integra o suporte ao desenvolvimento e aplicações testes para dispositivos
móveis que usam a plataforma Java 2, Micro Edition (J2ME).

<p><a href="https://netbeans.org/kb/articles/j2me_tutorial.html">Tutorial de Módulos
de Mobilidade</a> - Este tutorial lhe guia através do processo de criação e debug de uma
aplicação MIDP/CLDC ou "MIDLet," usando os Módulos de Mobilidade e o 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'>mais artigos</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>
