
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
<head>
<title>NetBeans Weekly Newsletter, Issue # 1</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 # 1 - Mar 06, 2008
		</div>
	</div>
	<div id="content">
	
				<h1>Calendário</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=1623">Bolsa à inovadores do NetBeans</a></h2>
						<p style="margin-left:8px;"><img src='http://services.netbeans.org/appl2/show_image.php?id=734&column=image&table=story&type=image/pjpeg&db=xnetbeans&db_type=pear&id_col=story_id' 
		height='91' width='109' alt='image' style='float:left; margin-right:5px;margin-bottom:5px;'/>
						Você quer fazer aquele projeto dos seus sonhos uma realidade? Você veio ao lugar certo. O Bolsa à inovadores do NetBeans irá ajudá-lo a tornar suas ideias reais e vai contribuir com dinheiro vivo para ajudar a transformar seus projetos em realidade.

O Bolsa à inovadores do NetBeans faz parte da iniciativa da Sun Microsystems em distribuir USD$ 1 milhão à desenvolvedores de código aberto em todo o mundo para trabalhar nos seus projetos favoritos. Este projeto é liderado pela comunidade NetBeans e pelo NetBeans Dream Team.

Mas corra! O prazo para submissão dos projetos acaba na próxima sexta-feira, dia 7 de março.</p><br style="clear:both;"/>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=1624">NetBeans está na Segunda Batalha dos IDEs! (10 e 12 de março)</a></h2>
						<p style="margin-left:8px;">
						Se você perdeu a <a href="https://netbeans.org/community/articles/jugcologne-shootout-summary.html">batalha do último ano<a/> em Colonia, Alemanha, agora você tem uma nova chance de se divertir - desta vez na Itália! NetBeans estará  disputando com a JetBrains e a Oracle em Genova e Roma, Itália. Os evangelistas dos IDEs irão demonstrar e debater os méritos de suas ferramentas. Será que nosso Roman Strobl trará os louros este ano? Há apenas uma maneira de descobrir!</p>
					</div>
				<h1>Novidades do projeto</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=1625">Roman Strobl demonstra NetBeans e MySQL</a></h2>
						<p style="margin-left:8px;">
						MySQL, o popular banco de dados open-source, agora faz parte do portifólio de softwares da Sun. Nesta video-aula, veja uma rápida demonstração de como desenvolver aplicações dirigidas a bancos de dados com o NetBeans e utilizando o servidor do banco de dados MySQL.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=1634">Construa jogos para dispositivos moveis com o NetBeans 6.0 e Java ME para a Premiação Sueca de Jogos!</a></h2>
						<p style="margin-left:8px;">
						Aqui está uma outra oportunidade para você ganhar dinheiro utilizando o NetBeans – se você for um estudante Sueco. A <a href="http://gameawards.se/">Premiação Sueca de Jogos</a> incluiu uma categoria especial para os usuários do NetBeans 6.0 e Java ME. O prêmio extra é de 10000 SEK! A Premiação Sueca de Jogos é a maior competição de desenvolvimento de jogos para os estudantes Suecos.</p>
					</div>
				<h1>Comunidade</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=1633">Vinicius Senger: Suavizando a curva de aprendizado do Java com o NetBeans</a></h2>
						<p style="margin-left:8px;">
						Vinicius Senger, membro do <a href="">NetBeans Dream Team</a> é fundador da GlobalCode, a maior empresa de treinamento Java no Brasil, e o NetBeans recebe uma nota 11 dele como uma ferramenta ideal para ensinar e aprender Java. Descubra o porquê.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=1632">Ajude a definer o my.netbeans.org e receba uma camiseta NetBeans</a></h2>
						<p style="margin-left:8px;">
						Você faz parte do <a href="http://my.netbeans.org">my.netbeans.org</a>, nosso novo site de relacionamento em comunidade? Se não, crie seu
próprio perfil, adicione membros de comunidades existentes à sua rede de relaciomanto, mantenha-se atualizado com as últimas novidades, e gerencie um widget bem legal para colocar nas suas propriedades web.

O que vem depois? Nós gostaríamos de receber sua ajuda para definir o futuro do my.netbeans. Quais funcionalidades adicionais e personalizações você gostaria de ver no site e no widget? Quando você tiver uma sugestão, simplesmente clique no botão feedback. Se nós gostarmos da sua idéia você ganhará uma camiseta!</p>
					</div>
				<h1>Treinamento</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=1631">Criando uma aplicação web simples utilizando um banco de dados MySQL</a></h2>
						<p style="margin-left:8px;">
						Aprenda a criar uma aplicação web simples que conecta a um servidor de banco de dados MySQL. Este tutorial também cobre algumas idéias básicas e tecnologias no desenvolvimento web, como JavaServer Pages™ (JSP) e outros mais.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=1630">Criação fácil de sites web no NetBeans</a></h2>
						<p style="margin-left:8px;">
						Este tutorial para iniciantes mostra como é fácil criar websites com as características arrastar-e-soltar do NetBeans. Também mostra como  um novo desenvolvedor pode aprender a programação Java de maneira gradual adicionando JavaServer Pages (JSP), e outras funcionalidades ou programas que podem ser adicionados a um website.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=1629">Um cliente SOAP para Open Calais</a></h2>
						<p style="margin-left:8px;">
						Amit Kumar Saha guia você através do processo de criação de um cliente SOAP para o Open Calais. Você vai escrever um cliente Java SOAP simples, baseado em linha de comando para acessar um serviço web Open Calais. O conceito apresentado neste tutorial também é útil quando você escrever um cliente SOAP para qualquer outro serviço web.</p>
					</div>
				<h1>Blogs</h1>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=1628">Iniciando no Visual VM estendido (Parte 1 – 6)</a></h2>
						<p style="margin-left:8px;">
						O <a href="http://visualvm.dev.java.net/">Visual VM</a> é uma ferramenta de código aberto para monitoração e performance construído em cima da plataforma NetBeans. Geertjan Wielenga escreveu seis artigos em seu blog (e contando…) sobre o Visual VM estendido utilizando o NetBeans.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=1627">Componente Acordeão de Woodstock</a></h2>
						<p style="margin-left:8px;">
						James Branam escreveu sobre um novo componente para o Woodstock no NetBeans. Neste artigo, ele dá uma olhada  nos componentes Acordeão e Acordeão Tab. Em um artigo anterior, ele cobriu o componente <a href="http://blogs.sun.com/branajam/entry/woodstock_bubble_help_component ">Buble Help</a>.</p>
					</div>
				<div class="item">
				<h2><a href="http://services.netbeans.org/newsletter/story.php?id=1626">Módulo de visualização de classe para o NetBeans</a></h2>
						<p style="margin-left:8px;">
						Tim Boudreau criou um módulo que utiliza a biblioteca visual do NetBeans e a API de árvore do Javac para criar um gráfico do conteúdo de um arquivo Java, exibindo as dependências entre os membros da classe. O módulo está disponível na central de atualização da construção diária do NetBeans, e o Boudreau gostaria de receber um feedback.</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>
	<div id="footer">
		<div id="footer-text">
				Este boletim também é acessível em   <a href="https://netbeans.org/community/news/newsletter/2008-03-06_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>