13 setembro 2012

Mudanças de perspectivas em aplicações Android: evite recriar a Activity

Usuários de aplicativos em geral podem requerer mudar a orientação do aparelho para visualizar melhor os conteúdos sendo exibidos na tela. Dependendo do que está sendo visto é comum girar a orientação da tela para o sentido horizontal (landscape) ou sentido vertical (portrait).

(1) Tela em modo Portrait


Em aplicações Android e iOS (smartphones e tablets) é comum implementar telas que vão funcionar em diferentes perspectivas de orientação de tela. No entanto, programadores de Android precisam estar atentos que quando ocorrem mudanças de orientação no aplicativo, o comportamento padrão do Android recria a Activity em execução, chamando os métodos do ciclo de vida: onPause(), onStop(), onDestroy(), para em seguida chamar o método onCreate() novamente, além dos métodos do ciclo de vida: onStart() e onResume().



Problema / Solução
Se a tela atual da sua aplicação apenas desenha elementos visuais sem obter dados de fontes custosas (para memória em geral ou uso da Internet para baixar os dados), então esse procedimento padrão do Android não será um problema. Contudo, caso sua Activity requeira dados da internet ou algum outro tipo de esquema de processamento “mais pesado” para ser realizado, talvez seja necessário evitar recarregar a instância da Activity, mantendo o estado dos objetos carregados na memória. Desta forma podemos evitar consultar a rede novamente, além de otimizar o uso do processamento do aparelho, melhorando o consumo da bateria. :)

Esse comportamento pode ser realizado de 2 formas: (que eu conheço)
  1. Salvar os dados atuais (o estado atual) utilizando o mecanismo do ciclo de vida da Activity do Android, através dos métodos onSaveInstanceState(bundle) para salvar, e o onRetainNonConfigurationInstance() para recuperar os dados do estado atual;
  2. Alterar o comportamento default do Android, descrito acima, evitando que a Activity seja automaticamente recriada. Desta forma o Android apenas irá notificar Activity que ocorreu uma mudança de orientação, através do método onConfigurationChanged(Configuration c).
Neste post vou mostrar como podemos implementar abordagem (2), ou seja, como evitar que o Android recrie Activity do ciclo de vida do aplicativo.

Essa dica eu encontrei no site oficial do desenvolvedor Android. Está neste link: Handling Runtime Changes: http://developer.android.com/guide/topics/resources/runtime-changes.html

Vou descrever passo a passo:

Passo 1: altere o arquivo AndroidManifest.xml conforme o exemplo abaixo adicionando a propriedade chamada (android:configChanges="orientation|screenSize") da sua Activity:



    

    
        
            
                

                
            
        
    



Passo 2: implementar no código Java da sua Activity o método conforme exemplo:
package br.com.blogspot.profdouglas.dicas3.orientationchange;

import android.app.Activity;
import android.content.res.Configuration;
import android.os.Bundle;
import android.util.Log;
import android.view.Menu;
import android.widget.TextView;

public class OrientationChange extends Activity {

 @Override
 public void onCreate(Bundle savedInstanceState) {
  super.onCreate(savedInstanceState);
  setContentView(R.layout.activity_orientation_change);

  Log.d("DOUGLAS", "OrientationChange.onCreate");

  TextView orientationTextView = (TextView) findViewById(R.id.orientationTextView);

  // detect the current orientation
  int currentOrientation = getResources().getConfiguration().orientation;

  if (currentOrientation == Configuration.ORIENTATION_LANDSCAPE) {
   // setting orientation landscape
   orientationTextView.setText(R.string.orientation_landscape);

  } else if (currentOrientation == Configuration.ORIENTATION_PORTRAIT) {
   // setting orientation portrait
   orientationTextView.setText(R.string.orientation_portrait);
  }

 }

 @Override
 public boolean onCreateOptionsMenu(Menu menu) {
  getMenuInflater().inflate(R.menu.activity_orientation_change, menu);
  return true;
 }

