
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
<head>
<title>NetBeans Weekly Newsletter, Issue # 28</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 # 28 - Jan 20, 2009
		</div>
	</div>
	<div id="content">
	
				<h1>Novidades do projeto</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=3171">Baixe o eBook do NetBeans: "100 NetBeans IDE Tips and Tricks!"</a></h2>
						<p style="margin-left:8px;"><img src='http://services.netbeans.org/appl2/show_image.php?id=2382&column=image&table=story&type=image/jpeg&db=xnetbeans&db_type=pear&id_col=story_id' 
		height='110' width='87' alt='image' style='float:left; margin-right:5px;margin-bottom:5px;'/>
						100 NetBeans IDE Tips and Tricks é uma coleção das melhores dicas técnicas para o NetBeans retiradas da comunidade. A versão impressa foi um sucesso no JavaOne 2008, então decidimos relançar a coleção como eBook. Pegue sua cópia hoje!</p><br style="clear:both;"/>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=3161">Novo depurador multi-tarefas no NetBeans</a></h2>
						<p style="margin-left:8px;">
						A equipe do Depurador do NetBeans tem trabalhado em um projeto de melhorias significantes para o fluxo de trabalho da depuração e usabilidade, com foco na depuração multi-tarefas que vem chegando com o NetBeans 6.5. Uma nova e poderosa janela de depuração foi introduzida e integra sessões, threads, e chamadas de pilhas. Aprenda mais sobre as características adicionais do novo suporte do Depurador Multi-tarefas e dê o seu feedback à equipe.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=3170">Podcast do NetBeans #49 - Estudioso do NetBeans!</a></h2>
						<p style="margin-left:8px;"><img src='http://services.netbeans.org/appl2/show_image.php?id=2383&column=image&table=story&type=image/png&db=xnetbeans&db_type=pear&id_col=story_id' 
		height='88' width='100' alt='image' style='float:left; margin-right:5px;margin-bottom:5px;'/>
						Querendo idéias para presentear um amigo desenvolvedor neste fim de ano? O Podcast do NetBeans #49 lhe dá alguma inspiração: Tente um livro do NetBeans! Esta é uma edição de todos os livros com Lloyd Dunn e Geertjan Wielenga em entrevista com três autores dos recentes livros do NetBeans. Confira as últimas novidades da comunidade NetBeans, incluindo um novo projeto da comunidade para 2009.</p><br style="clear:both;"/>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=3169">Vencedores de Os Inovadores do NetBeans — Onde eles estão agora?</a></h2>
						<p style="margin-left:8px;">
						Passaram-se três meses desde os 13 empreendedores usuários do NetBeans que foram premiados em dinheiro para desenvolver e completar projetos para o Concurso de Inovadores do NetBeans. A equipe do NetBeans foi atrás dos ganhadores para saber quais os planos eles têm para seus projetos e quais os seus ganhos!</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=3172">Woodstock migra para ICEfaces</a></h2>
						<p style="margin-left:8px;">
						<p>A equipe NetBeans está feliz em anunciar os esforços de fusão com a parceira estratégica ICEsoft para oferecer suporte aos usuários do Woodstock. Com o último plugin do ICEface para o NetBeans (v1.7.2SP1), os usuários do Woodstock poderão migrar e manter seus projetos existentes, e começar a desenvolver páginas ICEface em paralelo com páginas Woodstock existentes.</p>
<p>
<ul>
<li>Aprenda mais na <a href="http://www.icefaces.org/main/product/woodstock-migration.iface">página de migração Woodstock para ICEfaces.</a>
<li>Baixe o <a href="http://www.icefaces.org/main/downloads/os-downloads.iface?category=NetBeans">plugin do ICEfaces</a> em ICEfaces.org, ou da Central de Atualização do NetBeans clicando em Ferramentas -> Plugins de dentro do IDE.
<li>Leia o <a href="https://netbeans.org/kb/docs/web/icefaces-migration-1.html">guia de portabilidade do Woodstock para ICEfaces</a> (em inglês).
</ul>
</p></p>
					</div>
				<h1>Artigos</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=3159">Interoperabilidade avançada de web services em passos fáceis</a></h2>
						<p style="margin-left:8px;">
						O NetBeans Zone apresenta um artigo aprofundado do Engenheiro do NetBeans Martin Grebac sobre a interoperabilidade de web services no NetBeans 6.1, com alguns pedaços de códigos e telas ilustrativas.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=3160">3 maneiras de estar bem informado sobre o NetBeans Platform</a></h2>
						<p style="margin-left:8px;"><img src='http://services.netbeans.org/appl2/show_image.php?id=2372&column=image&table=story&type=image/jpeg&db=xnetbeans&db_type=pear&id_col=story_id' 
		height='33' width='110' alt='image' style='float:left; margin-right:5px;margin-bottom:5px;'/>
						No JavaOne 2008, o Diretor do Núcleo de Engenharia do NetBeans Arseniy Kuznetsov conseguiu uma folga em sua apertada agenda para nos dar as últimas notícias sobre o NetBeans Platform 6.1. Aprenda sobre aplicativos bem legais construídos na plataforma, a novíssima redesenhada <a href="http://platform.netbeans.org/">página de recursos do NetBeans Platform</a> e maneiras de tornar-se um Engheiro NetBeans Platform certificado!</p><br style="clear:both;"/>
					</div>
				<h1>Comunidade</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=3162">Confira o Redesenhado Portal da Comunidade NetBeans!</a></h2>
						<p style="margin-left:8px;">
						O Portal da Comunidade NetBeans tem um novo visual! Toda informação que você precisa para contribuir com o codebase do NetBeans, para desenvolver seus projetos com o NetBeans, e para engajar-se com a comunidade NetBeans está agora disponível em uma única página fácil de usar! O que você pode encontrar no portal? Coisas como:
<p>
<ul>
<li>Criar módulos para o NetBeans e submeter patches.
<li>Manter-se atualizado sobre as liberações do NetBeans, novidades da comunidade e eventos ao redor do mundo.
<li>Enviar vídeos e notas de eventos ao NetBeans TV.
<li>Compartilhar sua experiência com o NetBeans com outros usuários entrando para alguma das listas de discussões ou escrevendo tutoriais.
<li>E muito mais!
</ul>
</p>
O Portal da Comunidade NetBeans é a sua porta de entrada para participar do Projeto NetBeans e da crescente comunidade. Visite o portal e envolva-se!</p>
					</div>
				<h1>Treinamento</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=3156">Usando o JBI JavaEE Service Engine</a></h2>
						<p style="margin-left:8px;">
						Um tutorial que demonstra como usar o JavaEE Service Engine no NetBeans para melhorar a performance de web services EJB.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=3157">Melhores práticas para o Apache Maven no NetBeans</a></h2>
						<p style="margin-left:8px;">
						Aprenda como ganhar vantagem do suporte ao Apache Maven do NetBeans com este tutorial que demonstra a importação, criação e o trabalho com projetos baseados no Apache Maven</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=3158">Criando EJB3 Sessions Beans utilizando o NetBeans 6.1 e Glassfish</a></h2>
						<p style="margin-left:8px;">
						O NetBeans 6.1 vem com características que tornam o desenvolvimento web mais fácil, e combinado com o Servidor de Aplicações Glassfish é uma boa escolha para trabalhar com componentes EJB3 como explicado neste tutorial de contribuição à comunidade por Jair Rillo Junior.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=3165">Vídeo: Python e Ruby Code Coverage no NetBeans 7.0</a></h2>
						<p style="margin-left:8px;">
						Dois novos vídeos de Tor Norbye destacam uma nova característica para o NetBeans 7.0: suporte ao Code Coverage para Python e Ruby. Veja os vídeos do Ruby <a href="https://channelsun.sun.com/category/playlist?id=81">aqui</a>, e o recente <a href="http://blogs.sun.com/tor/entry/netbeans_screenshot_of_the_week6">blog</a> de Tor sobre o suporte ao code coverage.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=3166">Configure aplicação web utilizando JBoss Seam NetBeans Tomcat e Maven</a></h2>
						<p style="margin-left:8px;">
						Construa uma aplicação web HelloWorld simples utilizando o Framework JBoss-Seam no Tomcat e utilizando o NetBeans com o suporte ao Maven.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=3167">Guia de início rápido de desenvolvimento Java ME MIDP</a></h2>
						<p style="margin-left:8px;">
						Aprenda o básico da utilização do NetBeans para criar um aplicativo Java Platform, Micro Edition (Java ME platform), Mobile Information Device Profile (MIDP). Os usuários estão mostrando duas maneiras de crair um projeto Java ME MIDP chamado MyHello que exibe o texto "Make my day" em um dispositivo emulado.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=3168">Usando Plugins do Portal Pack 3.0 para criar Portlets</a></h2>
						<p style="margin-left:8px;">
						Portlets são componentes UI modulares que são utilizados para criar portais web. Os plugins Portal Pack no NetBeans suportam todo o ciclo de vida de um desenvolvimento de aplicativos portlets. Este tutorial fala sobre os passos para empacotar, implantar, e testar portlets dentro do NetBeans.</p>
					</div>
				<h1>Blogs</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=3153">Dica: Utilizando o Ruby IRB</a></h2>
						<p style="margin-left:8px;">
						O tutorial aponta algumas utilizações do Interactive Ruby (IRB) no NetBeans.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=3154">Ligações de esquema XML</a></h2>
						<p style="margin-left:8px;">
						As ligações XML no NetBeans podem melhorar. Angad Singh e Varun Nischal estão trabalhando em uma maneira de ligar elementos e atributos aos seus DTD ou definições de esquemas.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=3155">Levando o novo Swing Tree Table para uma volta</a></h2>
						<p style="margin-left:8px;">
						Geertjan Wielenga dá uma prévia sobre o uso do novo tree table do evangelista Tim Boudreau fora do NetBeans Platform. Ele demonstra com exemplos úteis.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=3163">Atualizando uma aplicação NetBeans Platform silenciosamente</a></h2>
						<p style="margin-left:8px;">
						Você construiu uma aplicação sobre o NetBeans Platform, mas quer que as atualizações ocorram automaticamente sem a interação do usuário. Jiri Rechtacek, um engenheiro do NetBeans Platform que trabalha no AutoUpdate do NetBeans, escreve sobre como fazer isto acontecer.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=3164">Inicie com o JavaFX SDK</a></h2>
						<p style="margin-left:8px;">
						O JavaFXpert James Weaver dá uma visão geral sobre o JavaFX SDK com um tutorial para criar uma aplicação de calculadora simples.</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_fr.html">French</a> | <a href="https://netbeans.org/community/news/newsletter/index_zh_CN.html">Chinese - simplified</a> | <a href="https://netbeans.org/community/news/newsletter/index_zh_TW.html">Chinese - traditional</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/2009-01-20_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>