
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
<head>
<title>NetBeans Weekly Newsletter, Issue # 34</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 # 34 - Dec 04, 2009
		</div>
	</div>
	<div id="content">
	
				<h1>Agenda</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=4499">Sun Tech Days de volta ao Brasil!</a></h2>
						<p style="margin-left:8px;"><img src='http://services.netbeans.org/appl/show_image.php?id=3761&column=image&table=story&type=image/png&db=services&db_type=pear&id_col=story_id'
		height='88' width='100' alt='image' style='float:left; margin-right:5px;margin-bottom:5px;'/>
						Desta vez, contaremos com a presença do James Gosling, o Pai do Java!

No Sun Tech Days Brasil, que está em sua oitava edição, você vai ver de perto os principais experts da Sun, além de aprender, compartilhar informações, interagir, criar oportunidades, conhecer outros desenvolvedores e, principalmente, participar.

Venha fazer parte do Sun Tech Days Brasil, que conta com o apoio dos JUGs brasileiros, das universidades e de milhares de desenvolvedores!</p><br style="clear:both;"/>
					</div>
				<h1>Novidades do projeto</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=4498">Baixe o NetBeans IDE 6.8 Release Candidate 1!</a></h2>
						<p style="margin-left:8px;"><img src='http://services.netbeans.org/appl/show_image.php?id=3751&column=image&table=story&type=image/jpeg&db=services&db_type=pear&id_col=story_id'
		height='88' width='100' alt='image' style='float:left; margin-right:5px;margin-bottom:5px;'/>
						A Equipe do NetBeans tem o prazer de anunciar o primeiro release candidate do NetBeans IDE 6.8 disponível para download. Teste esta versão e dê seu feedback pela <a href="https://netbeans.org/community/netcat/ca_survey_68.html">pesquisa NetCAT</a> ou participando das discussões nas listas e fóruns do NetBeans. A versão final do NetBeans IDE 6.8 está prevista para dezembro.
<br>
<b>NetBeans IDE 6.8: Conheça já hoje o amanhã!</b></p><br style="clear:both;"/>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=4497">O NetBeans 6.8 Release Candidate está pronto para o FCS?</a></h2>
						<p style="margin-left:8px;"><img src='http://services.netbeans.org/appl/show_image.php?id=3752&column=image&table=story&type=image/png&db=services&db_type=pear&id_col=story_id'
		height='83' width='110' alt='image' style='float:left; margin-right:5px;margin-bottom:5px;'/>
						O NetBeans IDE 6.8 está pronto para o lançamento do FCS? Baixe a última Release Candidate, faça a Pesquisa de Aceitação da Comunidade NetBeans e nos conte sobre sua experiência! As pesquisas estarão abertas até <b>9 de dezembro</b>.</p><br style="clear:both;"/>
					</div>
				<h1>Artigos</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=4492">Gestão Finaneira Corporativa na Plataforma NetBeans</a></h2>
						<p style="margin-left:8px;">
						Geertjan entrevista o desenvolvedor NetBeans Platform Craig Marshall da Experian Ltd, que oferece ferramentas e suporte para o setor financeiro. Veja como ele faz uso da API de Biblioteca Visual do NetBeans e o MemoryFileSystem, e por que eles estão distribuindo sua aplicação via Java Web Start.</p>
					</div>
				<h1>Treinamento</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=4494">Dica técnica: Depuração remota com PHP no NetBeans 6.8</a></h2>
						<p style="margin-left:8px;">
						Uma dica rápida sobre como depurar remotamente o seu código PHP com o NetBeans IDE 6.8.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=4495">REST Web Services no Google App Engine Usando o NetBeans 6.7</a></h2>
						<p style="margin-left:8px;">
						Um tutorial do desenvolvedor Armel Nene mostrando como desenvolver um web service baseado em REST que funciona com o Google App Engine usando o NetBeans 6.7 e a API Jersey.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=4496">Melhore a sua aplicação JavaFX aplicando transformações</a></h2>
						<p style="margin-left:8px;">
						Este artigo discute as transformações básicas que estão disponíveis no SDK do JavaFX. Aprenda a girar, escalonar, ou traduzir objetos em sua aplicação com os padrões visuais e exemplos de código fornecidos.</p>
					</div>
				<h1>Comunidade</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=4493">Próximos seminários Java EE 5/6 com Adam Bien</a></h2>
						<p style="margin-left:8px;">
						Adam Bien apresentará workshops sobre Java EE e falará em vários eventos, incluindo um workshop em Munique "Arquitetura Corporativa Pragmática", uma palestra sobre Cloud Computing, e um workshop Java EE 6 em janeiro. Ele também estará em fevereiro nas sessões JUG. Assine o blog de Adam para mais detalhes.</p>
					</div>
				<h1>Blogs</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=4489">Redesenhar uma app com NetBeans</a></h2>
						<p style="margin-left:8px;">
						Quando o blogueiro Quintin Beukes teve que redesenhar uma aplicação a partir do zero, ele abordou o front-end utilizando a Plataforma NetBeans RCP . Ele escolheu o NetBeans para o seu suporte Maven por "características que são muito mais completas e de qualidade muito maior" do que outros IDEs.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=4490">Quando os botões param de funcionar ... NetBeans para o resgate!</a></h2>
						<p style="margin-left:8px;">
						Um blogueiro da TechnologyTales.com migrou para o NetBeans depois que o Eclipse parou de funcionar com a atualização do seu Ubuntu 9.10. Ele disse: "As coisas pareciam ir bem e parece ter substituído o Eclipse para executar tarefas de desenvolvimento PHP."</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=4491">Novidades do NetBeans 6.8 para desenvolvedores Ruby?</a></h2>
						<p style="margin-left:8px;">
						Uma visão geral dos vários novos recursos e melhorias no suporte a Ruby do NetBeans 6.8.</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-12-04_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>