<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html><head>
  <meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
  <link rel="stylesheet" type="text/css" href="../../../netbeans.css" media="screen">
  <meta name="author" content="Tinuola Awopetu">
  <meta name="keywords" content="NetBeans IDE, NetBeans Platform, Open Source, Software Freedom Day">
  <title>NetBeans 6.8 no Sun Tech Days Brasil 2009</title>
</head><body>
<h1><img style="width: 118px; height: 110px;" alt="NetBeans 6.8 at Sun Tech Days Brazil" src="https://netbeans.org/images_www/brazil.png" align="right">Conheça já hoje o amanhã com o NetBeans 6.8 no Sun Tech Days Brazil!<br>
</h1>
        <br><br>
Você sabe há quanto tempo o NetBeans IDE e a Plataforma NetBeans "fala" português? A resposta é 3 anos! Desde o NetBeans 5.0 o IDE e a Plataforma foram localizados para o Português Brasileiro, inicialmente pela comunidade de <a href="brazil55-release.html">voluntários</a> e depois por uma equipe patrocinada pela Sun. Para a próxima versão do <a href="https://netbeans.org/community/releases/68/index_pt_BR.html">NetBeans 6.8</a> estará novamente disponível um download em Português Brasileiro, além de outros idiomas.<br>

<br>
Ao longo dos anos, o Projeto NetBeans tem recebido um enorme apoio da comunidade de desenvolvedores brasileiros, como tradutores, blogueiros, testadores de versão, correção de bugs, evangelistas, e muito mais. Como forma de dizer um "Muito Obrigado" à nossa vibrante comunidade de usuários e desenvolvedores no Brasil e para o lançamento do NetBeans 6.8 no <a href="http://www.suntechdays.com.br/agenda.html">Sun Tech Days Brasil 2009</a>, nós preparamos e traduzimos alguns recursos para dar aos nossos fãs brasileiros um guia rápido nesta incrível versão!<br>


<br>
<h2>NetBeans IDE 6.8 - Veja hoje o amanhã!</h2>
NetBeans 6.8 é o <span style="font-weight: bold;">primeiro</span> IDE a oferecer suporte completo à especificação Java EE 6 e à plataforma GlassFish Enterprise Server v3. A versão também vem com suporte ao PHP 5.3 e ao framework Symfony, C/C++, e inclui melhorias na integração com o Project Kenai, e muito mais.<br>
<br>
<a href="https://netbeans.org/downloads/6.8/index.html"><img alt="Download NetBeans IDE 6.8" src="../../images_www/v6/dl-nb-ide.gif" style="border: 0px solid ; width: 242px; height: 27px;"></a><br>
<br>
<ul>
  <li><a href="https://netbeans.org/community/releases/68/index_pt_BR.html">Conheça mais sobre o NetBeans IDE 6.8</a><br>
  </li>
  <li><a href="https://netbeans.org/community/releases/68/relnotes_pt_BR.html">Notas da versão do NetBeans IDE 6.8</a></li>
  <li><a href="https://netbeans.org/community/releases/68/install_pt_BR.html">Guia de instalação do NetBeans IDE 6.8</a><br>
  </li>

  <li><a href="https://netbeans.org/community/netcat/ca_survey_68.html">O NetBeans 6.8 está pronto para o FCS?</a> (Em inglês)</li>
</ul><br>

<h2>Novos tutoriais para o NetBeans IDE 6.8</h2>
<ul>
  <li><a href="https://netbeans.org/kb/docs/java/editor-codereference_pt_BR.html">Ajuda para codificação no Editor Java no NetBeans IDE: Um Guia de Referência</a></li>
  <li>
    <a href="https://netbeans.org/kb/docs/javaee/javaee-gettingstarted_pt_BR.html">Introdução aos aplicativos do Java EE 6</a><br>
</li>
  <li>
    <a href="https://netbeans.org/kb/docs/web/jsf20-support_pt_BR.html">Suporte para o JSF 2.0 no NetBeans IDE 6.8</a></li>
</ul><br>


<h2>Mantenha-se atualizado com o NetBeans News</h2>
<ul>
  <li><a href="https://netbeans.org/projects/www/lists">Inscreva-se</a> na edição brasileira do <a href="https://netbeans.org/community/news/newsletter/archive_pt_BR.html">Boletim Semanal do NetBeans</a> (<span style="font-style: italic;">Role a página para baixo e procure por </span><strong class="email">nbweekly_pt@netbeans.org</strong><span style="font-style: italic;">. Você precisa estar conectado com sua conta no netbeans.org para se inscrever.</span>)<br>
  </li>
  <li>Siga o <a href="http://twitter.com/netbeans">NetBeans no Twitter</a></li>
  <li>Ouça o <a href="http://blogs.sun.com/nbpodcast/">Podcast do NetBeans</a></li>
</ul><br>

<h2>Auditoria Financeira de um Estado Brasileiro na Plataforma NetBeans!<br>
</h2>
Você sabia que muitas aplicações populares em todo o mundo são construídas sobre a <a href="http://platform.netbeans.org/">Plataforma NetBeans</a>? Incluindo um software de gestão financeira utilizado pelo <a href="http://www.tce.to.gov.br/sitephp/">Tribunal de Contas do Estado do Tocantins</a>? Nesta entrevista com o brasileiro e desenvolvedor de software Paulo Canedo, veja porque Canedo e muitos outros desenvolvedores como ele passaram a contar com a arquitetura confiável e flexível da plataforma NetBeans para construir aplicativos Swing de forma rápida e fácil.<br>