 @Override
 protected void onStart() {
  super.onStart();
  Log.i("DOUGLAS", "OrientationChange.onStart");
 }

 @Override
 protected void onResume() {
  super.onResume();
  Log.i("DOUGLAS", "OrientationChange.onResume");
 }

 @Override
 protected void onStop() {
  super.onStop();
  Log.i("DOUGLAS", "OrientationChange.onStop");
 }

 @Override
 protected void onPause() {
  super.onPause();
  Log.i("DOUGLAS", "OrientationChange.onPause");
 }

 @Override
 protected void onDestroy() {
  super.onDestroy();
  Log.i("DOUGLAS", "OrientationChange.onDestroy");
 }

 /**
  * Caution: Beginning with Android 3.2 (API level 13), the "screen size"
  * also changes when the device switches between portrait and landscape
  * orientation. Thus, if you want to prevent runtime restarts due to
  * orientation change when developing for API level 13 or higher (as
  * declared by the minSdkVersion and targetSdkVersion attributes), you must
  * include the "screenSize" value in addition to the "orientation" value.
  * That is, you must decalare
  * android:configChanges="orientation|screenSize". However, if your
  * application targets API level 12 or lower, then your activity always
  * handles this configuration change itself (this configuration change does
  * not restart your activity, even when running on an Android 3.2 or higher
  * device).
  */
 @Override
 public void onConfigurationChanged(Configuration newConfig) {
  super.onConfigurationChanged(newConfig);
  Log.d("DOUGLAS", "MainActivity.onConfigurationChanged");

  TextView orientationTextView = (TextView) findViewById(R.id.orientationTextView);

  if (newConfig.orientation == Configuration.ORIENTATION_PORTRAIT) {
   Log.i("DOUGLAS",
     "MainActivity.onConfigurationChanged (ORIENTATION_PORTRAIT)");
   // setting orientation portrait
   orientationTextView.setText(R.string.orientation_portrait);

  } else if (newConfig.orientation == Configuration.ORIENTATION_LANDSCAPE) {
   Log.i("DOUGLAS",
     "MainActivity.onConfigurationChanged (ORIENTATION_LANDSCAPE)");
   orientationTextView.setText(R.string.orientation_landscape);
  }
 }

}


Observe o javadoc que deixei para que você entenda porque a propriedade do manifest precisou utilizar dois valores. A figura (2) demonstra o log (da view LogCat) demonstrando que a Activity não foi recriada, mas o método onConfigurationChanged foi notificado.

(2) Tela em modo Landscape sem recriar a Activity após mudar orientação


Conclusão
Ao executar seu aplicativo agora, quando ocorrer mudanças de orientação de tela sua Activity não será recriada e o método onConfigurationChanged será automaticamente notificada a cada mudança de orientação. 

Como sugestão, caso queira fazer algo específico para cada modo de orientação, pode-se usar a lógica da condição implementada no método, que atualmente possui instruções com logs. Dependendo do cenário no qual seu aplicativo está sendo usado, essa dica pode ser útil para você.

Assim que possível vou fazer uma vídeo aula sobre isso também e colocar aqui. O código fonte do exemplo do projeto pode ser baixado aqui.



30 agosto 2012

Aprenda a depurar (debugging) seu programa Java no Eclipse

Alguns anos atrás fiz um post relacionado sobre o processo de depuração no Eclipse. Desta vez resolvi criar uma vídeo aula para exemplificar o processo passo a passo.



No contexto de programação como podemos entender o que é a depuração e como fazê-la acontecer na prática? Quase sempre quando trabalho com novas turmas vejo uma grande maioria dos alunos ainda não utilizou esse precioso recurso do programador. O objetivo deste post é dar uma noção básica e mostrar como fazer na prática usando a IDE Eclipse. (fonte do post original Depuração no Eclipse (debugger))






Em resumo, depuração (do inglês debugging) é um processo de acompanhamento do programa a fim de acompanhar o fluxo de execução passo a passo, seguindo as linhas de codificação do ponto inicial até o ponto final do algoritmo que está sendo interpretado pelo computador.

