Java on Peczenyj's Blog

Closures em Java - Parte 2

Mon, 11 Aug 2008 10:48:00 -0300

Ainda sobre a Closures do java 7, agora será possivel fazer isso:

public class A {
 public static void main(String args[]) {
 @Shared int acumulador = 0;

 {int => int } xxx = { int i => acumulador += i; i};

 System.out.println(xxx.invoke(1));
 System.out.println(xxx.invoke(2));
 System.out.println(xxx.invoke(3));
 System.out.println("o valor do acumulador eh " + acumulador );

 }
}

Só eu estou achando divertido?

http://gafter.blogspot.com/2008/08/java-closures-prototype-feature.html

Comments

Tiago Peczenyj

Não dá ideia!!

Logo aparece um @Global da vida... ;-)

Marcelo Martins

Fiquei com medo que tu falasse que era uma "variavel global"

hehe

Tiago Peczenyj

Martins, sem o @Shared o codigo compila mas gera um warning. É uma marcação que a variavel é compartilhada com outra closure ou bloco de código.

Marcelo Martins

O que que vem a ser aquele @shared?

Fabio Nascimento

Pois é, a única dúvida é como ele faz o autoboxing escondido(leia-se por debaixo dos panos)?
Mas no geral, tbm estou gostando, vamos ver... quando chegar a hora do SDK implementar isso de verdade mesmo.

Té +

Closures em Java

Fri, 08 Aug 2008 19:23:00 -0300

Olha o que vai ter no java 1.7

public class A {
 public static void main(String args[]) {
 exec( { int a, int b => a + b });
 exec( { int a, int b => a * b });
 exec( { int a, int b => 
 System.out.println("closure " + a + ":" + b); 
 (a * a) + (b * b) 
 });
 }
 public static void exec({ int, int => int } closure){
 System.out.println(closure.invoke(3,2));
 }
}

$ java -Xbootclasspath/p:./closures-2008-08-04/lib/closures.jar A
5
6
closure 3:2
13

Divertido :)

Fonte:
http://guj.com.br/posts/list/99477.java

Comments

Tiago Peczenyj

Hehehe... bizarro mesmo sera quando o java tiver suporte a pipes, sinais e outras coisas do mundo shell/C/*nix.

Imagina uma classe fazendo um TRAP... hehehe!

La Batalema Pitonisto

Tenho muito medo disso!

[]'s
Cacilhas, La Batalema

Voltas às Aulas e o Java - parte 2

Thu, 07 Aug 2008 17:43:00 -0300

Existe o clássico problema de determinar se um aluno passou ou não de ano quando são informados as notas e o número de faltas.

Vejamos:
1) O número de faltas é acima do permitido?. Aqui entra um if dos bons com uma comparação numérica, quando um número é maior ou igual a outro.
2) A média é basicamente somar as X notas e dividir por X (se for média aritmética). Somar e dividir são operações matemáticas básicas.

Uma forma de fazer é:

 if( numero_de_faltas > maximo_de_faltas_toleradas) {
 // reprovado por faltas
} else if ( media_do_aluno < media_para_passar ){
 // reprovado por nota
} 
// se nem um nem outro, esta aprovado

O ruim dessa abordagem é que o aluno estar aprovado é uma condição "que sobra". Se passarmos a focar a aprovação do mesmo ficaria assim:

 if( media_do_aluno >= media_para_passar && numero_de_faltas <= maximo_de_faltas_toleradas) {
 // aprovado!
} else {
 // reprovado!
}

É claro que eu posso que eu posso querer saber o motivo pelo qual o aluno foi reprovado:

 if( media_do_aluno >= media_para_passar && numero_de_faltas <= maximo_de_faltas_toleradas) {
 // aprovado!
} else if(numero_de_faltas > maximo_de_faltas_toleradas){
 // reprovado pelo número de faltas: ignoro a média.
} else {
 // aqui só sobra a reprovação por nota, 
 // basta fazer a tabela-verdade dessas expressões
}

Se o foco do professor for o algoritmo, isso é o que deveria ser analisado. Quem implementa corretamente um método que recebe X notas e um número de faltas e consegue responder a essas perguntas consegue descrever facilmente os casos de teste para verificar se a implementação corresponde ao que se espera.

Um programa que tenha algum tipo de interação (seja Swing ou console) ajuda a fazer um macarrão de código, mesclando o algoritmo com o controle de estado dos "menuzinhos". No fim vemos laços de repetição aonde não são necessários, calculo de média errado, etc.

Ok, não acho que um marinheiro de primeira viagem devesse começar por JUnit, mas uma com boa noção dos fundamentos da linguagem e evitando a interação desnecessária com o usuario (poderia ser usado até os parâmetros do main), acredito num melhor desempenho. O risco é o aluno acreditar que java é dificil ou que tudo se resume a getters/setters e gigantescos try/catch's onde as exceptions são varridas pra debaixo do tapete.

Eu colocaria TDD num segundo momento, mas ai sem perdão, ensinando o caboclo a fazer do jeito certo o quanto antes. O que é dificil se eles conseguem passar sem saber fazer aritmética básica.

Test Driven Development - parte 1.

Wed, 06 Aug 2008 14:31:00 -0300

Veja este código:

 public void testEhPar() throws Exception{
 assertTrue("2 deve ser par",algoritmo.ehPar(2));
 assertTrue("4 deve ser par",algoritmo.ehPar(4));
 assertTrue("6 deve ser par",algoritmo.ehPar(6));
 
 assertTrue("1 NAO deve ser par",!algoritmo.ehPar(1));
 assertTrue("3 NAO deve ser par",!algoritmo.ehPar(3));
 assertTrue("5 NAO deve ser par",!algoritmo.ehPar(5)); 
 }

Dentro de uma classe de teste, usando o framework JUnit, a leitura dessas linhas é a seguinte:

Eu tenho um objeto chamado algortimo.
A chamada algoritmo.ehPar(2) deve retornar true, pois 2 é par, e este método informa se o parâmetro informado é, ou não, par.
O método assertTrue recebe dois parâmetros: uma mensagem informando o significado deste teste, e o resultado do mesmo.

Se o método estivesse com algum problema e retornasse false, isso:

assertTrue("2 deve ser par",algoritmo.ehPar(2));

seria o mesmo que

assertTrue("2 deve ser par",false);

Logo, o teste falha, pois 2 deve ser par.

Esta é uma forma programática de garantir o comportamento do código que eu desenvolvo: testando. Se o meu método só depende dos parâmetros informados, é muito simples verificar o seu funcionamento.

Desenvolvendo os testes antes de implementar o código, tendo apenas as assinaturas dos métodos (por isso recorri a uma interface aqui, lembra?), eu posso pensar nos comportamentos esperados e, então, vou desenvolvendo até que todos os testes estejam passando.

Não é nada fácil, funciona melhor quando o projeto que estás desenvolvendo está começando, porém os resultados são excelentes: veja o quanto de tempo estás economizando! Se tu pretendes determinar se um código teu está funcionando por programas que perguntam os valores, escrever

$ ant clean test

é muito mais rápido!

O problema surge quando queremos fazer algo complexo, pois a dificuldade de testar mostra problemas na arquitetura adotada, por exemplo. Quanto temos objetos que tem objetos, herança, polimorfismo, tecnicas mais avançadas podem ser usadas como usar Mocks de objetos (e prover os mecanismos para injetar estes Mocks).

No caso desse exemplo, esta é uma solução:

public boolean ehPar(int numero){
 return numero % 2 == 0;
}

Muitos alunos desconhecem as operações de divisão e módulo entre inteiros. O 1, inteiro, dividido por 2, inteiro, não é 0.5, (em java), e sim 0, pois este é o resultado da divisão inteira. O resto da divisão, simbolizado por %, retorna 1. Dessa forma, o resto da divisão de um numero par por 2 é 0, caso contrario é um número inteiro. São operações básicas que precisam ser dominadas. Repare que eu fiz um código que funcione, não tentei nada mais maquiavélico que dê 0.0001 milissegundos mais rápido. Evite a otimização precoce.

Programar profissionalmente é uma tarefa de muita responsabilidade. Desenvolver testes para garantir a qualidade provê excelentes resultados a longo prazo.

Comments

Tiago Peczenyj

Sim sim, escrevi errado!

OLP

"caso contrario é um número inteiro" não seria "caso contrario o numero é impar" ?

Voltas às Aulas e o Java

Mon, 04 Aug 2008 12:20:00 -0300

Na época de volta às aulas nas faculdades percebe-se uma grande invasão de alunos desesperados em foruns de informática para resolverem os seus execícios. É facil reconhecer um aluno em pânico com o seu primeiro while ou algum exercício sobre Fibonacci: eles não tentam, simplesmente colam o enunciado do problema esperando a resposta pronta.

Entretanto tão bizarro quanto são os exercícios propostos: um programa que leia pergunte 2 numeros e retorne a soma, ou um programa para calcular alguma coisa que pergunte ao usuário... perai, pergunte? Um programa perguntando? Como?

Este é o típico programa 'interativo' com o usuário. Quando não usa a entrada padrão (algo completamente misterioso para boa parte dos alunos), usam algum recurso SWING. Mas sera que ninguem pensa o quão PREJUDICIAL são estes exercícios?

Normalmente o aluno se preocupa com a apresentação do mesmo, fazendo frescuras de menuzinhos, asteriscos pra lá e pra cá... e o algoritmo que é bom nada. Sinceramente: dane-se os menuzinhos. Sabem quantos programas com menuzinhos e que vão perguntar alguma coisa pro usuario vcs vão fazer na vida profissional de vcs? 0! Zero! Nenhum!

Existem muitas formas de interação com o usuario, hoje em dia vc pode ter interfaces web, por exemplo. Eu acho que, num primeiro momento, a única interação com o usuario deveria ser escrever na tela. Nada mais que isso se o camarada não sabe o que significa um NullPointerException.

Exemplo pratico:

- Prepare um diretório para trabalhar (suponho que vc vai usar linux, senão deve ser facil portar este exemplo para outros sistemas operacionais).
- Crie um diretorio lib e copie o junit-4.4.jar pra lá (use o google pra baixar esse arquivo, se vc não conseguir saia do curso de informática).
- Crie a estrutura abaixo, ainda no diretório de trabalho:
src/java
src/test
- Instale o aplicativo ant (de novo o google te ajuda, alias vc tem algum JDK instalado, certo??).
- Crie um arquivo chamado build.xml no diretorio de trabalho.
- Baixe o arquivo ant-junit.jar daqui [ http://www.java2s.com/Code/Jar/ANT/Downloadantjunitjar.htm ] e copie o .JAR para ~/.ant/lib (se não existe, crie).

Agora vem a proposta: baseado nessa interface:

public interface Algoritmo{
/* dado um numero, retorna true se for par */ 
boolean ehPar(int numero);
/* calcula o valor absoluto ou modulo de um numero, ex: -1 vira 1, 1 vira 1 */
int calculaModulo(int numero);
/* calcula algum termo da série de fibonacci: se 0, mostra o primeiro, se 1 mostra o segundo...*/
int calculaFibonacci(int elemento);
/* calcula o fatorial do numero indicado */
long calculaFatorial(int numero);
}

