
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
<head>
<title>NetBeans Weekly Newsletter, Issue # 11</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 # 11 - May 15, 2008
		</div>
	</div>
	<div id="content">
	
				<h1>Agenda</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=1962">Pergunte aos especialistas: Suporte JRuby no NetBeans IDE 6.x</a></h2>
						<p style="margin-left:8px;">
						Você tem uma pergunta sobre o suporte ao JRuby no NetBeans IDE 6? Coloque na página "Ask the Experts" (Pergunte aos Especialistas) durante a semana de 19 de maio e receba as respostas de três especialistas: Tor Norbye, Charles Oliver Nutter, e Brian Leonard.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=1961">JUG: Pragmatic Java EE 5 Hacking</a></h2>
						<p style="margin-left:8px;">
						Junte-se a Adam Bien em Hamburgo, Alemanha, no dia 19 de maio para o "Pragmatic Java EE 5 Hacking - Repensando as melhores práticas". Depois de uma curta introdução ao Java EE 5 / Java EE 6, o membro do Dream Team do NetBeans Adam Bien, falará sobre os conceitos, padrões, melhores práticas e muito mais sobre Java EE 5/6. A sessão será interativa.</p>
					</div>
				<h1>Novidades do projeto</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=1957">Ganhadores do concurso de Blog</a></h2>
						<p style="margin-left:8px;"><img src='http://services.netbeans.org/appl2/show_image.php?id=1107&column=image&table=story&type=image/pjpeg&db=xnetbeans&db_type=pear&id_col=story_id' 
		height='61' width='110' alt='image' style='float:left; margin-right:5px;margin-bottom:5px;'/>
						Gostaríamos de agradecer a todos que participaram do Concurso de Blogs do NetBeans! Tivemos aproximadamente 300 artigos enviados. Os 10 mais receberão $500 dólares em forma de "vale-presente" do American Express. Os 100 melhores receberão uma camiseta do NetBeans. Todos os ganhadores serão contactados por e-mail nas próximas duas semanas (23 de maio) para confirmar o endereço de entrega. Então, quem ganhou? <a href="http://services.netbeans.org/newsletter/story.php?id=1915">Confira aqui</a>!</p><br style="clear:both;"/>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=1959">Eleições da Câmara de Administração do NetBeans - Candidaturas Abertas</a></h2>
						<p style="margin-left:8px;">
						É hora de eleger a nova Câmara de Administração do NetBeans. O período para a candidatura está aberto de 13 a 26 de maio e a votação será de 27 de maio a 9 de junho. Os novos membros da câmara de administração serão anunciados à comunidade em 11 de junho de 2008.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=1960">Portal Pack 2.0 está disponível</a></h2>
						<p style="margin-left:8px;"><img src='http://services.netbeans.org/appl2/show_image.php?id=1104&column=image&table=story&type=image/pjpeg&db=xnetbeans&db_type=pear&id_col=story_id' 
		height='76' width='110' alt='image' style='float:left; margin-right:5px;margin-bottom:5px;'/>
						A versão final do Portal Pack 2.0 para o NetBeans 6.1 está disponível para download. Ele suporta a nova especificação do portlet JSR 286. Há muitas novas funcionalidades que ajudarão os desenvolvedores a escrever portlets rapidamente utilizando as características do JSR 286 (Portlet 2.0). Estes plugins também estão disponíveis na Central de Atualizações Automáticas do NetBeans 5.1 e com o Java Tools Bundle Update 5.</p><br style="clear:both;"/>
					</div>
				<h1>Comunidade</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=1958">Recapitulando o Evento - NetBeans Day no CommunityOne 2008</a></h2>
						<p style="margin-left:8px;"><img src='http://services.netbeans.org/appl2/show_image.php?id=1106&column=image&table=story&type=image/pjpeg&db=xnetbeans&db_type=pear&id_col=story_id' 
		height='73' width='110' alt='image' style='float:left; margin-right:5px;margin-bottom:5px;'/>
						Uma semana depois da entrega do NetBeans IDE 6.1, uma multidão entusiasmada reuniu-se para comemorar o quinto NetBeans Day em São Francisco, e o segundo NetBeans Day a ser realizado no CommunityOne no Moscone Center. Descubra o que rolou!</p><br style="clear:both;"/>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=1955">blueMarine no JavaOne 2008</a></h2>
						<p style="margin-left:8px;"><img src='http://services.netbeans.org/appl2/show_image.php?id=1109&column=image&table=story&type=image/pjpeg&db=xnetbeans&db_type=pear&id_col=story_id' 
		height='82' width='110' alt='image' style='float:left; margin-right:5px;margin-bottom:5px;'/>
						Este é um vídeo introdutório para o blueMarine utilizado na apresentação do JavaOne 2008 por Fabrizio Giudici, autor do blueMarine e membro do Dream Team do NetBeans. Este é um belo aplicativo de workflow digital, de código aberto, que alavancará o NetBeans Platform e o NASA World Wind.</p><br style="clear:both;"/>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=1956">Gravação do vídeo do NetBeans Day</a></h2>
						<p style="margin-left:8px;">
						Se quer fazer mais do que ler sobre o NetBeans Day no CommunityOne, você pode assistir à gravação do vídeo. As imagens estão com baixa qualidade, mas o som está límpido. Para assistir à sequência do NB Day utilize as sete caixas USTREAM.tv abaixo do media player. Comece o dia a partir da segunda linha na parte direita e continue os dias executando os clips à esquerda.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=1954">NekoBean's NetBeans Travel</a></h2>
						<p style="margin-left:8px;"><img src='http://services.netbeans.org/appl2/show_image.php?id=1110&column=image&table=story&type=image/pjpeg&db=xnetbeans&db_type=pear&id_col=story_id' 
		height='73' width='100' alt='image' style='float:left; margin-right:5px;margin-bottom:5px;'/>
						Este filme chamado, NetBeans Travel features NekoBean - Uma mascote da comunidade Japonesa do NetBeans. O autor do filme é <a href="http://hibiki.imprix.net/">Hibiki</a>, que é um membro da comunidade <a href="http://ja.netbeans.org/">ja.netbeans.org</a>. Muito obrigado Hibiki-san por este filme legal!</p><br style="clear:both;"/>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=1972">Novo coordenador de contribuições para o NB Community Docs: Varun Nischal</a></h2>
						<p style="margin-left:8px;">
						Varun Nischal foi apontado como novo Coordenador de Contribuições para o programa NetBeans Community Docs. Varun substitui Amit Kumar Saha, que foi um empregado da Sun Microsystems da Índia. Varun já contribuiu com uma série de documentos para o programa. Bem-vindo Varun!</p>
					</div>
				<h1>Artigos</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=1967">Clone usando o Mercurial no NetBeans 6.1</a></h2>
						<p style="margin-left:8px;">
						Este tutorial de Tushar Joshi mostra como clonar o projeto NetBeans IDE utilizando o Mercurial. O suporte ao Mercurial está em constantes alterações no IDE, e este tutorial mostra como você pode clonar no NetBeans 6.1.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=1968">NetBeans como um Scala IDE</a></h2>
						<p style="margin-left:8px;"><img src='http://services.netbeans.org/appl2/show_image.php?id=1115&column=image&table=story&type=image/pjpeg&db=xnetbeans&db_type=pear&id_col=story_id' 
		height='69' width='110' alt='image' style='float:left; margin-right:5px;margin-bottom:5px;'/>
						O grande trabalho de Caoyuan em seu plugin Scala está cada vez mais impressionante. Este artigo é uma visão geral do que você pode fazer atualmente com o Scala no NetBeans, como as instruções iniciais. Para telas e mais informações visite o <a href="http://blogtrader.net/page/dcaoyuan/">blog do Caoyuan</a>.</p><br style="clear:both;"/>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=1969">NetBeans Ruby IDE: Você nunca pensou que o desenvolvimento em Rails era tão divertido</a></h2>
						<p style="margin-left:8px;">
						Ed Ort oferece um bom resumo da sessão técnica do JavaOne 2008 apresentado por Tor Norbye e Brian Leonard. Se você ainda não testou o NetBeans para Ruby, JRuby, e Ruby on Rails você deveria dar uma outra olhada.</p>
					</div>
				<h1>Treinamento</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=1971">TechDays 2008 - Crie um laboratório em sua casa</a></h2>
						<p style="margin-left:8px;">
						Você perdeu o JavaOne 2008? O hands-on labs (HOLs) do 2008 tech days está disponível como "faça-você-mesmo". Você pode baixar os laboratórios e utilizar o tutorial passo-a-passo para experimentar novas tecnologias em casa.</p>
					</div>
				<h1>Revisões</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=1970">Extensão do NetBeans torna o trabalho do PHP mais simples</a></h2>
						<p style="margin-left:8px;">
						Pan Pantziarka do The Register mergulha no NetBeans IDE Early Access for PHP. Pan escreve, "Andando pelas partes principais do NetBeans, pensei que valeria a pena olhar na atualização do PHP para ver o que ele oferece para uma das mais populares linguagens dos dias de hoje."</p>
					</div>
				<h1>Blogs</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=1963">NetBeans Talk no Second Life</a></h2>
						<p style="margin-left:8px;">
						Leia sobre a fala que Roman Strobl deu no Second Life sobre as grandes características do NetBeans IDE, quais belas características estão por vir, e o que novos desenvolvedores precisam aprender sobre a plataforma Java.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=1964">Iniciando com Facelets e Seam no NetBeans 6.1</a></h2>
						<p style="margin-left:8px;">
						David Salter explica o que você precisa para iniciar com o Facelets e o Seam no 6.1.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=1965">Analisador Javadoc para o NetBeans 6.1</a></h2>
						<p style="margin-left:8px;">
						Adam Myatt fala sobre uma ferramenta legal para analisar o Javadoc, no NetBeans Zone.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=1966">RichFaces no NetBeans: Código aberto</a></h2>
						<p style="margin-left:8px;">
						O plugin exibido no NetBeans Day, para suporte ao RichFaces no IDE, está com seu código aberto no java.net. Você é muito bem-vindo a baixar os códigos-fonte, fazer adições a eles, e enviar sua contribuição ao projeto.</p>
					</div>
	<div class="edited">
	Esta edição foi enviada para você por: Henrique Meira<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-05-15_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>