Minha percepção do porquê depurar o código... 

Podemos acompanhar o ciclo de vida do aplicativo (do início ao fim), procurando verificar o valor de variáveis, de expressões, acessando métodos entre outras possibilidades.


"Na minha opinião a principal vantagem é permitir o acompanhamento em tempo real. Já resolvi muitos bugs em menor tempo por utilizar esse recurso. Na prática, percebemos nosso erro de lógica quando podemos entender o que o computador está fazendo em determinada situação. A maioria das vezes o erro é do próprio programador que não previu determinada situação. Ao perceber isso, com ajudada da depuração, temos mais probabilidade de corrigir o bug alterando a lógica do programa."

21 agosto 2012

Instalação e configuração do emulador Android SDK (com plugin ADT do Eclipse)


Neste post abordarei sobre a instalação do Android SDK e a instalação do plugin ADT para desenvolver com a IDE Eclipse, bem como algumas dicas para atualizações automáticas dos seus componentes.



Pré-requisitos para instalação e configuração dos ambientes:
1) Eclipse IDE (versão + recente) - usei a JUNE 4.2 de 32 bits;
2) Android SDK (versão + recente);
3) JDK 1.6 ou superior;
4) JRE (no path do SO)
5) Página com instruções para instalação do Plugin ADT

Configurações mínimas do hardware e software do sistema operacional

(1) Requisitos de sistema (fonte)


Inicialmente você deve baixar todos os programas indicados acima. Pode ser que você já tenha o interpretador Java (JRE), entretanto, vai precisar o JDK para programar para Android. Veja a figura (1) destacando que não basta a JRE.

Siga as dicas do vídeo ou então siga os passos seguintes:


  • Baixe o Eclipse IDE [pré-requisito é o item (1)];
  • Baixe e instale o Android (no caso do Mac OS é apenas um zip);
  • Rode o Eclipse e instale o plugin ADT (URL download abaixo):
https://dl-ssl.google.com/android/eclipse/
  • Baixe os pacotes do emulador Android (siga essas dicas);
  • Configure o Eclipse para fazer checagem automáticas de atualizações do plugin (veja o vídeo acima)
  • Crie um atalho para um emulador AVD (Android Virtual Device) (dicas aqui);
  • Rode o programa usando o Eclipse


Série: Android Dicas (no youtube)
Este vídeo faz parte de uma série que estou fazendo sobre dicas Android (no YouTube). O link da série está aqui. http://www.youtube.com/playlist?list=PL5EFD4E0D0D24F43E

14 agosto 2012

Criação de Janelas Gráficas (GUI) com NetBeans (sobre a série vídeo aulas)

Neste post comento da série que chamei de Curso Básico de Criação de Janelas Gráficas (GUI) com NetBeans, que foi produzido um total de 10 vídeo aulas, contabilizando 2h:12m:30s de conteúdos para o YouTube, inteiramente gratuito.  No final deste post tem o link para baixar o código fonte.



Foi a minha primeira experiência na produção de vídeos para a internet e creio que aprendi muito. Recebi vários feedbacks de pessoas que nem conheço, no qual fico muito agradecido e motivado a tentar melhorar. Tenha certeza que nos próximos vídeos eu levarei em consideração as dicas sugeridas nos comentários de vocês, bem como espero contribuir cada vez mais nesta iniciativa.

Meus agradecimentos a todos que contribuem e contribuíram. Lembrem-se que é ajudando que se é ajudado, não é mesmo? :)

Um pouco sobre a série... 

Esta série de vídeo aulas objetiva ajudar alunos da disciplina de Programação Orientada a Objetos entender como criar janelas visuais usando NetBeans.

Endereço da série no canal do YouTube (com os 10 vídeos):
http://www.youtube.com/playlist?list=PLEA1EF325BD74F0E7