Vais criar uma classe chamada, digamos, SuaClasse que implementa esta interface (percebeu que tudo deve ficar em src/java não é?). Não pense na implementação dessa classe ainda.

No diretorio src/test vc vai salvar esta classe:

import junit.framework.TestCase;

public class AlgoritmoTeste extends TestCase{
 Algoritmo algoritmo;
 public void setUp(){
 algoritmo = new SuaClasse();
 }
 
 public void tearDown(){
 algoritmo = null; 
 }
 
 public void testEhPar() throws Exception{
 assertTrue("2 deve ser par",algoritmo.ehPar(2));
 assertTrue("4 deve ser par",algoritmo.ehPar(4));
 assertTrue("6 deve ser par",algoritmo.ehPar(6));
 
 assertTrue("1 NAO deve ser par",!algoritmo.ehPar(1));
 assertTrue("3 NAO deve ser par",!algoritmo.ehPar(3));
 assertTrue("5 NAO deve ser par",!algoritmo.ehPar(5)); 
 }
 
 public void testCalculaModulo() throws Exception{
 assertTrue("modulo de 3 deve ser 3",algoritmo.calculaModulo(3) == 3);
 assertTrue("modulo de -3 deve ser 3",algoritmo.calculaModulo(-3) == 3);
 assertTrue("modulo de 5 deve ser 5",algoritmo.calculaModulo(5) == 5);
 assertTrue("modulo de -5 deve ser 5",algoritmo.calculaModulo(-5) == 5); 
 }
 
 public void testCalculaFibonacci() throws Exception{
 assertTrue("elemento 0 da serie fibonacci deve ser 0",algoritmo.calculaFibonacci(0) == 0);
 assertTrue("elemento 1 da serie fibonacci deve ser 1",algoritmo.calculaFibonacci(1) == 1);
 assertTrue("elemento 2 da serie fibonacci deve ser 1",algoritmo.calculaFibonacci(2) == 1);
 assertTrue("elemento 3 da serie fibonacci deve ser 2",algoritmo.calculaFibonacci(3) == 2); 
 assertTrue("elemento 4 da serie fibonacci deve ser 3",algoritmo.calculaFibonacci(4) == 3);
 assertTrue("elemento 5 da serie fibonacci deve ser 5",algoritmo.calculaFibonacci(5) == 5);
 assertTrue("elemento 6 da serie fibonacci deve ser 8",algoritmo.calculaFibonacci(6) == 8);
 assertTrue("elemento 7 da serie fibonacci deve ser 13",algoritmo.calculaFibonacci(7) == 13); 
 assertTrue("elemento 11 da serie fibonacci deve ser 89",algoritmo.calculaFibonacci(11) == 89);
 assertTrue("elemento 13 da serie fibonacci deve ser 223",algoritmo.calculaFibonacci(13) == 233); 
 }
 
