
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
<head>
<title>NetBeans Weekly Newsletter, Issue # 88</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/appl/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/appl/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 # 88 - Feb 01, 2011
		</div>
	</div>
	<div id="content">
	
				<h1>Novidades do projeto</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=6074">Plugin APIGen: Gerador API de projeto PHP</a></h2>
						<p style="margin-left:8px;">
						O plugin APIGen integra o gerador de documentação da API APIGen ao NetBeans IDE e permite gerar documentação da API para projetos PHP.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=6075">NetBeans Plugin: Suporte ao SCSS ("Sassy CSS")</a></h2>
						<p style="margin-left:8px;">
						SCSS é uma das duas sintaxes disponíveis para Sass, que é uma extensão do CSS que adiciona potência e elegância para a linguagem básica. Saiba mais sobre Sass aqui. Este plugin da comunidade NetBeans adiciona suporte para edição de arquivos SCSS.</p>
					</div>
				<h1>Tutoriais</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=6069">Adicionando sub-projetos para Tipos de Projeto</a></h2>
						<p style="margin-left:8px;">
						Aprenda a visualizar facilmente arquiteturas modulares em hierarquias de árvore em Java Swing.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=6070">Vídeos: Arquitetura de serviços da Plataforma NetBeans</a></h2>
						<p style="margin-left:8px;">
						Estes vídeos mostram Toni Epple no curso de formação da plataforma NetBeans do JUG de Poznan. Os vídeos dão uma boa visão geral do que acontece em nossos cursos de formação popular.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=6071">Replay do Webinar: Java EE 6 com o NetBeans e GlassFish</a></h2>
						<p style="margin-left:8px;">
						Perdeu o webinar ao vivo de 20 de janeiro sobre JavaEE 6, NetBeans e Glassfish com o evangelista da Oracle Arun Gupta? A sessão inteira está disponível sob demanda.</p>
					</div>
				<h1>Agenda</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=6068">NetBeans, JDK 7 e Java EE 6 no JFokus, Suécia (14-16 fevereiro)</a></h2>
						<p style="margin-left:8px;">
						Junte-se os evangelistas Oracle Arun Gupta, Alexis Moussine-Pouchkine, Roger Brinkley e Tomas Nilsson no JFokus em 2011, em Estocolmo, Suécia, para aprender sobre os mais recentes recursos em Java EE, GlassFish e JDK 7, e como o NetBeans IDE em conjunto com estas tecnologias ajuda os desenvolvedores a serem mais produtivos, e muito mais.<br><br>
<b>Sessões Oracle no JFokus:</b><br><br>
Modelo de programação Java EE 6 desmistificado<br>
Exibição de ferramenta Java EE 6<br>
Executando o seu aplicativo Java EE nas nuvens<br>
Aprendendo Porcas & Parafusos do Java EE 6 Tutorial de código intensivo<br>
Atualização do JDK7<br>
Tudo sobre ME (Móvel e Embutido)<br></p>
					</div>
				<h1>Comunidade</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=6072">Renascido: Localização Romêna da Plataforma NetBeans</a></h2>
						<p style="margin-left:8px;">
						A localização romena da plataforma NetBeans está de volta com o novo tradutor Ioan Stan Eugen. Com 93% da localização concluída da Plataforma NetBeans 7.0, junte-se à Eugen para colocar o projeto em 100%!</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=6073">Pesquisa NetBeans: Próximo controle de versão do NetBeans?</a></h2>
						<p style="margin-left:8px;">
						Serena Dimension, Bazar, SourceSafe, Perforce? Qual o controle de versão que você quer ver no NetBeans IDE? Diga-nos na última Pesquisa da  Comunidade NetBeans.</p>
					</div>
				<h1>Artigos</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=6067">KLISS, Software Legislativo na software na plataforma NetBeans</a></h2>
						<p style="margin-left:8px;">
						Construído sobre a plataforma NetBeans, KLISS (Kansas Legislative Information Systems) é um software criado por Propylon, uma empresa especializada em processamento de informações legislativas e regulamentares e de gestão de conteúdo.</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/2011-02-01_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>