Endereço para baixar o projeto completo (versão do NetBeans 7.1.2 ou superior):
https://sites.google.com/site/douglasfrari/arquivos/SistemaCadastroProdutos.zip


09 agosto 2012

Criando atalhos para geração de LOGs no Android usando templates do editor de código da IDE Eclipse


Este post objetiva compartilhar uma dica simples para geração de logs, que permitiu aumentar a produtividade na programação durante a realização desta atividade. Trata-se do uso do editor de templates do Eclipse para geração de código automático (famoso Ctrl+space+template



Tenho hábito e prática de utilizar logs na programação. De forma simples, isso nada mais é do que prover uma saída de dados textual na tela do console para visualizar o fluxo atual em execução no programa. Assim, podemos de forma rápida comprovar nossas hipóteses que o algoritmo está se comportando exatamente como o imaginamos. J Isso não é lindo? Para termos certeza que tudo vai correr bem é necessário fazer esse tipo de processo de validação N vezes até que tenhamos certeza absoluta que vai funcionar.

Geralmente através de testes de unidade, ou simplesmente para constatar se os comandos dados e as ordens programadas (formalmente escritas na forma de código fonte) foram percorridos como se esperava dentro do programa em execução, permitindo estruturar e validar o percurso do algoritmo e da lógica de programação como um todo. Dependendo da complexidade do software, podemos criar cenários não desejados – conhecidos como bugs. Nem tudo é perfeito minha gente! J

Percebo também que eu não sou o único que tem esse hábito de usar logs. Todos os programadores que conheço fazem isso.  Fazer logs é uma boa prática. No entanto, para fazê-lo precisamos escrever uma linha de código utilizando a criatividade, que varia de programador para programador. Se perder o controle e ficar criando log de tudo, pode poluir demasiadamente o código com comentários inúteis ou não mais necessários. Normalmente se usa algo como isso:

System.out.println(“*Classe*.metodo() - comentário opcional”);
System.out.println(“TelaCadastroCliente.salvar() – registrando dados ...”);

Na prática temos um exemplo concreto sem padrão algum, apenas para ver o valor da variável na saída:

public class Teste {
       static char caracter = 170;
      
       public static void main(String[] args) {
             
              System.out.println("valor = "+caracter);
              System.out.println("valor (int) = "+(int)caracter);
       }
}

Escrever a linha de comando System.out.println usando o Eclipse se torna fácil quando conhecemos o nome que chama o template para preenchimento automático. Por exemplo, se eu digitar “sysout + (Crtl+SPACE), o editor do Eclipse irá substituir a palavra “sysout” pelo comando System.out.println(), e ainda deixar o cursor dentro dos parênteses. Para quem não sabe você acabou de usar o template de código do editor Eclipse para códigos da linguagem Java. Isso não é show de bola? Os programadores sabem que isso torna o trabalho mais eficaz. Eu pelo menos me sinto muito animado quando uso editores assim.

Criando templates para geração de LOG automático para uso no emulador Android

O SDK do emulador Android oferece a saída de dados usando a janela do LogCat (Windows/Show View/Other/Android/LogCat), que fica disponível após instalar o plugin ADT. Nesta janela podemos visualizar os logs de acordo com o seu nível. Veja a tabela:

Nível
Sigla
Cor
Debug
D
azul
Verbose
V
preto
Info - Informação
I
verde
Warn - alerta
W
laranja
Error - erro
E
vermelho
Níveis de logs e suas cores

Assim, no Android temos que usar a classe android.util.Log para escrever os logs de acordo com os níveis disponíveis da tabela. Temos então no código:

Por exemplo, vamos criar o código abaixo e sua tecla de atalho correspondente:
Exemplo uso android.util.Log
Nome do Atalho pretendido
Log.d("SUA_TAG", "log DEBUG");
dbg
Log.i("DOUGLAS", "log INFORMATION");
dbgi
Log.e("DOUGLAS", "log ERROR");
dbge


Crie as tags acima no Eclipse usando uma tecla de atalho

Acesse a opção de preferências no menu principal do Eclipse, no caso do sistema operacional ser o Windows, use o atalho Windows/Preferences/. Na figura abaixo (A), observe o campo para digitar a busca. Digite o termo “templates” para filtrar a quantidade de opções disponíveis. Veja a imagem (B). Acesse opção Java/Editor/Templates/


(A)

(B)



Agora basta inserir novas entradas clicando no botão “New...”. (B) Crie 3 ou mais entradas de acordo com o código abaixo. Veja também a imagem (C).

(C)


Name
Description
Pattern
dbg

Log.DEBUG level (default)

Log.d("DOUGLAS","${enclosing_type}.${enclosing_method}${cursor}");

dbgi
Log.INFORMATION level
Log.i("DOUGLAS","${enclosing_type}.${enclosing_method}${cursor}");
dbge
Log.ERROR level
Log.e("DOUGLAS","${enclosing_type}.${enclosing_method}${cursor}");

Esse código é uma linguagem de expressão do Eclipse e faz com que o nome da classe atual seja obtida ( ${enclosing_type} ), e o nome do método atual seja obtido e substituído (${enclosing_method} ), e por fim, sete o cursor para o final deste comentário ( ${cursor} ).  Se desejar poderá criar outros templates estudando essa linguagem de expressão do Eclipse.



Após criar seus templates poderá utilizá-los durante a codificação do seu aplicativo no Android, e usar as teclas de atalho criadas. Ex. digite dbg + (Crtl+Space) e poderá ver as opções disponíveis do template. Assim que escolher um, o código será gerado automaticamente obtendo o nome da classe, o nome do método e você poderá ainda testar seu código neste trecho sem a necessidade de digitar todo o código.



Espero que essa dica seja útil para você tanto quanto está sendo para mim. J

13 junho 2012

Conceito de Encapsulamento em POO (java)

Oi pessoal! Antes de mais nada, se desejar me seguir no twitter está aqui (@douglasddf)

Neste post vou comentar o conceito chamado Encapsulamento relativo a programação orientada a objetos (POO). Observem as perguntas iniciais:
  1. Por que encapsular informações em nosso programa? 
  2. Como fazemos isso na prática usando Java?
  3. É realmente necessário encapsular?

Essas questões são abordadas no vídeo que fiz (veja abaixo) para tentar responder as duas primeiras perguntas acima. Porém, a terceira pergunta é mais difícil de explicar. Alguém poderia dar uma resposta ou opinar sobre isso?






Encapsulamento, segundo Wikipédia (fonte: http://pt.wikipedia.org/wiki/Encapsulamento):
"Encapsulamento vem de encapsular, que em programação orientada a objetos significa separar o programa em partes, o mais isoladas possível. A idéia é tornar o software mais flexível, fácil de modificar e de criar novas implementações."
Ou seja, é uma forma de tornar visível para o usuário as funcionalidades que são importante para o sistema e somente isso. Em nosso exemplo, temos a classe Cliente que na prática, adicionou o tipo de acesso private do Java nos atributos e o tipo de acesso público nos métodos da classe. Só que foram criados um par de métodos (GET e SET) para recuperar e alterar, respectivamente, para cada atributo.

public class Cliente {

 // atributos para representar o cliente com acesso PRIVATE
 private String nome;
 private String CPF;
 private int quantidadePedidos;

 // para que se possa acessar os dados, criamos métodos PÚBLICOS get e set
 // para
 // cada atributo que se pretenda dar esse acesso

 /**
  * @return the nome
  */
 public String getNome() {
  return nome;
 }

 /**
  * @return the cPF
  */
 public String getCPF() {
  return CPF;
 }

 /**
  * @return the quantidadePedidos
  */
 public int getQuantidadePedidos() {
  return quantidadePedidos;
 }

 /**
  * @param nome the nome to set
  */
 public void setNome(String nome) {
  this.nome = nome;
 }

 /**
  * @param cPF the cPF to set
  */
 public void setCPF(String cPF) {
  CPF = cPF;
 }

 /**
  * @param quantidadePedidos the quantidadePedidos to set
  */
 public void setQuantidadePedidos(int quantidadePedidos) {
  this.quantidadePedidos = quantidadePedidos;
 }
 
 // operacoes que o cliente poderá
 // fazer neste sistema
 public void efetuarPedidoCompra() {
  System.out.println("efetuando pedido de compra");
  quantidadePedidos++;
 }

 // imprimir os seus valores
 @Override
 public String toString() {
  String atributosClasse = "Nome: " + nome + ", CPF: " + CPF
    + " , quantidade pedidos: " + quantidadePedidos;
  return atributosClasse;
 }

}


Isso simplesmente porque ao mudar o tipo de acesso aos atributos o Java não terá mais acesso a referência direta para LER e ESCREVER. Logo, temos que criar métodos para cada atributo GET e SET (sujestão de nome do Java). Desta maneira, quando precisarmos acessar (LER) o atributo do objeto usaremos:

  Cliente c = new Cliente();
  // acesso para ESCREVER (write)
  c.setNome("Douglas Frari"); 
  c.setCPF("222.222.222.11");
  
  // acesso para LER (read)
  System.out.println("Nome: "+c.getNome());
  System.out.println("CPF: "+c.getCPF());
  
  
  // ACESSO direto NAO é permitido pelo comilador java 
  // se não for da mesma classe. Logo, é preciso usar os SETs neste caso
  c.nome = "Douglas Frari";
  c.CPF = "222.222.222.11";
  

E quanto a pergunta 3 (É realmente necessário encapsular?)

É importante perceber que não é necessário encapsular para que o programa funcione. Mas é uma boa prática SIM encapsular os dados (atributos), pois assim tornamos o acesso DIRETO às referências dos objetos "seguros" do ponto de visto de escrita e leitura. O acesso somente será permitido usando os métodos públicos GET e SET.

25 maio 2012

Série sobre Programação Orientada a Objetos com Java (POO) (+ códigos fonte)

AULA 02 - Programação Orientada a Objetos - (POO)


Antes de mais nada, se deseja acompanhar meu twitter é só me seguir. Se preferir, sugiro acompanhar o canal no YouTube.


  • Você sabe codificar sem uma IDE?
  • Você sabe compilar sem o Eclipse? 
  • Sabe rodar sem o NetBeans?
  • Sabe definir uma classe?
  • Compreende as diferenças de usar uma classe pronta da linguagem Java e definir a sua própria? 
  • O que os objetos tem haver com isso?

Assista, pratique e descubra! :)


Objetivos vistos na aula 2:


1 - Entender o conceito de classe;
- discutido na aula 1;

2 - Criar uma classe para fazer algo;
2.1) mostrar na prática classe chamada Teste
2.2 - escrever na saída de dados um texto qualquer;
2.3 - Entender o processo Codificar/Compilar/Executar sem IDE :)