 public void testCalculaFatorial() throws Exception{
 assertTrue("Fatorial de 1 deve ser 1",algoritmo.calculaFatorial(1) == 1);
 assertTrue("Fatorial de 2 deve ser 2",algoritmo.calculaFatorial(2) == 2);
 assertTrue("Fatorial de 3 deve ser 6",algoritmo.calculaFatorial(3) == 6);
 assertTrue("Fatorial de 4 deve ser 24",algoritmo.calculaFatorial(4) == 24);
 assertTrue("Fatorial de 5 deve ser 120",algoritmo.calculaFatorial(5) == 120);
 assertTrue("Fatorial de 6 deve ser 720",algoritmo.calculaFatorial(6) == 720);
 assertTrue("Fatorial de 10 deve ser 3628800L",algoritmo.calculaFatorial(10) == 3628800L); 
 }
}

Uma ideia sobre o JUnit pode ser encontrada aqui: [ http://guj.com.br/java.tutorial.artigo.40.1.guj ], alias o guj, na sessão de tutoriais, explica varias coisas, é ótimo material de referência!

Ok, vc tem a interface que vc deve respeitar e um arquivo de teste. Vamos falar do arquivo de build do ant.

<project name="Meu Projeto" basedir="." default="dist">
 <description>
 Aprendendo a fazer um build.xml para o ant
 </description>

 <property name="lib" location="lib"/>
 <property name="src" location="src/java"/>
 <property name="test" location="src/test"/>

 <property name="build" location="build"/>
 <property name="dist" location="dist"/>

 <path id="classpath.test"> 
 <pathelement location="${test}" />
 <pathelement location="${build}" />
 <pathelement location="${lib}/junit-4.4.jar" />
 </path>

 <target name="init">
 <!-- Create the time stamp -->
 <tstamp/>
 <!-- Create the build directory structure used by compile -->
 <mkdir dir="${build}"/>
 </target>

 <target name="compile" depends="init" description="compile the source " >
 <!-- Compile the java code from ${src} into ${build} -->
 <javac srcdir="${src}" destdir="${build}"/>
 </target>

 <target name="dist" depends="compile" description="generate the distribution" >
 <!-- Create the distribution directory -->
 <mkdir dir="${dist}/lib"/>

 <!-- Put everything in ${build} into the MyProject-${DSTAMP}.jar file -->
 <jar jarfile="${dist}/lib/Algortimo-${DSTAMP}.jar" basedir="${build}"/>
 </target>

 <target name="clean" description="clean up" >
 <!-- Delete the ${build} and ${dist} directory trees -->
 <delete dir="${build}"/>
 <delete dir="${dist}"/>
 </target>

 <target name="test" depends="compile">
 <javac srcdir="${test}">
 <classpath refid="classpath.test"/>
 </javac>
 <junit>
 <classpath refid="classpath.test" />
 <formatter type="brief" usefile="false" />
 <test name="AlgoritmoTeste"/>
 </junit>
 </target>
</project>

A utilização desse arquivo é muito simples, não se amedronte pelo tamanho do arquivo, o formato xml do ant é bizarro e verboso, sou muito mais um Makefile, porém uma vez com ele feito basta ir adicionando coisas "com cuidado". Sem falar que tudo tem documentação oficial cheia de exemplos, só não aprende quem não quer.

$ ant
isso deve compilar a sua classe e gerar um jar (pode ser util no futuro).

$ ant clean
limpa os diretorios que vc acabou de criar com as suas paradas compiladas.

$ ant test
compila e executa os testes unítarios.

É claro que vc vai dizer, e agora??? Bom, veja isso:

public class SuaClasse implements Algoritmo{
 public boolean ehPar(int numero){return false;}
 public int calculaModulo(int numero){ return -1;}
 public int calculaFibonacci(int elemento){return -1;}
 public long calculaFatorial(int numero){return -1;}
}

Olha que legal! Uma classe que tem o minimo pra compilar! Agora vamos testar...

$ ant test
Buildfile: build.xml

init:
 [mkdir] Created dir: /home/GLOBO.COM/peczenyj/test/junit/build

compile:
 [javac] Compiling 2 source files to /home/GLOBO.COM/peczenyj/test/junit/build

test:
 [javac] Compiling 1 source file
 [junit] Testsuite: AlgoritmoTeste
 [junit] Tests run: 4, Failures: 4, Errors: 0, Time elapsed: 0.005 sec
 [junit] 
 [junit] Testcase: testEhPar(AlgoritmoTeste): FAILED
 [junit] 2 deve ser par
 [junit] junit.framework.AssertionFailedError: 2 deve ser par
 [junit] at AlgoritmoTeste.testEhPar(Unknown Source)
 [junit] 
 [junit] 
 [junit] Testcase: testCalculaModulo(AlgoritmoTeste): FAILED
 [junit] modulo de 3 deve ser 3
 [junit] junit.framework.AssertionFailedError: modulo de 3 deve ser 3
 [junit] at AlgoritmoTeste.testCalculaModulo(Unknown Source)
 [junit] 
 [junit] 
 [junit] Testcase: testCalculaFibonacci(AlgoritmoTeste): FAILED
 [junit] elemento 0 da serie fibonacci deve ser 0
 [junit] junit.framework.AssertionFailedError: elemento 0 da serie fibonacci deve ser 0
 [junit] at AlgoritmoTeste.testCalculaFibonacci(Unknown Source)
 [junit] 
 [junit] 
 [junit] Testcase: testCalculaFatorial(AlgoritmoTeste): FAILED
 [junit] Fatorial de 1 deve ser 1
 [junit] junit.framework.AssertionFailedError: Fatorial de 1 deve ser 1
 [junit] at AlgoritmoTeste.testCalculaFatorial(Unknown Source)
 [junit] 
 [junit] 
 [junit] Test AlgoritmoTeste FAILED

BUILD SUCCESSFUL
Total time: 1 second

Agora basta escrever codigo de verdade na SuaClasse e testar, estara pronto quando TUDO estiver passando. São 4 métodos básicos, sabendo lidar com variaveis locais, if e for, vc consegue muita coisa.

Se eu fosse professor eu daria exercícios assim: o projeto deveria compilar e todos os testes deveriam passar senão o aluno leva 0. A nota viria de acordo com o que eu espero, posso usar um EMMA e ver a cobertura de código, posso avaliar a presença de um Javadoc que preste, etc.

Enfim, eu seria um professor muito malvado }-)

Não perca a parte 2 aqui, e uma introdução ao TDD aqui.

Comments

Marcelo

