
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
<head>
<title>NetBeans Weekly Newsletter, Issue # 16</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 # 16 - Jun 20, 2008
		</div>
	</div>
	<div id="content">
	
				<h1>Agenda</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=2139">NetBeans WorldTour no Jazoon 08 (23 de Junho, Zurique)</a></h2>
						<p style="margin-left:8px;"><img src='http://services.netbeans.org/appl2/show_image.php?id=1321&column=image&table=story&type=image/png&db=xnetbeans&db_type=pear&id_col=story_id' 
		height='60' width='100' alt='image' style='float:left; margin-right:5px;margin-bottom:5px;'/>
						Participe do Jazoon para ter uma chance de ver o que há de novo no NetBeans. Os membros da equipe do NetBeans demonstrarão como o NetBeans suporta as mais quentes linguagens de scripts, irão construir Ricas Aplicações de Internet (RIA - Rich Internet Applications) e aplicações para telefones e PDAs num piscar de olhos. Veja como você pode reutilizar código existente da plataforma NetBeans para criar rapidamente sua própria aplicação desktop. Registre-se hoje para o Jazoon 08 e junte-se a outros membros da comunidade. Interaja com a equipe NetBeans, encontre-se com os iluminados do Java e divirta-se!</p><br style="clear:both;"/>
					</div>
				<h1>Comunidade</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=2147">Programação Java EE (com Paixão!) 80 graduados</a></h2>
						<p style="margin-left:8px;">
						Parabéns aos 80 graduados do curso online "Java EE Programming (with Passion!)" de Sang Shin que foi finalizado em Maio. Os diplomados participaram enviando todos os 22 deveres de casa durante o curso. Aqui está algo do que alguns dos novos programadores JEE estão dizendo sobre o curso que está agora no 13º. ciclo:
<br><br>
<i>"Este curso é uma grande iniciativa e muito útil!! Eu aprendi muito sobre os fundamentos do J2ee, excelente para iniciantes." - Maciek Opala, Polônia</i>
<br><br>
<i>"Novamente, muito obrigado por oferecer este programa. O currículo do curso é excelente, com muitos desafios e lições interessantes. Obviamente que você coloca muito trabalho nisto. Muito obrigado por oferecer este serviço!" - LB Corney, EUA</i></p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=2148">Varun Nischal - Mineração de blogs em busca de bons tutoriais do NetBeans</a></h2>
						<p style="margin-left:8px;">
						Recentemente anunciamos que o programa NetBeans Community Docs recebeu um novo coordenador. Saiba mais sobre Varun Nischal, como ele contribui para a Comunidade e porque grandes artigos de blogs sobre o NetBeans fazem ele ficar tão feliz. E se você tem algum artigo em blog sobre o NetBeans, Varun espera conhecê-lo!</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=2149">Eleitos da Câmara de Administração do NetBeans</a></h2>
						<p style="margin-left:8px;">
						Os membros do Dream Team Wade Chandler e Tom Wheeler ganharam o segundo mandato da Câmara de Administração do NetBeans! O terceiro membro da Câmara nomeado será anunciado brevemente. Parabéns a Wade e Tom e todos os nossos candidatos!</p>
					</div>
				<h1>Artigos</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=2146">Gerenciador de Banco de Dados Epictetus (Construído sobre a plataforma NetBeans)</a></h2>
						<p style="margin-left:8px;">
						Konstantin Chikarev foi entrevistado no Javalobby e falou sobre um novo gerenciador de bancos de dados que teve seu desenvolvimento iniciado em Moscou. Veja porque Chikarev escolheu a plataforma NetBeans e como o Epictetus foi criado.</p>
					</div>
				<h1>Treinamento</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=2143">Aplique checkout em projetos do Java.net utlizando o NetBeans</a></h2>
						<p style="margin-left:8px;">
						Este tutorial fornece um guia visual para a utlização do suporte CVS no NetBeans para aplicar o check-out em projetos hospedados no Java.net.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=2144">Melhorias do depurador no NetBeans</a></h2>
						<p style="margin-left:8px;">
						Expression Stepping e Heap Walking são duas das maiores melhorias do depurador no NetBeans. Este documento oferece um resumo rápido de como começar a utilizar estas funcionalidades para a depuração de projetos.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=2145">Guia do ClearCase para o NetBeans IDE 6.1</a></h2>
						<p style="margin-left:8px;">
						Com o NetBeans IDE 6.1 você pode realizar tarefas de versionamento utlizando o Rational ClearCase. Aprenda os passos básicos envolvidos com o uso do ClearCase no NetBeans e uma introdução para algumas das novas características de versionamento incluídas no IDE desde a versão 6.0.</p>
					</div>
				<h1>Blogs</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=2140">Novo Blog: NetBeans para PHP</a></h2>
						<p style="margin-left:8px;">
						A equipe por trás do desenvolvimento do suporte ao PHP no NetBeans iniciou um novo blog. Siga seu progresso, como por exemplo, como anda o trabalho das funcionalidades para o NetBeans 6.5. E utilize o blog para dar um feedback à equipe.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=2141">Pegue seus plugins no Gerenciador de Plugins do NetBeans</a></h2>
						<p style="margin-left:8px;">
						Talvez você tenha plugins no NetBeans Plugin Portal. Você sabia que agora é possível pegá-los de dentro do Gerenciador de Plugins do NetBeans automaticamente? Primeiro, você precisa ter seus plugins verificados, como explicado neste blog por Geertjan Wielenga.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=2142">Utilizando o Beans Binding para pesquisar em tabelas</a></h2>
						<p style="margin-left:8px;">
						O escritor técnico do NetBeans Patrick Keegan escreveu em seu blog sobre o beans binding (JSR-295). Neste artigo, ele explica como pesquisar registros em um aplicativo de banco de dados desktop utilizando mecanismos que existem no Swing e na biblioteca Beans Binding.</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>
        </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-06-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>