import java.util.Date;

public class Teste {

 public static void main(String[] argumentos) {

  // o programa ira comecar por essa classe

  System.out.println("Oi JAVA!! ");

  Date dataAtual = new Date();
  System.out.println("Data Atual é: " + dataAtual.toString());

  // criar um cliente
  // criar um objeto do tipo Cliente
  Cliente cliente1;
  cliente1 = new Cliente();
  cliente1.nome = "Douglas Frari";
  cliente1.CPF = "721.XXX.XXX.XX";
  cliente1.efetuarPedidoCompra();
  cliente1.efetuarPedidoCompra();
  cliente1.efetuarPedidoCompra();
  cliente1.efetuarPedidoCompra();
  
  // definicao do objeto
  Cliente cliente2;
  // instanciando objeto cliente
  cliente2 = new Cliente();
  
  // escrita no objeto (write)
  cliente2.nome = "Maria Eduarda";
  cliente2.CPF = "543.323.321.12";

  System.out.println("Nome do cliente 1: " + cliente1.toString());

  System.out.println("Nome do cliente 2: " + cliente2.toString());

 }

}




public class Cliente {


 // atributos para representar 
 // um cliente no sistema ATUAL
 String nome;
 String CPF;
 int quantidadePedidos;
 

 // operacoes que o cliente poderá
 // fazer neste sistema
 void efetuarPedidoCompra() {
  System.out.println("efetuando pedido de compra");
  quantidadePedidos++;
 }
 