Muito bom o post, parabéns. Na minha opinião todo professor poderia ser "ruim" desse jeito.

Rafael Ponte

Excelente post, parabéns!

Infelizmente muitos professores se preocupam mais com telinhas e "firulas" do que o que é importante na disciplina, pior é que muitos destes professores nunca nem ouviram falar sobre TDD ou mesmo testes unitários!

Guilherme Gall

Está aí uma coisa que sempre achei errado e vi acontecer várias vezes com mais de um professor onde estudo: o cara começa ensinando bibliotecas para desenvolvimento de aplicações gráficas e detalhes específicos de determinada linguagem para uma galera que não sabe nada (e quando digo que não sabe nada digo que não sabem nem definir o termo) de algoritmos, ou herança e polimorfismo por exemplo.

Terminam as matérias que envolvem programação sabendo como fazer sobrecarga de operadores, mas implementando toda a lógica de um programa dentro de uma única classe com métodos static. Sabem fazer janelas com botões bonitinhos, mas se matam para implementar a lógica do programa.

Ficaria feliz se minha primeira aula de programação fosse no esquema do seu post. Sempre gostei de brincar com os exercícios propostos em sala, mas o cara era tão inflexível que certo dia veio me pedir para trocar de editor de texto, porque o que eu estava utilizando era complicado demais (vim) e me confundiria (wtf?). Tive aulas bastante boas depois, com um cara que valorizava o que é realmente essencial, mas alguns de meus colegas não tiveram a mesma sorte e continuaram tendo aulas desse tipo durante vários semestres.

Triste é ver o camarada que me pediu para trocar de editor de texto sendo citado como "excelente professor para quem está começando". :-|

Tiago Peczenyj

É aquilo, ou se aprende por necessidade ou pq se gosta da parada. Eu propus algo que, se alguem gosta de programar, vai se amarrar em fazer.

Mas tem quem cague pra isso. Paciência, depois vai pegar um estágio onde vai ter que fazer algo muito pior e sem internet pra poder postar as dúvidas!

tiago_stos

Concordo como Roger, professor que faz aluno pensar e aprender algo útil é visto como professor ruim, que não sabe ensinar. Caso verídico de um professor do semestre passado.

Interessante notar que alguns professores que fazem os alunos pensarem mas ensino coisas inúteis não tem fama tão ruim...

Agora, Tiago, vc deveria dar aulas para alguns professores sobre como ensinar de verdade... hehe

Muito bom.

Roger Leite

É Tiago, você seria um professor malvado e muito odiado, porque, seguindo a experiência acadêmica que tive, todo professor que ensina algo útil, e faz os alunos pensarem, geralmente caem naquela listinha (de troca de professor) que vai pra secretaria.

Pelo menos foi isso que eu vi acontecer. :(

De qualquer maneira, concordo com o seu post, e se um dia eu der aula, vou seguir a dica !

CMilfont

Tiago, a academia não é para você. Você seria uam vergonha para seus colegas de "d[e]ocência".
Onde já se viu utilizar Junit, ant e essas bizarrices em sala de aula?
Cadê o bom e velho pascal? [engraçado que tem aluno do 5º semestre ainda chamando de pascoal]
Cadê os System.out.println que todo sistema de vergonha tem?
:)
Tirando a brincadeira, muito bom seu artigo!

Tiago Peczenyj

Falta o convite de alguma instituição de ensino, de preferência uma que não dê bola pras tais "Certificações".

Rafael Carneiro

Você já está indo no caminho correto... quando será professor mesmo? :-)

Tiago Peczenyj

Tenho que dar o primeiro exemplo }-)

Tiago Albineli Motta

Pra mim você está sendo bonzinho, pois você escreveu os testes pros alunos. Assim fica mole.

Sobre o "ensino" de Java hoje em dia.

Thu, 06 Mar 2008 08:22:00 -0300

Java é uma linguagem orientada a objetos que contem tipos primitivos e wrappers para estes tipos, é executada sobre uma maquina virtual, com suporte a herança simples mas possui interfaces, com mecanismos de sobreescrita e sobrecarga de métodos, com um sistema de tratamento de exceções que te obriga a tratar determinadas situações e por ai vai.

Ao meu ver o estudo da linguagem deveria focar o domínio do mecanismo de herança e a construção de classes, domínio dos métodos, tipos de retorno, escopos de variavel, conversão de tipos, domínio das estruturas condicionais, de loops e de tratamento de erros, domínio das operações matemáticas e lógicas e,principalmente, domínio da classe String (ok, domínio pode ser uma palavra forte, talvez uma boa noção fosse suficiente em algumas situações).

Com disso tudo, o aluno deveria primeiro trabalhar com argumentos de linha de comando (o que vc acha que o main recebe?), depois passar a estudar a leitura e escrita em arquivo texto e, por fim, leitura pela entrada padrão.

Pois leitura pela entrada padrão é o que vc menos vai fazer em Java. Ninguem faz programa com menuzinho em Java pra console no mercado. Temos coisas mais complexas pela frente e sem conhecer tudo aquilo que eu listei antes só é possivel fazer gambiarras (como as famosas class functions, gigantescos métodos que fazem centenas de coisas com nomes adequados do tipo createTree3).

Ensina-se Java ao contrário: primeiro o camarada programa como se fosse C, perdendo tempo em fazer menus e estruturas de controle pois o usuario pode ter dado um enter, tab, "ç" ou ter digitado algo inválido quando deveria aprender os fundamentos da linguagem. Cria-se vícios que pode ser custoso para remover (como encher o código de getters/setters sem necessidade). A prova disso é que invariavelmente temos comparação de Strings usando o operador == quando deveria ser utilizado os métodos adequados para isso (imagina o susto quando a galera descobre o equalsIgnoreCase).

Eu vejo muitos estudantes incapazes de compilar e executar uma classe (o famoso hello world) pois os mesmos nunca fizeram uso da linha de comando muito menos foram apresentados ao conceito de classpath. Vejo barbaridades típicas de quem não conhece (ou não sabe ler) o javadoc das classes básicas. Fico me perguntando quando esses jovens serão capazes de ler um "Effective Java", por exemplo.

Aqui tem um excelente começo.

Espero que os professores acordem para essa realidade e que os alunos percebam que estão sendo prejudicados e passem a estudar por sua conta os tópicos necessários para sair arrasando pro ai.

Comments

Guilherme

O problema é que esses tais sistemas distribuídos não existem em qualquer lugar como se fala, e as pessoas frequentemente usam objetos fantoches independente da situação. Os sistemas distribuídos acabaram virando uma "desculpa" para os "objetos burros" existirem...

paulo

tem tda razão ferhr, mas no caso do sistema distribuido estamos falando de Data Transfer Objects (DTOs). É o caso que é necessario o fantochismo (as vezes da ate pra colocar alguma funcionalidade neles... mas é raro)

ferhr

(aliás, todo problema gerado por quaisquer linguagens de programação é o abuso).

