
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
<head>
<title>NetBeans Weekly Newsletter, Issue # 5</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 # 5 - Apr 02, 2008
		</div>
	</div>
	<div id="content">
	
				<h1>Novidades do projeto</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=1714">Baixe o NetBeans 6.1 Beta, fale no seu blog e ganhe USD$500!</a></h2>
						<p style="margin-left:8px;"><img src='http://services.netbeans.org/appl2/show_image.php?id=866&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;'/>
						Baixe e teste a última versão do NetBeans e fale para o mundo o que você achou. Coloque em seu blog algo falando sobre as características que você mais gosta ou sobre a sua experiência usando o NetBeans e você poderá ganhar USD$500 ou uma camiseta bem legal do NetBeans! O concurso termina em 18 de abril de 2008.</p><br style="clear:both;"/>
					</div>
				<h1>Artigos</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=1724">Exemplos da API para os desenvolvedores da plataforma NetBeans</a></h2>
						<p style="margin-left:8px;">
						Onde você pode ir para aprender sobre a plataforma NetBeans?
Independentemente das <a href="https://netbeans.org/kb/">páginas de tutoriais</a>, do NetBeans.org você também pode fazer download de alguns pequenos (e não tão pequenos)  exemplos da API do NetBeans a partir do <a href="http://plugins.netbeans.org/PluginPortal/">Portal de plugins do NetBeans</a>. Tenha uma visão geral sobre estes exemplos no artigo de Geertjan Wielenga no Javalobby.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=1723">Adam Bien - Pensando no meio-ambiente com o NetBeans IDE</a></h2>
						<p style="margin-left:8px;">
						Arquiteto Java EE, desenvolvedor, palestrante, instrutor, autor, blogueiro, consultor, campeão Java —Adam Bien usa muitos chapéus, incluindo um deles como membro do Time dos Sonhos do NetBeans. Nesta entrevista descubra como o NetBeans o ajuda a otimizar o consumo eficiente de energia.</p>
					</div>
				<h1>Treinamento</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=1722">Geração de código personalizado no NetBeans UML</a></h2>
						<p style="margin-left:8px;">
						Aproveite  o poder dos modelos dentro do framewok de geração de código do NetBeans UML com este tutorial para criação, adição e personalização de modelos de geração de código. Os modelos de geração de código personalizados fornecem uma maneira eficiente e fácil de geração de código que podem ser utilizados em projetos de aplicação.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=1713">O NetBeans e o que ele pode fazer por seu jogo móvel</a></h2>
						<p style="margin-left:8px;"><img src='http://services.netbeans.org/appl2/show_image.php?id=867&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;'/>
						Petr Suchomel introduz o NetBeans e como aplicar suas características móveis para o desenvolvimento de jogos para dispositivos móveis.</p><br style="clear:both;"/>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=1715">Carregamento dinâmico de Jar no JRuby</a></h2>
						<p style="margin-left:8px;">
						Um problema potencial da construção do JRuby e do Java em um pacote é como gerenciar as dependências do Jar. Teera Kanokkanjanarat explica uma solução rápida neste tutorial criado com contribuições da comunidade.</p>
					</div>
				<h1>Agenda</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=1716">Registre-se para o NetBeans Day no CommunityOne! (São Francisco, 5 de maio)</a></h2>
						<p style="margin-left:8px;"><img src='http://services.netbeans.org/appl2/show_image.php?id=864&column=image&table=story&type=image/png&db=xnetbeans&db_type=pear&id_col=story_id' 
		height='73' width='110' alt='image' style='float:left; margin-right:5px;margin-bottom:5px;'/>
						Participe do <b>NetBeans Day no CommunityOne</b> para ouvir e ver o que há de novo no NetBeans; almoce com o Java Posse; encontre-se com os especialistas em NetBeans, com outros desenvolvedores e leve consigo algumas lembranças do NetBeans. A participação é gratuíta mas as vagas são limitadas por isso registre-se agora!</p><br style="clear:both;"/>
					</div>
				<h1>Comunidade</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=1717">Lista de discussão NetBeans em italiano!</a></h2>
						<p style="margin-left:8px;">
						O NetBeans criou uma lista de discussão para os usuários italianos! Os membros podem discutir os assuntos relacionados, oferecer ajuda uns aos outros e mais. Inscreva-se hoje em <a href="mailto:nbdiscuss_it@netbeans.org">nbdiscuss_it@netbeans.org</a>. Com esta nova lista nós chegamos a oito grupos de discussão em língua diferente do inglês, incluindo espanhol, francês, japonês, polonês, português, russo e chinês.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=1718">Lançado o Planeta NetBeans Polonês!</a></h2>
						<p style="margin-left:8px;">
						Os desenvolvedores poloneses, que "blogam" sobre o NetBeans, agora têm uma casa no Planeta NetBeans! Encoraje outros bloggers a adicionarem <a href="http://www.planetnetbeans.org/add.html">adicionarem seus blogs</a> ao diretório. Com o site polonês, o Planeta NetBeans conta agora com autores escrevendo blogs sobre o NetBeans em 13 idiomas diferentes!</p>
					</div>
				<h1>Blogs</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=1719">Importando projetos C do Eclipse no NetBeans: um guia visual</a></h2>
						<p style="margin-left:8px;">
						Amit Kumar Saha fornece um guia visual, fácil de seguir, para importar projetos C/C++ do Eclipse para o NetBeans.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=1720">Verificação rápida de atualizações no NetBeans 6.1</a></h2>
						<p style="margin-left:8px;">
						Precisa verificar as atualizações disponíveis para o NetBeans 6.1? O blogger Rechtacek descreve três maneiras de fazer isto, incluindo a utilização de um novo item de menu do IDE: <b>Ajuda | Verificar atualizações</b>.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=1721">Escrevendo dicas para o editor Java do NetBeans</a></h2>
						<p style="margin-left:8px;">
						Você está sentindo falta das dicas no editor Java do NetBeans? Veja esta simples maneira de criar suas próprias dicas.</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>
        </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-02_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>