
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
<head>
<title>NetBeans Weekly Newsletter, Issue # 8</title>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8" >
<meta name="keywords" content="NetBeans, IDE, Platform, free, open source, developer" >
</head>
<body>
<style>
body {
		margin:5px 15px 5px 15px;
		font-size: 11px;
		font-family: Verdana, "Verdana CE",  Arial, "Arial CE", "Lucida Grande CE", lucida, "Helvetica CE", sans-serif;
		background-color:#e3eaf1;
		text-align:center;
}
				
#letter {width:533px;margin-left:auto;margin-right:auto;}
#head {background-image:url("http://services.netbeans.org/appl2/shared_images/head.png");width:533px;height:70px;background-repeat:none;}
#issue-date {padding-top:50px;text-align:center; color:white;}
#footer {background-image:url("http://services.netbeans.org/appl2/shared_images/footer.png"); width:533px;height:28px;background-repeat:none;}
#footer-text {padding-top:5px;color:#6a6b6d;text-align:center;}
#content {border-right:3px solid #747d9e;border-left:3px solid #747d9e; background-color:white; text-align:left; color:#6a6b6d; padding:13px 20px 13px 13px; }
#letter h1 {font-size: 14px; font-weight:normal; margin:3px 0px 5px 0px; padding:0px;color: #EE6B00; border-bottom:1px solid silver;}
#letter h2 {color:#2C3C79;font-size: 13px; font-weight:normal;margin:0px 0px 2px 0px;padding:0px; border:0px;}
#letter p {padding: 0px;margin:0px; text-align:justify;}
#letter a:link, a:visited { color: #045491; font-weight : normal; text-decoration: none;}
#letter a:link:hover, a:visited:hover  { color: #045491; font-normal : bold; text-decoration : underline;}
.item {margin-left:8px; margin-bottom:9px;}
.bold {font-weight:bold;}
#letter a.orange {color: #EE6B00;}
.align-right {text-align:right;}     
.align-center {text-align:center;}  
.edited {margin:15px -20px 0px -13px;padding-top:8px;text-align:center;}
.edge-top {background-color: #f0f7ff;padding:7px 12px 7px 7px;margin-bottom:10px; border:1px solid #747d9e;}
</style>

				
<div id="letter">
	<div id="head">
		<div id="issue-date" class="bold">
				Edição # 8 - Apr 24, 2008
		</div>
	</div>
	<div id="content">
	
				<h1>Agenda</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=1830">Faltam duas semanas para o NetBeans Day no Community One! Entrada de estudantes no JavaOne é grátis!</a></h2>
						<p style="margin-left:8px;"><img src='http://services.netbeans.org/appl2/show_image.php?id=995&column=image&table=story&type=image/jpeg&db=xnetbeans&db_type=pear&id_col=story_id' 
		height='73' width='110' alt='image' style='float:left; margin-right:5px;margin-bottom:5px;'/>
						O NetBeans Day no CommunitOne está chegando! Registre a sua vaga agora mesmo no Moscone Center, 5 de maio, e você estará garantindo: excitantes demonstrações do NetBeans IDE 6.1, cara a cara com o time de evangelhistas do NetBeans e do Java Posse, chances de ganhar brindes legais e muito mais! E nós temos uma grande notícia para os estudantes - A entrada no CommunityOne e JavaOne é GRÁTIS! Veja detalhes do cadastro <a href="http://developers.sun.com/events/studentprogram/">aqui</a>.</p><br style="clear:both;"/>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=1839">Café da manhã do JavaOne 2008 com Software FX - 7 de Maio</a></h2>
						<p style="margin-left:8px;">
						O Software FX, uma companhia parceira do NetBeans, está oferecendo um seminário e café da manhã GRÁTIS no JavaOne na quarta, 7 de maio. Junte-se a Software FX e aos especialistas do NetBeans no JW Marriott San Francisco para uma apresentação de Creating Advanced Charts with NetBeans and Chart FX. O espaço é limitado, portanto, registre-se logo.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=1840">Sessões no JavaOne Imperdíveis - Java EE, Aplicações Web, Serviços Web</a></h2>
						<p style="margin-left:8px;">
						Aprenda mais sobre o NetBeans no JavaOne assistindo às sessões que demonstram as características do IDE! E ainda melhor, nós estamos colocando essas sessões em uma lista de mão para você. Na semana passada, nós destacamos conversas sobre <a href="https://netbeans.org/servlets/NewsItemView?newsItemID=1221">Scripting e desenvolvimento Java Móvel</a>. Esta semana, nosso foco está em sessões para Java EE, Aplicações Web e Serviços Web. Marque isto no seu calendário de conferências e garanta seu lugar.</p>
					</div>
				<h1>Novidades do projeto</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=1838">Participe do NetBeans Quiz e ganhe incríveis prêmios toda semana!</a></h2>
						<p style="margin-left:8px;"><img src='http://services.netbeans.org/appl2/show_image.php?id=998&column=image&table=story&type=image/jpeg&db=xnetbeans&db_type=pear&id_col=story_id' 
		height='91' width='110' alt='image' style='float:left; margin-right:5px;margin-bottom:5px;'/>
						Toda semana, de 14 de abril a 23 de junho, participe de nosso novo NetBeans Quiz para ter uma chance de ganhar prêmios legais como um Apple Ipod Touch, um Nintendo Wii, um celular Nokia E 61i e mais! Isto envolve três passos fáceis:
<ul>
    <il>Baixe o NetBeans IDE.</il>
    <il>Instale o plugin quiz da Central de Atualizações do NetBeans.</il>
    <il>Responda as questões e ganhe um prêmio toda semana! </il>
</ul>

No final da campanha, um participante sortudo do Quiz irá ganhar o grande prêmio—um Apple MacBook Air! <b>NOTA: Campanha aberta somente para os residentes na Índia.</b></p><br style="clear:both;"/>
					</div>
				<h1>Comunidade</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=1836">1a. competição anual "Irei codificar por comida"</a></h2>
						<p style="margin-left:8px;"><img src='http://services.netbeans.org/appl2/show_image.php?id=1000&column=image&table=story&type=image/jpeg&db=xnetbeans&db_type=pear&id_col=story_id' 
		height='93' width='109' alt='image' style='float:left; margin-right:5px;margin-bottom:5px;'/>
						Quer ganhar um livro que está chegando sobre o desenho da API, de Jaroslav Tulach, um dos engenheiros fundadores do NetBeans? Então esta original e fácil competição pode lhe interessar. Tire uma foto de você mesmo segurando um cartaz "Will Code for Food" e envie-o a geertjan PONTO wielenga ARROBA sun PONTO com. Leia a história completa no blog do Geertjan.</p><br style="clear:both;"/>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=1837">Comunidade NetBeans aprova v6.1!</a></h2>
						<p style="margin-left:8px;"><img src='http://services.netbeans.org/appl2/show_image.php?id=999&column=image&table=story&type=image/jpeg&db=xnetbeans&db_type=pear&id_col=story_id' 
		height='90' width='110' alt='image' style='float:left; margin-right:5px;margin-bottom:5px;'/>
						Os resultados da Pesquisa de Aceitação da Comunidade para o NetBeans 6.1 estão aqui: 91% de vocês concordam que o NetBeans 6.1 está estável o suficiente para movê-lo ao FCS! (Uns poucos participantes pontuaram correções que devemos fazer, e nós estamos trabalhando para fazer as mudanças dentro do NetBeans Update Center.) Obrigado pelo grande retorno e esteja sintonizado para o lançamento oficial do 6.1!</p><br style="clear:both;"/>
					</div>
				<h1>Treinamento</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=1833">Colocando projetos NetBeans no CVS</a></h2>
						<p style="margin-left:8px;">
						Coloque seus projetos NetBeans em um CVS para tornar os códigos-fonte disponíveis para muitos desenvolvedores. Embora esta dica seja direcionada a projetos em SOA centralizados em aplicações compostas JBI e unidades de serviços, a maioria dos projetos NetBeans pode tirar vantagens desta funcionalidade. Também está disponível informação sobre como fazer o mesmo com o Subversion.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=1834">Escreva um cliente SOAP para o Open Calais</a></h2>
						<p style="margin-left:8px;">
						Aprenda a escrever um cliente SOAP Java simples, baseado em linha de comando, para acessar o serviço web Open Calais. O conceito apresentado neste tutorial, contribuição de Amit Kumar Saha à comunidade, é útil também quando você escrever um cliente SOAP para qualquer outro serviço web.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=1835">Novos exemplos de mobilidade na Central de Atualizações do NetBeans!</a></h2>
						<p style="margin-left:8px;">
						Está curioso sobre como funciona o desenvolvimento de uma aplicação móvel, mas não tem idéia por onde começar? Deixe o portal NetBeans Sample Applications inspirar você com um novo grupo de aplicações de exemplo para projetos de mobilidade. Enriqueça sua UI com SVG, navegue por um álbum de fotos móvel, crie um jogo, ou leia seu blog favorito usando o conjunto de exemplos Ajax móvel.</p>
					</div>
				<h1>Blogs</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=1831">Java e NetBeans no Ubuntu 8.04</a></h2>
						<p style="margin-left:8px;">
						Java e NetBeans no Ubuntu normalmente é um processo complicado, mas depois da bem recente experiência de Roman Strobl, ambos os pacotes estão bem integrados agora e facilmente acessíveis.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=1832">Auto-Validação com Rails</a></h2>
						<p style="margin-left:8px;">
						Uma pergunta comum que Brian Leonard recebe depois de suas palestras é como validar contra um banco de dados. Neste artigo, Brian faz exatamente isto, mas com um bônus adicional de incorporar Ajax para evitar a apresentação da página.</p>
					</div>
	<div class="edited">
	Esta edição foi enviada para você por: Jefferson Prestes<br/>Se você não deseja receber este boletim, <a href="https://netbeans.org/community/lists/top.html">remova sua inscrição aqui</a>
	</div>
	<div class="edited">
        Available languages<br>
        <a href="https://netbeans.org/community/news/newsletter/index.html">English</a> | <a href="https://netbeans.org/community/news/newsletter/index_pt_BR.html">Brazilian Portuguese</a> | <a href="https://netbeans.org/community/news/newsletter/index_zh_CN.html">Chinese - simplified</a>
        </div>
	</div>
	<div id="footer">
		<div id="footer-text">
				Este boletim também é acessível em   <a href="https://netbeans.org/community/news/newsletter/2008-04-24_pt_BR.html">www.netbeans.org</a>, 
				<a href="https://netbeans.org/community/news/newsletter/archive_pt_BR.html">arquivo de boletins</a>
		</div>
	</div>

</body>
</html>