ferhr

Também vejo problemas com abuso. Neste caso, concordo plenamente.

Mas também não vejo problemas com certos fantochismos, principalmente quando você tem que tratar um objeto (ou seria neste caso "dados"?) em sistemas distribuídos ou usando duas, três linguagens diferentes.

Tiago Peczenyj

Ao invés de criar um objeto cheio de get/set desnecessário, poderiamos preparar interfaces fluentes, como no exemplo do Chapiewski.

paulo

o problema está escrito la, chegou a ler o post? Voce deixa de programar orientado a objetos pra programar estruturado.

value objects nunca precisaram obrigatoriamente de getters e setters. alias, value objects imutaveis sao muito mais interessantes.

getters e setters não fazem encapsulamento por si só, isso é uma ilusão! as vezes muito pelo contrario: voce acaba expondo atributos que nao deveria expor: deveria ter criado métodos para trabalhar com esses atributos, em vez de apenas fornecer um simples par de getter e setter. Esse é o mais que conhecido anti pattern do dominio de modelo anemico:

http://www.guj.com.br/posts/list/75388.java

Seus objetos acabam virando fantoches:
http://www.fragmental.com.br/wiki/index.php?title=Fantoches

Em nenhum momento falei para nunca utilizar getter e setters, o problema é seu abuso. quem vem de linguagem estruturada e esta comecando com orientacao a objetos, costuma abusar demais disso, deixando seu sistema identico a um nao orientado a objetos.

ferhr

> fehr, usar getters e setters gerados, como
> voce falou, é muito perigoso e pode gerar
> um dominio muito fraco. os objetos podem
> passar a ser apenas estruturinhas de dados:

ValueObjects / encapsulação, anyone? E qual o problema de alguns objetos serem apenas "estruturinhas de dados"? Nenhum. Depende da aplicação, da idéia. Não há bala de prata.

paulo

Oi Tiago! Agradeço o link para o blog da Caelum. Nos tentamos seguir essa linha de pensamento, focar no que é realmente importante: interfaces, polimorfismo, reescrita de método, encapsulamento. Alias, quando mostramos java.util e java.io, damos mais atencao para o bom uso das interfaces e polimorfismo desses pacotes do que a API em si. Saber fazer um bom design é o que é fundamental.

fehr, usar getters e setters gerados, como voce falou, é muito perigoso e pode gerar um dominio muito fraco. os objetos podem passar a ser apenas estruturinhas de dados:

http://blog.caelum.com.br/2006/09/14/nao-aprender-oo-getters-e-setters/

e atraves de reflection da sim para manipular os atributos, sem necessidade dos getter e setters, nao vejo reflection como motivacao para o uso dos getters e setters.

Daniel Wildt

Tiago, belo post. Eu vejo ser necessário ensinar o aluno que java não é dependente de uma IDE como ocorre com algumas outras linguagens de programação. Passo pelo menos 3 aulas trabalhando diretamente na linha de comando e usando um editor de texto sem sintax highlight. E desde o início trabalho identação de código fonte, organização de código fonte, enfim, o programador tem que entender a base do processo e tem que saber aplicar isto para qualquer outra linguagem de programação que venha a aprender.

Ainda, que você não precisa de uma IDE com 5000 plug-ins para ter produtividade. Deve achar o que te deixa produtivo, como disse o Vitor Pamplona.

E principalmente, focar no ensino de orientação a objetos. Criar classes, entender composição e herança, saber diferenciar uma classe abstrata de uma interface. Gosto de trabalhar todos os princípios para que um aluno possa ler um livro sobre design patterns e saber como construir aquilo, porque ele entende orientação a objetos, e não porque sabe java.

Já vi aluno meu reclamar que não consegue aprender patterns porque o material que passei não era em java.

O Urubatan já falou em um post dele que aprender uma linguagem de programação deveria ser um processo rápido. Concordo com isto e no meu entendimento isto está relacionado a sua habilidade de abstração e de entender como as linguagens orientadas a objetos funcionam.

Eu aqui fico pensando em como estes profissionais que hoje tem problemas vão evoluir para novas linguagens de programação e assim manter a própria empregabilidade em alta.

Será culpa somente do aluno ou também é culpa do professor?

Como professor, me considero um cara muito chato e deixo claro sempre para os alunos que não existe melhor linguagem de programação. Semestre passado em uma disciplina de desenvolvimento para web, ensinei ASP.NET, Java Server Faces e Ruby on Rails. Só que antes disto trabalhei muito o que envolve desenvolver para a internet.

Ufa, ficou longo o comentário... :-)

Ana Carolina

Oi Tiago.

Concordo totalmente contigo.
Trabalho com cursos e também disciplinas de cursos técnicos e sei que não adianta começar com a parte prática sem a parte teórica, e também não adianta o objetivo ser "conquistar o mundo", é com exemplos simples, mastigados e várias atividades que se consegue base para um bom profissional. Depois disso é que podemos aprofundar o assunto e abordar tópicos mais avançados.

Ah! E não é só Java.
Tenho muito aluno que vem dizendo que "eu sei trabalhar com banco de dados" e na verdade usou o Access e nem sabe o que é uma view.

Quando surge o incêndio, é a teoria que te ajuda.

Se o aluno aprende primeiro "na mão", da forma mais trabalhosa e programando em modo texto, com certeza depois ele pode ir pra uma interface gráfica, mas o contrário não é verdadeiro.

Conheço um "professor" de Linguagem C que não sabia que um for() pode ser infinito heheheh

Por esses problemas é que eu sou contra estes cursos muito curtos que ensinam "tudo" e não ensinam os fundamentos das coisas.

É por essas e outras que quem trabalha com TI sofre tanto preconceito. Todos os anos vários "fabricantes de gambiarras" aparecem por aí (mas eles não tem muito sucesso, não se preocupe! heheheh)

Um forte abraço.

Ana Carolina
http://anacarol.blog.br

ferhr

No início (bem no início, há mais de dez anos) via a questão dos getters/setters com muita desconfiança.

No entanto é fácil de criá-los, nem que seja através de geração de código.

Sem eles, entretanto, fica difícil fazer certas coisas com reflexão e afins.

Analise Orientada a Objetos com Java - Parte 1

Sat, 17 Nov 2007 15:02:00 -0300

Estes dias eu me deparei com um problema bem interessante: uma forma de atribuir professores a disciplinas por meio de um sistema feito em Java.

Já aviso, estou tentando aprender e achei este exemplo interessante. Este post é uma tentativa de análise orientada à objetos feita de forma progressiva, comentários são bem vindos.

A primeira proposta foram 2 matrizes bidimensionais, uma com os professores disponíveis naquele dia e outra com as turmas, distribuidas ao longo de uma semana. Eu logo percebi que isso podia ser um problema de modelagem, pois se vc vai utilizar matrizes, paineis, interface textual ou seja lá o que for, isto é apenas uma camada - a visão. Um modelo muito mais rico pode ser criado, vejamos este exemplo em Java:

class Professor{}
class Disciplina{}
class Turma{
 Disciplina disciplina;
 Professor professor;
}
public class Main{
 public static void main(String[] args) {
 Professor oseias = new Professor();
 Disciplina matematica = new Disciplina();
 Turma matA = new Turma();
 
 matA.disciplina = matematica;
 matA.professor = oseias;
 }
}

A minha classe Main mostra como seriam as operações sobre estas 3 classes. Basicamente eu tenho uma classe Professor, uma classe Disciplina e uma classe Turma. Se vc observarem qualquer instituição de ensino vão perceber que uma turma tem-um professor e tem-uma disciplina associados (composição).

Percebam também que eu não fui até uma escola ou universidade e fiquei horas levantando requisitos, criado diagramas uml ou documentos no word - apenas criei uma casca inicial de código (cheio de problemas por sinal). Também não me importo, ainda, com nenhum aspecto temporal. Sem falar que esta escola todos os professores podem dar qualquer disciplina - agora vamos implementar direito.

Vejamos... uma turma não troca de disciplina facilmente, mas de professor sim. Faz sentido, então, ter um setter de professor e um construtor que receba uma disciplina. Outra coisa, eu não defini nada nas outras classes, então está na hora de definir 2 atributos : id (numérico) e nome (String). Vou diferenciar os objetos pelo código, isto é, o seu id, e o nome será utilizado como descrição. Vou sobreescrever os métodos equals e toString.

Como o nome desses objetos é importante, vou coloca-los no construtor também (assim como o id).

class Professor{
 long id;
 private String nome;
 public Professor(long id,String nome){
 this.id = id;
 this.nome = nome;
 }
 public long getId(){ return id; }
 public String toString(){ return this.nome ; }
 public boolean equals(Object o){
 boolean test = false;

 if (!(o instanceof Professor))
 test = super.equals(o);
 else 
 test = ((Professor) o).getId() == this.id; 
 return test;
 } 
}
class Disciplina{
 long id;
 private String nome;
 public Disciplina(long id,String nome){
 this.id = id;
 this.nome = nome;
 }
 public long getId(){ return id; }
 public String toString(){ return this.nome ; }
 public boolean equals(Object o){
 boolean test = false;

 if (!(o instanceof Disciplina))
 test = super.equals(o);
 else 
 test = ((Disciplina) o).getId() == this.id; 
 return test;
 }
}
class Turma{
 long id;
 private String nome;
 private Disciplina disciplina;
 private Professor professor;
 public Turma(long id, String nome,Disciplina disciplina){
 this.id = id;
 this.nome = nome;
 this.disciplina = disciplina;
 }
 public void setProfessor(Professor professor){
 this.professor = professor;
 }
 public long getId(){ return id; }
 public String toString(){ 
 return this.nome + " [" + this.disciplina 
 + "] c/ " + this.professor ; 
 }
 public boolean equals(Object o){
 boolean test = false;

 if (!(o instanceof Turma))
 test = super.equals(o);
 else 
 test = ((Turma) o).getId() == this.id; 
 return test;
 } 
}
public class Main {
 public static void main(String[] args) {
 /* objetos bem comportados */
 Professor oseias = new Professor(1L,"Oseias");
 Disciplina matematica = new Disciplina(1L,"Matematica");
 Turma matA = new Turma(1L,"Matematica A", matematica);
 matA.setProfessor(oseias); 
 
 System.out.println("Professor " + oseias); 
 System.out.println("Disciplina " + matematica); 
 System.out.println("Turma " + matA);
 
 /* objetos mal comportados 
 * Sujeitos a NullPointerException */
 Professor juca = new Professor(2L,null);
 Disciplina calculo = new Disciplina(2L,null);
 Turma matB = new Turma(2L,"Matematica B", null);
 matB.setProfessor(null); // nem precisava mas...
 Turma matC = new Turma(3L,"Matematica C",calculo); 
 Turma matD = new Turma(4L,"Matematica D",calculo);
 matD.setProfessor(juca);
 
 System.out.println("Juca? " + juca);
 System.out.println("Calculo?" + calculo);
 System.out.println("matB? " + matB); 
 System.out.println("matC? " + matC);
 System.out.println("matD? " + matD);
 }
}

Mas que raios eu estou fazendo? veja a saída desse programa:

Professor Oseias
Disciplina Matematica
Turma Matematica A [Matematica] c/ Oseias
Juca? null
Calculo?null
matB? Matematica B [null] c/ null
matC? Matematica C [null] c/ null
matD? Matematica D [null] c/ null

Qual o significado? Bom... eu tenho uma forma razoavel de representar um professor, disciplina e turma, porém não é pratico, o construtor está gigante e, em muitas situações, eu posso ter parâmetros nulos, o que pode ser uma fonte de problemas. Existem muitas formas de refatorar estas classes, eu nem toquei no HashCode, enfim, tem muito pano pra manga.

Apresento a vcs o desenvolvimento em etapas, iterativo. Eu estou chutando requisitos aos poucos, é verdade, mas eu entrego um codigo testável e completo e cada ciclo. Com os usuarios testando esse código (nesse caso, uma API, mas enfim...) eu obtenho um feedback interessante. O que vc acha?

Comments

NetWalker

Saudações, sir Peczenyj. :)
Muito boa a abordagem da análise.
Java, como sempre, usual e prático no que diz respeito a conceitos de orientação a objeto (a não ser herança múlt... ops, heim? alguém disse algo? ah bom... :D ).
Pois bem, quero ver a segunda parte pra descobrir o que pretende com esses construtores.
No mais, já que Professores e Disciplinas são apenas referenciados em Turmas, e têm a sua existência independente destas, ainda acredito que a relação seria uma Agregação. E não Composição, como citou.
Voltando... Vc descreveu o problema como possuindo o objetivo de atribuir professores às disciplinas. Tem alguma restrição ou regra geral que o problema define e pretende seguir (disponibilidade, horários, etc)? Ou continuará o foco em relacionar professores e disciplinas sem maiores restrições?
Então é isso, continue o bom trabalho de sempre.
Abraço.
Até +.

Marcio

Eu acho que você deveria usar um problema mais complexo como exemplo e ver se isso realmente funciona. Seu exemplo é bem simples e todo mundo conhece o domínio (estou deduzindo que você estudou e fez faculdade :))

Acho que não é necessário coletar todos os requisitos possíveis e modelar todos os detalhes do sistema, mas é quase obrigatório um estudo do domínio e um design, nem que seja um rascunho, do sistema. Os outros detalhes surgirão com a implementação. :)

[]'s

Aprenda Java com os melhores versão Tropa de Elite

Sun, 30 Sep 2007 21:01:00 -0300

Exatamente: Não vem com essa que vc é istudante, vai tomar tapa na cara se não aprender Java. Saiba que, de cada 100, só 5 terminam o curso. Nem na Sun se treina programador assim.