 // imprimir os seus valores
 @Override
 public String toString() {
  String atributosClasse = "Nome: " + nome + ", CPF: " + CPF+
    " , quantidade pedidos: "+quantidadePedidos;
  return atributosClasse;
 }
 
 

}
Conclusão parcial Programar sem uma IDE é essencial. É claro que utilizar IDE torna o trabalho mais produtivo e a ideia é exatamente essa. Porém, como pretende ser um bom programador se não compreender o que essas ferramentas fazem sem que você perceba? Outro aspecto destacado foi o uso de classes em duas abordagens distintas. Veremos mais sobre isso nos próximas aulas. O código fonte refere-se as aulas 2, 3, 4 e 5. Porém, somente publiquei até o momento de hoje a aula 2. Em breve mais!

23 maio 2012

Programação Orientada a Objetos (POO) com JAVA

Apresento a todos a nova série de video-aulas sobre Programação Orientada a Objetos (POO).



Objetivos da série

  • Entender os principais conceitos de POO;
  • Aplicar os conceitos na linguagem Java;
  • Conceitos POO
    • Classes
    • Objetos
    • Encapsulamento
    • Herança
    • Polimorfismo


Perguntas iniciais

  1. Por que programação?
  2. Por que temos que codificar classes?
  3. Temos que entender de objetos?


