
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
<head>
<title>NetBeans Weekly Newsletter, Issue # 31</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 # 31 - Oct 24, 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=4325">NetBeans IDE 6.8 Beta disponível para Download</a></h2>
						<p style="margin-left:8px;"><img src='http://services.netbeans.org/appl2/show_image.php?id=3573&column=image&table=story&type=image/png&db=xnetbeans&db_type=pear&id_col=story_id' 
		height='30' width='110' alt='image' style='float:left; margin-right:5px;margin-bottom:5px;'/>
						A equipe do NetBeans tem o prazer de anunciar o NetBeans IDE 6.8 Beta

<ul>
<li><a href="http://download.netbeans.org/netbeans/6.8/beta/?intcmp=3443">Download NetBeans IDE 6.8 Beta</a></li>
<li><a href="https://netbeans.org/community/releases/68/">Saiba mais sobre o NetBeans IDE 6.8 Beta</a></li>
</ul>


O NetBeans IDE 6.8 Beta é o primeiro a oferecer suporte completo para o Java EE 6 spec. Os destaques incluem suporte para JSF 2.0/Facelets, Java Persistence 2.0, EJB 3.1 incluindo utilização de EJBs em aplicações Web, serviços Web RESTful, e GlassFish v3. A integração do IDE com o <a href="http://kenai.com/">Project Kenai</a>, um ambiente colaborativo para hospedar projetos open-source, agora oferece suporte completo para JIRA e melhoria ao instant messenger  e integração ao issue tracker. O suporte ao PHP foi estendido para incluir o framework Symfony e PHP 5.3. O lançamento também suporta o JavaFX SDK 1.2.1, e vem com características adicionais para Maven e integração à banco de dados, além de melhorias para o editor e ferramentas para Ruby, Groovy, e C/C++. O NetBeans IDE 6.8 Beta está disponível em Inglês, Português brasileiro, japonês e chinês simplificado, bem como em várias línguas traduzidas pela comunidade.
Destaques da Versão
<ul>
    <li> Java Enterprise Edition 6
    <ul>
          <li> JavaServer Faces 2.0 para interfaces web e a capacidade de usar EJBs em aplicações web
          <li> Java Persistence JPA 2.0 e suporte a serviços Web RESTful
          <li> Ampliado o uso de anotações em vez de descritores de implantação
          <li> Implantação, depuração e profiling com GlassFish v3 
    </ul>
</ul>

<ul>
    <li> JavaServer Faces 2.0 (Facelets)
    <ul>
          <li> Auto-completar de código, sugestões sobre erros, auto-completar para namespaces, janelas de documentação, e auto-importação de tag para Facelets
          <li> Suporte às bibliotecas Facelets, componentes compostos, linguagem de expressão 
    </ul>
</ul>

<ul>    
    <li> JavaFX
    <ul>
          <li> Suporte para o JavaFX SDK 1.2.1
          <li> Navegação melhorada, auto-completar de código, e dicas 
    </ul>
</ul>
    
<ul>
    <li> PHP
    <ul>
          <li> Suporte completo ao PHP 5.3
          <li> Suporte ao Framework Symfony 
    </ul>
</ul>


<ul>
    <li> Kenai.com: Desenvolvedor Conectado
    <ul>
          <li> Suporte completo ao JIRA
          <li> Melhoria à integração de issue tracker
    </ul>
</ul>

<ul>
    <li> Maven
    <ul>
          <li> Melhoria ao suporte para Java EE 6, Groovy, Projetos Scala
          <li> Exclusão de dependência personalizável em gráfico de dependência
    </ul>
</ul>


<ul>
    <li> Ruby
    <ul>
          <li> Suporte para o JRuby 1.3.1, depuração Ruby 1.9 e RSpec 1.2.7
          <li> Melhoria ao renomear da refatoração, inferência de tipos e navegação 
    </ul>
</ul>


<ul>
    <li> C / C + +
    <ul>
          <li> Profiling: Novas ferramentas para a Monitoria de E/S, análise de thread e detecção de disputa.
          <li> Sincronização mais rápida durante o desenvolvimento remoto
    </ul>
</ul>

<br>
<a href="https://netbeans.org/community/releases/68/">Saiba mais sobre o NetBeans IDE 6.8 Beta.</a>


A versão final do NetBeans IDE 6.8 está prevista para dezembro de 2009.