/*
* O Bope foi criado para atuar quando a policia perde o controle
* E no rio de janeiro isso acontece com bastante frequencia
*/
class Bope{
 
 private String nome; 
 private int vitimas;
 
 public Bope(String nome){
 this.nome = nome;
 this.vitimas =0;
 }
 
 public void matou(int tantas_vitimas_agora){ 
 this.vitimas = this.vitimas + tantas_vitimas_agora;
 }
 
 public int quantas_vitimas(){
 return this.vitimas;
 }
}

public class Programa{
 public static void main(String [] xxx){
 // Apresento o capitão nascimento
 Bope capitao = new Bope("Capitao Nascimento");
 
 // quando o capitão sobe a favela, é pra matar, não pra morrer
 capitao.matou(1000);
 
 // agora ele subiu o morro de novo, com ele não tem erro.
 capitao.matou(2000);
 
 // e a farda dele não é azul, é PRETA
 System.out.println("O Bope matou: " + capitao.quantas_vitimas());
 }
}

Entendeu? Não?

ENTÃO PEDE PRA SAIR, GUERREIRO!
TU É CORRUPTO, TEU LUGAR É COM .NET, É COM VB! JOCKEY DE IDE! PEDE PRA SAIR AGORA!

Comments

RIC@RDO

Te puxou em Peczenyj!!
Essa ficou muito boa!!!

gto

hahah!
Nunca tinha comentado por aqui, mas leio as vezes. Dessa vez me obriguei a comentar.

Vou te dizer, pra ficar bem ao estilo do bope, com direito a caveirão e tudo mais, só faltava um método "ondeTaOBaianoPorra" :D

E claro, as ameaças com vouTeMostrarOSaco e pegaAVassoura...

uh!

[]'s!

NetWalker

Fala Peczenyj.
Estamos na mesma, só na base das descrições.
Agora, "Jokey de IDE" foi PHoda. LOL
Nunca tinha achado uma expressão que casasse tão bem. (com o jeito do Capitão Nascimento claro) :D
Isso inspira a fazer um do senado.
Difícil é que nunca sairia da prioridade mais alta (e com imunidade a kills).
Farewell. :)

Tiago Peczenyj

Acontece que o Capitão Nascimento aprendeu C primeiro, eu até tentei corrigir isso mas ele me ameaçou, disse q eu era moleque.

E não vi o filme ainda, me alimento das descrições eletrizadas dos meus colegas de trabalho :)

Edson

Assistiu ao filme na versão oficial (na única sala que o passa em Jundiaí) ou foi em piratão mesmo?
Tem de tomar um tapa no ouvido mesmo, que "quantas_vitimas" é o jeito C de falar, e BOPE que se preza fala em Java ("quantasVitimas") :P

rsfair

Nada como comentários para facilitar o entendimento do programa :)

JEDI - Java Education and Development Initiative

Sat, 18 Aug 2007 15:22:00 -0300

JEDI e o ensino de Java gratuito

Iniciado pela Universidade das Filipinas e apoiado pela Sun Microsystems, nasce através do Java Research & Development Center, a iniciativa JEDI (Java Education and Development Initiative), em Fevereiro de 2005.

A partir desta data, o JEDI vem sendo desenvolvido como um projeto colaborativo, que conta com o apoio da comunidade Java em todo o mundo. Tem como principais objetivos o de melhorar a experiência do ensino e da aprendizagem; Aumentar a qualidade dos graduados em Ciência da Computação e Tecnologia da Informação (disponibilizando os materiais de seus cursos gratuitamente para quem se interessar); Aumentar o banco de especialistas em Java e, Fornecer serviços e produtos a altura das necessidades do mercado mundial.

Tecnologia Java

A tecnologia Java está presente, hoje, em 2 bilhões de dispositivos tecnológicos em todo o planeta - e também fora dele, já que podemos localizar dispositivos Java rodando até em Marte. Existem hoje, no mundo, cerca de 579 milhões de celulares com Java, 93 operadoras de telefonia móvel, 750 milhões de cartões SmartCard (do tipo JavaCard) distribuídos, 650 milhões de computadores pessoais e com 2 milhões de cópias da plataforma empresarial J2EE. Por isto, 68% das novas aplicações, hoje, são desenvolvidas em Java, que substituiu o C++ como a competência mais procurada pelos profissionais. É executado em múltiplas plataformas e em uma ampla gama de dispositivos, indo de um pequeno chip em SmartCards aos servidores dos Grandes Data Centers.

Demanda por Profissionais

Com tudo isso, existe hoje, uma demanda por 2 milhões de novos profissionais de TI a cada ano. Desenvolvedores Java, devem prover soluções nas mais diversas áreas de tecnologia. Torna-se crescente a necessidade, por exemplo, do desenvolvimento de soluções para aparelhos celulares que demandam uma integração com sistemas legados, de maneira a fornecer soluções corporativas. A partir disto, o conhecimento de Java e de sistemas abertos, são imprescindíveis para profissionais de TI.

Além da demanda, a tendência é um outro fator motivador para este mercado. No Brasil, esta aponta para direção de trabalhos realizados para clientes de fora do país - o outsourced. É crescente a procura por parte das organizações, o desenvolvimento de projetos baseados em tecnologia Java, distribuindo-se as aplicações desenvolvidas aqui pela Internet.

Todavia, a busca do mercado por esse perfil de profissional vai de encontro com a capacidade de fornecimento do conhecimento Java. O fato é que, o mercado tem dificuldade em encontrar desenvolvedores com competência nos fundamentos de Tecnologia da Informação, orientação a objetos, conhecimento e experiência em Java avançado, competência em comunicação e nas relações interpessoais.

A industria de software supre o despreparo dos profissionais formados pelo mercado, com a necessidade de re-treinamento interno dos novos contratados, muitos graduados sem conhecimento em TI. A grande maioria não tem uma certificação, que tem um valor adicional no mercado, especialmente para trabalhos executados fora do pais. Outro fator que colabora para o despreparo do profissional é fato do treinamento oficial Java da Sun ser relativamente caro e os programas de treinamento interno das empresas atuais serem pouco abrangentes. Disso resulta uma contratação de apenas 5% dos currículos recebidos nas empresas.

Academicamente o treinamento é, muitas vezes gratuito e de boa qualidade, é acessível. Contrastando, os professores não possuem experiência prática das demandas da indústria e não há, por parte de centros acadêmicos, a compreensão com respeito ás preocupações da industria de software, que não conseguem cobrir as necessidades que o mercado exige. Aliado a isso, está a dificuldade de alterar os currículos acadêmicos.

E o JEDI ?

O JEDI, entra neste contexto de forma totalmente gratuita para a comunidade e disponibiliza todo o acesso aos cursos e materiais. O aluno terá ao seu dispor manuais, slides de apresentação das aulas, provas, exercícios e material de referência e vídeo-aulas. Contando ainda com os softwares, o treinamento de instrutores, o acesso a suporte e a lista de discussão da comunidade.