As respostas dessas perguntas são discutidas no primeiro vídeo.


Os códigos fontes serão postados por aqui em breve. Na primeira aula discutimos o porquê precisamos codificar coisas na forma de Classes e utilizar Objetos.

Envie suas dúvidas pelo formulário:
http://migre.me/9aGqN (via googledocs)

17 maio 2012

8 ANOS como programador++

Hoje é um dia especial para mim. Estou completando 8 anos trabalhando na empresa mais legal do mundo (C.E.S.A.R). E se você pensa que estou exagerando é porque não sabes como me sinto em relação a isso!

Pois bem. Vou expressar aqui com minhas próprias palavras um pouco o porquê digo isso:

Em 11 de agosto de 2008 eu publiquei esse post:
A motivação no dia a dia: seja lá qual o seu trabalho...

Em 10 de setembro de 2009, publiquei um post:
Aviso de defesa de dissertação de mestrado (CIn/UFPE)

Em 30 de novembro de 2010, postei:
C.E.S.A.R vence Prêmio Finep 2010

No dia primeiro de março de 2011 estava bem resolvido com o Amor, então escrevi:
Feito amor

Em 29 de setembro de 2011, escrevi:
Caminho para ensinar programação ! ?

No ano de 2012, no dia 17/02/2012:
O Programador Pragmático (The Pragmatic programmer)

Recentemente, produzi e estou ainda produzindo coisas diferentes, como:
Curso Básico Criação Janelas Gráficas (GUI) com NetBeans (no YouTube)


E que tal trabalhar enquanto escuto um Podcast de empreendedorismo Nerd?


Onde eu estava quando fazia tudo isso (quase ao mesmo tempo)? 
Eu estava trabalhando na melhor empresa do mundo. Eu estou na empresa que me proporciona desafios aos problemas relevantes (alguns nem tantos), mas são SEMPRE bons PROBLEMAS para resolver. Só preciso torná-los úteis para aprender com eles

Conheça o C.E.S.A.R e venha trabalhar aqui!





Então, como vejo no geral a rotina


import java.util.ArrayList;

/**
 * 
 * @author Douglas Frari
 */
public class DiaADiaCesar {
    