<br>
(<span style="font-style: italic;">O artigo original e telas do sistema estão publicadas no <a href="http://netbeans.dzone.com/news/brazilian-state-financial">NetBeans Zone</a>.</span>)<br>
<br>
<h3>Oi Paulo, por favor conte-nos quem você é.</h3>
Meu nome é Paulo Canedo, sou brasileiro e nasci em Araguaína,
Tocantins, hoje moro em Palmas (capital do Tocantins). Me formei em
ciência da computação há 2 anos atrás. Atualmente estou trabalhando em
órgão público(TCE-TO) como desenvolvedor, provalvemente estarei mudando
de empresa em breve. Sou um entusiasta de open source e estou
procurando meu espaço no mundo da tecnologia.<br>
<br>
<h3>Você está criando uma aplicação para gerir informações contábeis
usando o NetBeans Platform. Por favor conte-nos o que esta aplicação
faz.</h3>
Bem, essa aplicação é muito específica, a empresa onde trabalho tem
como função fiscalizar os gastos com dinheiro público realizados em
unidades gestoras, para cada unidade gestora existem&nbsp; algumas
pessoas responsáveis pelas informações contábeis daquela unidade. A
aplicação baseada no NetBeans Platform que criamos serve para analisar
as informações e realizar uma pré checagem dos dados antes mesmo que
cheguem até nós, aliado a isso temos também um sistema de assinatura
digital para garantir que as informações foram enviadas por um
responsável daquela unidade, além de aumentar a segurança da transação
de dados.<br>
Os passos realizados por um usuário dessa aplicação são:<br>
<ol>
  <li>Pegar os dados xml gerados por uma terceira aplicação</li>
  <li>indicar: unidade gestora à qual pertencem esses dados, diretório do xml, período das informações</li>
  <li>realizar a análise de dados (por motivos de perfomance os dados xml são repassados para um banco derby e depois analisados)</li>
  <li>assinar digitalmente por um e-cpf</li>
  <li>enviar os arquivos xml via internet</li>
</ol><br>

<h3>Por quê vocês estão utilizando o NetBeans Platform como base para
esta aplicação? (Quais são as coisas que vocês consideram mais úteis?)</h3>
A primeira versão da aplicação tinha sido construída apenas com swing,
ao longo do tempo percebemos que perdíamos muito tempo cuidando de
detalhes que não interessavam a nós, além de a atualização do software
ser complicada. As coisas que achei mais úteis foram a programação
modular e praticidade no desenvolvimento.<br>
<br>
<h3>Como você começou com o NetBeans Platform (quando? qual o motivo que o levou a usá-lo?)</h3>
Algumas vezes eu via coisas sobre o NetBeans Platform em alguns blogs e
no próprio site do NetBeans, e pensei: "bom porque não usar o NetBeans
Platform?" Com ele não precisamos nos preocupar com coisas comuns de
aplicações desktops, além disso nosso problema de atualização será
resolvido, isso foi em maio de 2008.<br>
<br>
<h3>Quais são as principais APIs do NetBeans que vocês usam? Qual delas é a sua favorita?</h3>
A principal API que utilizamos é o componente wizzard, através dele
conseguimos criar uma UI (user interface) amigável para o usuário.
Nossas APIs favoritas são os sistemas de janela, atualização e wizzard.<br>
<br>
<h3>Você pode dar uma dica ou truque (talvez um trecho de código) para a utilização do NetBeans Platform?</h3>
Se você precisa criar uma aplicação extensível e não tem tempo para
perder com definições comuns de uma aplicação desktop, como por
exemplo, gerenciamento de atualização e janelas, acho interessante você
tentar o NetBeans Platform.<br>
<br>
<h3>A aplicação está em produção? Como vocês distribuem ela? O que os usuários acham da aplicação?</h3>
Sim, a aplicação está em produção. A aplicação pode ser baixada pelo <a href="http://www.tce.to.gov.br/sicap/">site da empresa</a>,
mas como eu disse anteriormente, é uma aplicação muito específica para
a empresa. Os usuários sempre comparam com a aplicação anterior que
existia e dizem: "esse aqui funciona bem e é simples de usar".<br>
<br>
<h3>Você pode dar algumas dicas de como iniciar com o NetBeans
Platform? (ex. Eu sou um novo usuário do NetBeans Platform, como eu
poderia iniciar?)</h3>
Visitar a seção "<a href="https://netbeans.org/kb/trails/platform.html">Getting started</a>" [2] no site do NetBeans, escrever os exemplos básicos, visitar o <a href="http://planetnetbeans.org/">planetnetbeans</a>, o <a href="http://blogs.sun.com/geertjan/">blog do Geertjan</a> :), um livro que recomendo: "Rich Client Programming - Plugging into the NetBeans Platform".<br>
<br>
<h3>Qual é o futuro da aplicação? (Quais características são planejadas para o próximo lançamento, quando será lançado?)</h3>
O futuro para esta aplicação é criar outros módulos para implantar
novas funcionalidades, possívelmente a primeira delas será um
questionário com assinatura digital, e para isso vamos novamente
utilizar o componente wizzard :). Ainda não existe data definida.<br>
<br>

<h3><span id="result_box" class="short_text"><span style="background-color: rgb(255, 255, 255);" title="Anything else you want to share?">Mais alguma coisa que deseja compartilhar?</span></span></h3>
Apenas gostaria de agradecer a oportunidade que você nos deu de contar sobre nosso projeto. Para conhecer mais sobre mim, por favor visite meu blog: <a href="http://paulocanedo.com.br/">paulocanedo.com.br</a><br>
<br>
<br>
<div style="text-align: right;"><span style="font-style: italic;">(Dezembro
2009)</span><br>
</div>
</body></html>