Na Filipinas já existe uma estrutura acadêmica dividida em fases. Na primeira fase foram disponibilizados os cursos de Introdução a programação I (versão 1.3); Introdução a Programação II (versão 1.1) e Estruturas de Dados (versão1.1). Na segunda fase os cursos de Engenharia de software (versão 1.0); Desenvolvimento de aplicações móveis (versão 1.0); Programação Web (versão 1.0). Na terceira fase, os cursos de Web Services; Segurança em Java e Programação, modelagem e análise orientada à objetos. Completando quatro semestres de curso com: Sistemas operacionais; Gerenciamento de projetos orientados à objetos e Inteligência artificial. Todo este material está atualmente disponível para download, em Inglês, no site Java.net.

A comunidade JEDI tem contribuído bastante para o sucesso desta iniciativa, em todo o mundo existem mais de 80 pessoas contribuindo ativamente. Os treinamentos são realizados pelos membros do JEDI que conduzem os testes e recebem cada vez mais pessoas como voluntárias. O JEDI possui, atualmente, parcerias globais nas Filipinas através de JP Petines (Java champion), no Brasil através de Daniel deOliveira (Java champion), na França através de Vicent Brabant (Java champion) e de coordenações na Malásia, Tailândia, Singapura, Japão e Vietnam.

Hoje o JEDI concentra o maior número de membros nas Filipinas. Desde fevereiro de 2005 até abril de 2006 são 110 escolas - 10% de todas as universidades e faculdades das Filipinas aderentes ao programa; Foram realizados 13 treinamentos e formados 207 instrutores multiplicadores, que formaram 1.318 instrutores que atendem a 48.205 estudantes.

Países de Língua Portuguesa

O Brasília Java Users Group - DFJUG é responsável pela coordenação do JEDI em países de língua portuguesa. Angola, Cabo Verde, Guiné-Bissau, Brasil, Moçambique, Portugal, São Tomé e Príncipe; Timor Leste serão países que poderão fazer o treinamento em língua nativa, com todos os recursos que a iniciativa provê. O DFJUG possui mais de 9.900 membros e é totalmente baseado em trabalho voluntário, sem personalidade jurídica e patrocinado pelo Instituto CTS, OSCIP, voltada para a pesquisa e desenvolvimento de tecnologias de software, que fornece ao grupo apoio logístico, administrativo e jurídico.

Atualmente, o Brasil conta, segundo a SUN Microsystems, com 70 mil desenvolvedores Java e 43 grupos de usuários Java, com mais de 25 mil membros participantes. É através do apoio destes grupos distribuídos em todos os estados da nação que esta iniciativa espera se consolidar, para elevar o nível de aprendizado Java, provendo melhores profissionais para atender as exigências do mercado mundial.

Como participar do JEDI ?

No momento estamos trabalhando na tradução e adaptação do material utilizado na Filipinas. Um vez que este esteja concluído, os cursos poderão ser acessados pelo site. Ao concluir o processo cada aluno terá que fazer uma prova presencial para obter a sua certificação, que será oferecida agentes que serão certificados em todo Brasil.

O DFJUG necessita de pessoas para corrigir e dar opiniões sobre todo o material produzido e realizar testes de Stress no site aonde o JEDI será hospedado, isso é um trabalho que somente poderá ser realizado com o apoio de toda a comunidade javanesa existente no Brasil. Quem quiser participar da iniciativa, no Brasil, deve acessar a página do DFJUG (www.dfjug.org) e entrar em contato com o grupo. Junte-se a nós, participe no instrutor ou como aluno desta iniciativa, poderemos assim enriquecer o conhecimento da linguagem e difundi-la de uma forma totalmente gratuita, voluntária e colaborativa, no Brasil e em diversos paises de língua portuguesa, será seu trabalho e seu empenho que ajudará elevar o Brasil ao hall dos melhores desenvolvedores JAVA no mundo.

Comments

Eduardo Bregaida

Me manda um e-mail ou MP no GUJ e fala tbm com o WilliamSilva do GUJ tbm q vc entra rapidinho =)

Eduardo Bregaida

Boa, está também envolvido no JEDI?

[]s

Israel

Putz cara... vou confessar que só caiu a ficha agora no lance do "nuts" UHAUHAUHAUHUA :D

Vou te colocar no blogroll. Abraços!

Israel

Nunca viu Jericho? Não sabe o que tá perdendo hehehe :)

A propósito, bem legal o teu blog. Gostei muito dos posts. Parabéns.

Sugestões de Leitura

Wed, 11 Jul 2007 15:38:00 -0300

Ja ouviu falar na tal Web 2.0? Veja os slides da apresentação do Philip Calçado.

Quer dominar o Vi/Vim? Veja este pequeno guia.

Se inglês não é problema, vc pode aprender Java, C++ ou Programação Avançada em Linux usando livros gratuitos e de ótima qualidade.

No site da InfoQ vc ainda pode baixar livros de SOA, Scrum & XP, Domain Driven e Dicas de Visual Studio .NET.

E, se vc se interessa por Gerência de Projetos, vai gostar desse artigo.

Boa leitura!

Ola Mundo!

Mon, 11 Jun 2007 16:42:00 -0300

Quando aprendemos uma nova linguagem de programação, normalmente o primeiro exemplo é o famoso "Hello World!", ou seja, um pequeno código que imprime uma mensagem na tela do computador.

Em C, ele seria assim:

/* Um comentário */
#include <stdio.h>

int main ()
{
 puts ("Hello world!");
 return 0;
}

As vezes o puts é substituido pelo multifacetado printf no exemplo, mas o efeito é o mesmo. Vejamos como seria em Java.

/* Comentarios, igual ao C */
package Hello;

public class HelloWorld {
 public static void main(String[] args) {
 System.out.println("Hello world");
 }
 }

As diferenças são várias, apesar da estrutura ser semelhante. Em C nós temos funções parametrizadas, enquanto em Java nós temos objetos (System.out) e métodos (println).

Por fim, vamos ver um exemplo em Shell Script

#!/bin/bash
# comentario
echo "Hello World!"

Diferente de uma linguagem de programação, aqui o interpretador de comandos (normalmente) chama um programa capaz de escrever mensagens para o usuario. Ou seja, alguem ja escreveu um "Hello World!" genérico o suficiente para nós.

Cada linguagem possui um propósito. Enquanto vc projeta sistemas operacionais e drivers em C, Java ocupa uma área no desenvolvimento de grandes sistemas corporativos enquanto o shell está presente na administração de determinadas tarefas de um servidor (normalmente rodando algum sabor de *nix).

Não basta comparar um hello world, pois é preciso ver muito além da sintaxe e recursos da linguagem, mas normalmente se começa por ele.

Outros exemplos podem ser encontrados aqui.

Abraços