<a href="http://download.netbeans.org/netbeans/6.8/beta/?intcmp=3443">Baixe o Beta</a> hoje e envie seu feedback sobre sua experiência com esta versão. Você também pode participar de discussões sobre o NetBeans IDE em nossas <a href="https://netbeans.org/community/lists/top.html">listas de discussão e fóruns</a>. Se você escreve sobre o uso do NetBeans adicione seu blog ao <a href="http://planetnetbeans.org/">Planeta NetBeans</a>. Siga o <a href="http://twitter.com/netbeans">NetBeans no Twitter</a> para atualizações sobre o NetBeans e seu desenvolvimento.</p><br style="clear:both;"/>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=4320">NetBeans para PHP: Formatação e Recuo</a></h2>
						<p style="margin-left:8px;">
						Petr Pisl recentemente fez uma apresentação no WebExpo 2009, em Praga. Ele falou sobre o desenvolvimento de aplicações web, e o público mostrou muito interesse em suas demonstrações PHP. Após a sessão, Petr recolheu todos os comentários em uma tarefa do Issuezilla recém-criado. Se você se lembrar de algum problema (por exemplo, se a formatação ou recuo no editor PHP não funciona como esperado) ajude a encontrá-los adicionando seu código de exemplo na lista.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=4321">Plugin ALM com suporte para Mercurial e Git</a></h2>
						<p style="margin-left:8px;">
						Um grupo de entusiastas do software open source e a Intland continuam a desenvolver o plugin NetBeans ALM (Application Lifecycle Management). Este plugin se integra com o codeBeamer 5.4, Mercurial e Git. A equipe solicita feedback de todos, e incentiva os membros da comunidade NetBeans para aderirem ao projeto no JavaForge. O lançamento está agendado para 31 de janeiro de 2010.</p>
					</div>
				<h1>Comunidade</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=4322">OSUM hospeda o Global NetBeans Demo Fest!</a></h2>
						<p style="margin-left:8px;">
						Você é um estudante ou um instrutor? Entre para a comunidade Open Source University Meetup (OSUM) e participe do mês do NetBeans Demo Fest! Visite o site OSUM e confira a agenda dos eventos. Reúna com seus amigos e assista (ou exiba) demos do NetBeans em ação. A OSUM preparou uma série de seminários via web para apresentar o IDE, e treinar você sobre como conduzir uma demonstração do NetBeans caso você se interesse em apresentar uma sessão.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=4323">Última chance para votar para a Câmara de Administração do NetBeans</a></h2>
						<p style="margin-left:8px;">
						A Câmara de Administração do NetBeans é um conselho de três membros, cuja principal tarefa é certificar que o projeto NetBeans está sendo executado de uma maneira justa e aberta. <a href="https://netbeans.org/community/articles/election_profiles.html">Saiba mais sobre os candidatos</a> e <a href="https://netbeans.org/community/articles/nbelections.html">seus votos</a>! O período de votação vai até meia-noite, quarta-feira 21 de outubro. Os resultados e os novos conselheiros serão anunciados na segunda-feira, 26 de outubro.</p>
					</div>
				<h1>Treinamento</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=4317">Video: Suporte Namespace do PHP no NetBeans IDE 6.8</a></h2>
						<p style="margin-left:8px;">
						Este screencast demonstra o auto-completar de código namespaces para PHP 5.3 no NetBeans IDE 6.8. Também mostra ao usuário como alterar as opções para o auto-completar de código namespace PHP e outros recursos de edição PHP.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=4318">Vídeo: Demos RESTful Web Service de Carol McDonald</a></h2>
						<p style="margin-left:8px;">
						Esta aplicação do Pet Store Catalog expõe um catálogo como um serviço Web RESTful para aplicações cliente remotas, e mostra um cliente Ajax que recebe e mostra as respostas do Web Service em uma tabela dinâmica Ajax (grade Dojo). Por Carol McDonald.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=4319">Trabalhando com o Maven no NetBeans 6.7.1</a></h2>
						<p style="margin-left:8px;">
						Neste artigo vamos olhar para o suporte ao Maven no mais recente NetBeans IDE 6.7.1. Maven é uma ferramenta excelente, muito apreciada por sua capacidade de ajudar, harmonizar e padronizar a construção de práticas dentro de uma organização. Saiba mais sobre como criar e trabalhar com projetos Maven, e gerenciar o arquivo POM e dependências.</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-10-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>