    // as oportunidades sao compartilhadas
    public static ArrayList listaOportunidades = 
            new ArrayList();
    
    public static void main(String[] oportunidades) {
        
        if (oportunidades!=null && oportunidades.length > 0) {
            // estou VENDO oportunidades para aprender
            for (int i = 0; i < oportunidades.length; i++) {
                listaOportunidades.add(new Oportunidade(oportunidades[i]));                   
            }
        }
        
        // bater ponto de entrada no CESAR
        int horasProdutivas = 7;
        int horasInterativas = 1; // as vezes mais ou menos
        boolean queroContinuarTrabalhando = true;
        
        do {            
            
            fazerOquePrecisaSerFeito(horasProdutivas); // foco no problema
        
            interagirComPessoas(horasInterativas); // interações com colegas
        
            // 1 hora = 3 600 000 milisegundos
            Thread.sleep(3600000); 

            // o tempo passou ...
            horasProdutivas--;
            horasInterativas--;
            
            queroContinuarTrabalhando = vouContinuarMaisUmTempoTrabalhando();
            
        } while (queroContinuarTrabalhando);
        
        
        // bater ponto de saída / hora de sair da empresa
        
        if (listaOportunidades.size() > 0) {
            
            // que aprendizados eu tive hoje?
            // o que eu fiz de legal hoje?
            // como farei para resolver o problema?
            
            // etc.
            
        }
        
    }
    
}

Como vou iniciar o programa? 

 #java DiaADiaCesar oportunidade1 oportunidade2 oportunidadeX 

Cada um cria as suas próprias oportunidades ou não. Mas se criá-las, sei que no final terei aprendido melhor e isso me dá motivação extra para fazer muitas outras coisas que tenho vontade.

14 maio 2012

Criação de Interfaces Gráficas Java no NetBeans (com video-aulas)

Oi pessoal,

Estou fazendo umas video-aulas para novatos em programação ou para quem deseja utilizar o NetBeans para criação de telas visuais. Melhore sua produtividade! :)


18 fevereiro 2012

O programador pragmático (posts)

Estou testando um novo servidor de hospedagem de posts de blog no wordpress. Fiz dois posts sobre o livro de O Programador Pragmático. Creio que vale a pena você comprar esse livro. Confira:



Andy Hunt Video Talk Pragmatic Thinking from Ismael Marin on Vimeo.


O Programador Pragmático (The Pragmatic programmer)


Quero deixar uma dica de leitura para programadores ou profissionais de computação em geral. Trata-se do livro “O Programador Pragmático“, no qual pode-se perceber a qualidade do conteúdo com dicas sábias, preciosas e verdadeiras sobre a área de informática.



O Programador Pragmático (cap. 1)


Como relatei no post anterior, o livro do programador pragmático é uma leitura excelente para reflexões sobre o cotidiano da programação. Mas qual é o perfil do programador pragmático?

15 fevereiro 2012

Dicas básicas para desenvolvedores Bada (samsung/c++)

Me pediram para dar umas dicas para programadores iniciantes com Bada, então resolvi compartilhar um resumo aqui. Coisa muito simples mas que acho importante "ficar ligado".


Dicas:

  • Baixar e instalar o SDK Bada (já estará integrado com Eclipse);
  • Estudar os exemplos do SDK (importe para o projeto pela view ‘Bada SDK Samples’);
  • Rode o exemplo ‘UiControls’ que possui diversos usos de comportamentos padrões dos componentes mais comuns para aplicações visuais; Estude o código fonte;
  • Crie o hábito de ler o HELP do Eclipse (do SDK Bada) e usar o search do eclipse para consultar as APIs (as bibliotecas estão bem documentadas e têm exemplos de código).



Principais sites sugeridos:

[1] Bada Developer Site - http://developer.bada.com (oficial)

[2] Forúm Não Oficial - http://www.badadev.com/ (vários exemplos de uso prático com códigos comentados)

[3] Novidades Bada 2.0 - http://developer.bada.com/article/Whats-new-in-bada-2-0