Desempenho Java x C

show Felipe, o Tiger realmente esta ótimo… mas tenho uma idéia, faça o mesmo com um código como Bubble Sort… algo q realmente processe, ou a série de Fibonacci até X número… e poste os resultados

Oi

Show de bola isso, nao precisa ser 100% exato nao, o Tiger esta esmagando o C…

Faça o teste com o JDK 1.4.2, eu aposto que Java será mais lento.

T+

Seguinte, muito simples esse teste… mas não se iludam.

Mude o tipo de dado de long para int no código do C. O tempo deve cair para uns 2/3. Isso porque no código objeto eu preciso uma instrução a mais para carregar a parte alta do inteiro no registrador, isso acontece em cada operação ou atribuição.

Muda para register int veja o tempo cair para 1 ou 2 segundos… o complicador irá gerar o código objeto acessando as variáveis diretamente dos registradores, sem acessar a memória…

me corrijão se eu estiver errado, mas o “long” em C admite valores de ponto flutuante neh ? (ex: 5,6989). E esse tipo de dado leva mais tempo para ser processado do que aqueles que apenas admitem valores inteiros.

mas dé qualquer forma a comparação é válida, C é considerado uma linguagem muito veloz, e o java chegar próximo a ele já mostra que de lento ele só tem a fama (AINDA).

int nao vai funcionar, pq em C o int tem apenas 16 bits, e 2 bilhoes nao cabem em 16 bits… eu repeti o teste agora com o i e o x como register e o resultado foi o parecido: 8 segundos e 48 centesimos…

e eu sei que java nao eh mais rapido que C, eu soh fiz esse teste pra mostrar que nao eh tao lento quanto muita gente pensa… o buble sort acredito que a diferenca sera pequena, mas o quicksort acredito que C vai dar uma surra em java… vou fazer uns testes e depois posto aki…

qnto a usar long ao invez de int em C no primeiro teste, eu fiz um pequeno teste pra verificar isso:

int main(){
 printf("sizeof(int) = %d; sizeof(long) = %d\n", sizeof(int), sizeof(long int));
}

o resultado foi:

sizeof(int) = 4; sizeof(long) = 4

achei bem estranho um long ter o mesmo tamanho de um int…

e fiz um outro teste, agora com o bublesort, e novamente o java foi mais rapido!!!

codigo Java:

public class Teste{
 private static final int SIZE = 100000;
 public static void main(String args[]){
  int array[] = new int[SIZE];
  for (int i = 0; i < SIZE; i++){
   array[i] = i % 100;
  }
  bublesort(array);
 }
 public static void bublesort(int array[]){
  int aux;
  for (int i = 0; i < array.length; i++){
   for (int j = array.length - 1; j > i; j--){
    if (array[j] < array[i]){
     aux = array[i];
     array[i] = array[j];
     array[j] = aux;
    }
   }
  }
 }
}

codigo C:

#define SIZE 100000
void bublesort(int array[]);
int main(){
 int array[SIZE], i;
 for (i = 0; i < SIZE; i++){
  array[i] = i % 100;
 }
 bublesort(array);
}
void bublesort(int array[]){
 int aux, i, j;
 for (i = 0; i < SIZE; i++){
  for (j = SIZE - 1; j > i; j--){
   if (array[j] < array[i]){
    aux = array[i];
    array[i] = array[j];
    array[j] = aux;
   }
  }
 }
}

OBS: como quis que sempre fossem ordenados os mesmos valores, nao botei nada aleatorio

resultados Java:

52 segundos e 74 centesimos
52 segundos e 17 centesimos
52 segundos e 34 centesimos

resultados C:

53 segundos e 93 centesimos
55 segundos e 98 centesimos
55 segundos e 97 centesimos

depois vou testar o quicksort, soh q acho q C vai dar uma surra em java

Ae Felipe esse teste sim mostra que java esta realmente rápido…

Eu imagina que com o Bubble o C ia disparar na frente do java.

Estou aguardando o resultado do Quick! manda ve ai…

agora fiquei de boca! eu pensava que C ia ser duas vezes mais rapido que java, mas o que ocorreu foi o contrario! Java foi aproximadamente duas vezes MAIS rapido que C!!!

codigo Java:

public class Teste{
 private static final int SIZE = 1000000;
 public static void main(String args[]){
  int array[] = new int[SIZE];
  for (int i = 0; i < SIZE; i++){
   array[i] = i % 100;
  }
  quicksort(0, SIZE - 1, array);
 }
 public static void quicksort(int p, int q, int array[]){
  if (p < q){
   int j = p - 1;
   int aux = array[q];
   for (int i = p; i <= q; i++){
    if (array[i] <= aux){
     int taux = array[i];
     array[i] = array[++j];
     array[j] = taux;
    }
   }
   quicksort(p, j - 1, array);
   quicksort(j + 1, q, array);
  }
 }
}

codigo C:

#define SIZE 1000000
void quicksort(int p, int q, int array[]);
int main(){
 int array[SIZE], i;
 for (i = 0; i < SIZE; i++){
  array[i] = i % 100;
 }
 quicksort(0, SIZE - 1, array);
}
void quicksort(int p, int q, int array[]){
 int j, aux, i, taux;
 if (p < q){
  j = p - 1;
  aux = array[q];
  for (i = p; i <= q; i++){
   if (array[i] <= aux){
    taux = array[i];
    array[i] = array[++j];
    array[j] = taux;
   }
  }
  quicksort(p, j - 1, array);
  quicksort(j + 1, q, array);
 }
}

resultados Java:

1 minuto, 4 segundos e 91 centesimos
1 minuto, 4 segundos e 78 centesimos
1 minuto, 4 segundos e 81 centesimos

resultados C:

2 minutos, 4 segundos e 81 centesimos
2 minutos, 4 segundos e 66 centesimos
2 minutos, 4 segundos e 53 centesimos

:viva:

Vixxi essa comparação do Quick foi para calar a boca de qualquer um que disse que java é lento.

isso mostra como tem programadores que n sabem o q é realmente o java hoje em dia, ficam falando que o java é lento, e ruim de programar, etc… mas é o que mas há portabilidade e se programa para varias coisas como celular , web e etc…
simplesmente java eh muito melhor q qq outra linguagem… :triunfo:

Bah…

esse teste foi pra tira tudo que éra duvida mesmo…
eu ainda to tentando achar uma explicação teorica pra isso…

de qualquer forma tenho que rever meus conceitos, até 30 min atraz eu achava que C a linguagem de alto nivel imbativel em qualquer aspecto de velocidade.

8O 8O 8O 8O 8O 8O 8O 8O

hahahahahah

java é demais!!!

que venha o .NET!!!

Esse é o Tigre!!!

Q venha o Mustang !!!

resultados surpreendentes…

eu naum sabia dessa grande performance que o Tiger possui…

“sens”:

esse teste foi pra tira tudo que éra duvida mesmo…
eu ainda to tentando achar uma explicação teorica pra isso…

Otimização… codigo objeto gerado pelo compilador Java é aparentemente muito melhor que o código objeto gerado pelo GCC.

Particularmente, eu não conheço o GCC, por isso não sei como funciona o esquema de otimização dele. Mas provavelmente o default deve privilegiar um código objeto pequeno, e deve ser possivel configura-lo de maneira a reverter essa situação.

Sejamos realistas, a linguagem C++ é bastante proxima ao hardware… tanto que podemos configurar o compilador para otimizar de diversas maneiras, como para performance, compatibilidade (caso queira se usar processadores antigos), código objeto pequeno, baixo uso de recursos de hardware.

No caso do dotNet e Java, um código objeto intermediário é gerado, e depois esse é aberto e interpretado por uma VM. Só o fato ler um arquivo e interpretar pseudo-instruções já um processamento… com um software gerado em C++ corretamente otimizado não faz esse tipo de processamento.

Não me entendam mal pessoal mas é:

• C++ para computação gráfica
• Java para aplicação web

São as áreas que atuo hoje. Tiger está de parabens, parece ter melhorado muito, pois tava perdendo um bom espaço para dotNet.

Abraços.

daniel_bocian, obrigado pela esplicação …

mas o que não entendo é o seguinte:

“C” não é orientado a objeto, e java é 100% orientado a objeto, isso pesa em favor do C pois a linguagem não orientada é mais rápida.

E ainda o JAVA necessita de uma JMV o que faz que fiq mais lento ainda, pois necessita ser interpretado e em tempo de execução.

e o C é compilado previamente, teoricamente ele deveria ganhar tempo com isso. Sem contar que é uma linguagem mais baixo nivel que java, o que também na teoria faz com que ele seja mais rapido…

Continuo na duvida… se mais alguêm puder achar uma explicação…

Obrigado

[]´Victor

Bem, em primeiro lugar, o fato da linguagem ser orientada a objeto ou não, não faz nenhuma diferença. Isso por que depois de passar pelo compilador tudo vira um conjunto de instruções que não seguem paradigma algum.

Segundo, mas uma vez falo que isso depende do compilador. Pensa só, nossos processadores atuais implementam instruções MMX, SSE, SSE2, 3DNow e etc… te garanto que o GCC padrão, compila gerando código objeto compatível com todos os processadores x86. Ou seja, não faz uso desse conjunto avançado de instruções. Agora, a implementação da JVM com toda a certeza utiliza esses recursos para otimizar performance.

Ok… agora, com toda a certeza eu posso habilitar o GCC para utilizar essas instruções avançadas… daí ele ganha desempenho…

Infelizmente, eu não sei utilizar o GCC… atualmente trabalho apenas com compilador da Microsoft. Mas é uma coisa que dá para garantir, C é flexivel… tanto que o Felipe pode rodar sem problema esse programa teste em C em um micro 286, já o em Java…

ok daniel_bocian, valeu pelo toke…

deu pra dar uma clareada…

[]'s Victor

corrijao me se eu estiver errado, mas o gcc nao otimiza o codigo por default para o computador onde esta sendo compilado??? eu compilei e rodei no mesmo computador… entaum nao estava otimizado pro meu computador??? nao tenho certeza disso pois sou iniciante em C, mas lembro de ter lido em algum lugar que o gcc otimizava por default pro pc que ta compilando…

e soh pra deixar claro, em nenhum momento eu quis dizer que java eh mais rapido que C, tanto eh que eu pensei que C iria ficar na frente nos testes que fiz, o que eu to querendo eh mostrar que Java NÃO eh lento como dizem por ai…

“microfilo”:

hahahahahah

java é demais!!!

que venha o .NET!!!

Já que pediram, eu topei o desafio e coloquei os resultados lá no GUJ: http://www.guj.com.br/posts/list/15/19168.java#100433

“sens”:

me corrijão se eu estiver errado, mas o “long” em C admite valores de ponto flutuante neh ? (ex: 5,6989). E esse tipo de dado leva mais tempo para ser processado do que aqueles que apenas admitem valores inteiros.

mas dé qualquer forma a comparação é válida, C é considerado uma linguagem muito veloz, e o java chegar próximo a ele já mostra que de lento ele só tem a fama (AINDA).

long é para valores inteiros, igual o int, so que maior. O tipo de ponto flutuante em C é “float” e “double”.

po, daniel, não era pra humilhar o .NET…

“Felipe”:

mas o gcc nao otimiza o codigo por default para o computador onde esta sendo compilado???

Hum… eu não conheço o GCC, pode ser verdade. Mas acho pouco provavel… acredito ser mais correto assumir compatibilidade e portabilidade como default, assim como faz o compilador da microsoft… o GCC deve seguir a mesma filosofia. É o caso de dar uma pesquisada…

“Felipe”:

e soh pra deixar claro, em nenhum momento eu quis dizer que java eh mais rapido que C, tanto eh que eu pensei que C iria ficar na frente nos testes que fiz, o que eu to querendo eh mostrar que Java NÃO eh lento como dizem por ai…

Perfeito Felipe, você foi correto. Apenas fiz minhas colocações para conter excessos de empolgação.

Java mais rápido que C?

Claro que tem coisa errada aí.
Até porque a máquina virtual é feita em C, né não ?

Bom, é óbvio que C sempre vai ser mais rápido que Java
se forem feitos programas otimizando da melhor
maneira para obter o melhor desempenho possível.

Conclusão:
Java é rápido o bastante.
O Swing é que é absurdamente lento, daí
vem a fama de Java ser lento.

“soldate”:

O Swing é que é absurdamente lento, daí
vem a fama de Java ser lento.

Me parece q no Tiger a coisa mudou um poko.

Eu ainda naum testei, mas o pessoal ta falando q o desempenho melhorou mto na nova versão.

[]'s

Desculpem minha ignorância, mas o que é Tiger? Uma IDE?
Onde encontro?

“Schuenemann”:

Desculpem minha ignorância, mas o que é Tiger? Uma IDE?
Onde encontro?

Tiger é o sinonimo de Java 5! é só a nova versão do Java… o Java Tiger, ou Java 5, ou simplesmente Tiger

Swing lento? Hummm… Não sei: http://www.javalobby.org/articles/swing_slow/index.jsp

“DanielQO”:

“microfilo”:

hahahahahah

java é demais!!!

que venha o .NET!!!

Já que pediram, eu topei o desafio e coloquei os resultados lá no GUJ: http://www.guj.com.br/posts/list/15/19168.java#100433 :)

sobre o que vc postou no GUJ…

o stackoverflow ocorreu ai pq por default a JVM esta configurada pra usar apenas 64MB de ram, dai soh o array que tem um milhao de elementos, e cada int ocupa 4 bytes, vai ocupar 40MB (na verdade um pouco menos, jah que 1KB = 1024B e 1MB = 1024KB), e cada chamada recursiva vai gastar mais a memoria das variaveis dos metodos e ainda a memoria que vai ser usada para “apontar” para onde retornar (stack), e ainda tem a memoria alocada pela JVM…

bem, aki rodou, nao sei pq ai faltou memoria, mas tente repetir o teste com um array menor…

Dá-lhe tiger…

aiô mustang… :razz:

So vejam o meu avatar!!! V8tão!!!

Programo para a web, na plataforma J2EE, e sempre escuto dizer que é uma linguagem muito lenta e que nunca vai chegar a competir com o PHP.

Quer saber o PHP é que nunca vai chegar aos pés do JAVA, pois quer maior prova: o site de um dos maiores bancos do mundo e que foi eleito o mais seguro também “www.bb.com.br”.

E tem mais, pois soube que ele não segue o padrão MVC, mas é bem estruturado arquitetonicamente e tem uma ótima performance. 8O

“cleo_nascimento”:

Programo para a web, na plataforma J2EE, e sempre escuto dizer que é uma linguagem muito lenta e que nunca vai chegar a competir com o PHP.

Quer saber o PHP é que nunca vai chegar aos pés do JAVA, pois quer maior prova: o site de um dos maiores bancos do mundo e que foi eleito o mais seguro também “www.bb.com.br”.

E tem mais, pois soube que ele não segue o padrão MVC, mas é bem estruturado arquitetonicamente e tem uma ótima performance. 8O

AFFFFFF

php = asp gratis

caramba surpreendente !!!
eu trabalha com um cara amante de C, ai ele nao se conformou e disse q era impossivel entao ele disse q ia provar q ia otimiza o codigo c… mas ???
[size=“18”]
entao ele consegui otimizou o codigo!!! [/size]
mas do JAVA
o java ficou dois segundos mais rapigo !!!
kkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkk!!! ele ficou puto!!!
[size=“18”]
nos zuamos muito ele!!! com while o java fica mais rapido!!![/size] :serra: :bei:[/size]

Seguinte,

Devido ao excesso de empolgação do pessoal, fui obrigado a fazer alguns testes. Volto a afirmar, que Java nunca será mais rápido que C! Uma boa justificativa é da propria JVM ser implementada nesta linguagem, como foi colocado por alguém antes.

Bem, indo ao teste… peguei o mesmo código gerado pelo nosso amigo Felipe:

int main(){ 
    long i, x = 0; 
    for (i = 0; i < [telefone removido]; i++){ 
        x++; 
    } 
}

Compilei duas vezes, com os seguintes comandos:

1. gcc teste.c -o a.out
   

2. gcc teste.c -O3 -o b.out
   

Para explicar, no primeiro compilo sem ativar otimizações, que é a configuração default do GCC. No segundo comando, ativo o grau maximo de otimizações.

Resultados:
a.out executou em aproximadamente 20 segundos
b.out executou em aproximadamente 6 segundos

Cronometrei manualmente também, apenas para dar uma ideia da diferença… não sei a configuração da máquina que utilizei.

Sugiro que o Felipe refaça os testes utilizando o otimizador do GCC, certamente o resultado será invertido.

Abraços,
Daniel

Oi

Pessoal, hehehe mas esta discussão ainda nem chegou nas partes boas hein…

Bocian, se for pra apelar otimizando na compilação, o Java tb tem otimização, mas comnhecido como JIT ou Just in Time…

O JIT CLient já roda or default na VM da Sun, mas existe o JIT Server, que da mais performance ainda a aplicação e tb outros compiladores JIT que nao sao da Sun, que aumentam a performance ainda mais, muito mais…

Se tu esitver com o Tiger, roda este exemplo com o comando: java -server SuaClasse e verá o resultado, não tem pra onde correr.

Um exemplo, em aplicações com gerenciamento de memória muito complexo, usando JIT, Java não é só mais rápido do que C/C++, é increditavelmente mais rapido, é muito mais rápido.

T+

haiuehiuaheiuahe

Sinceramente… Eu acho tbm que o C deva ganhar do JAva… mas e dai?! se ele ganhar é pq tem que ganhar mesmo… porém como podemos ver, Java está cada vez mais encostando no C, e em alguns passos até passando devido a muitas implementações…

Vou pedir para um pessoal que desenvolvem Sistemas Operacionais, pessoal da antiga Conectiva, para desenvolver um código em C super-ultra rápido, e dai colocamos ele para rodar contra um em Java, para ver qual que vai ser o bizu que vai dar!
hehehehe

aguardem!

eu jah tinha ouvido desses recursos que o jeve falou, mais nunca cheguei a usar (inclusive nao usei nesses testes)… e inclusive, nao hora de compilar pode-se passar a flag “-O” (Otimizar), isso faz com que o prog seja compilado sem as informacoes pra debug, o que deixa mais rapido…

e daniel_bocian, lembre-se que os aplicativos distribuidos em C, nao vao ser distribuidos otimizados, a nao ser que eles facao uma compilacao pra cada hardware (ou eles podem mandar o codigo pra pessoa compilar no proprio PC, mas isso ocorre soh com software livre)…

hj to meio sem tempo, mas amanha vou ver se faco mais uns testes…

“jeveaux”:

Oi
Um exemplo, em aplicações com gerenciamento de memória muito complexo, usando JIT, Java não é só mais rápido do que C/C++, é increditavelmente mais rapido, é muito mais rápido.
T+

Desculpem mas esse comentário parece um tanto fanático…

É visível que java esta se aproximando de C, mas dizer que ele já o igualou (em termos de velocidade) já eh um pouco de exagero, agora falar que é muito mais rápido é um pouco forçado…

Sugiro fazer testes com ambas as partes otimizadas. assim da pra ter uma ideia mais real de qual é a diferença entra eles

fiz mais alguns testes com o Quicksort, agora com as otimizacoes…

codigo Java:

public class Teste{
 private static final int SIZE = 1000000;
 public static void main(String args[]){
  int array[] = new int[SIZE];
  for (int i = 0; i < SIZE; i++){
   array[i] = i % 100;
  }
  quicksort(0, SIZE - 1, array);
 }
 public static void quicksort(int p, int q, int array[]){
  if (p < q){
   int j = p - 1;
   int aux = array[q];
   for (int i = p; i <= q; i++){
    if (array[i] <= aux){
     int taux = array[i];
     array[i] = array[++j];
     array[j] = taux;
    }
   }
   quicksort(p, j - 1, array);
   quicksort(j + 1, q, array);
  }
 }
}

codigo C:

#define SIZE 1000000
void quicksort(int p, int q, int array[]);
int main(){
 int array[SIZE], i;
 for (i = 0; i < SIZE; i++){
  array[i] = i % 100;
 }
 quicksort(0, SIZE - 1, array);
}
void quicksort(int p, int q, int array[]){
 int j, aux, i, taux;
 if (p < q){
  j = p - 1;
  aux = array[q];
  for (i = p; i <= q; i++){
   if (array[i] <= aux){
    taux = array[i];
    array[i] = array[++j];
    array[j] = taux;
   }
  }
  quicksort(p, j - 1, array);
  quicksort(j + 1, q, array);
 }
}

resultados Java SEM flag “-server”:
1 minuto, 4 segundos e 91 centesimos
1 minuto, 4 segundos e 80 centesimos
1 minuto, 4 segundos e 91 centesimos

resultados Java COM flag “-server”:
34 segundos e 55 centesimos
34 segundos e 53 centesimos
34 segundos e 53 centesimos

resultados C SEM flag “-O3”:
2 minutos, 4 segundos e 41 centesimos
2 minutos, 4 segundos e 41 centesimos
2 minutos, 4 segundos e 66 centesimos

resultados C COM flag “-O3”:
14 segundos e 80 centesimos
14 segundos e 78 centesimos
14 segundos e 78 centesimos

eu tinha feito testes passando a flag “-O” na compilacao do codigo java, mas nao teve nenhuma diferenca…

como eh possivel ver nos testes, com a otimizacao C fica mais rapido, mas nao esquecam que nenhum programa eh distribuido otimizado a um hardware especifico, daria muito trabalho ficar otimizando pra tudo qnto eh hardware, soh vai dar pra aproveitar a otimizacao do C se o programa for open source…

mesmo nao sendo mais rapido que C, o Tiger surpreendeu…

“sens”:

“jeveaux”:

Oi
Um exemplo, em aplicações com gerenciamento de memória muito complexo, usando JIT, Java não é só mais rápido do que C/C++, é increditavelmente mais rapido, é muito mais rápido.
T+

Desculpem mas esse comentário parece um tanto fanático…

É visível que java esta se aproximando de C, mas dizer que ele já o igualou (em termos de velocidade) já eh um pouco de exagero, agora falar que é muito mais rápido é um pouco forçado…

Sugiro fazer testes com ambas as partes otimizadas. assim da pra ter uma ideia mais real de qual é a diferença entra eles

Oi…

Fanático??? 8O 8O

Eu não diria fanático, mas sim realista, basta fazer os testes… Fazer um contador ou um algoritmo de busca ou ordenaćão simples, não vai mostrar quem é mais rápido ou mais lento… Agora, com aplicaćões como eu citei, com gerenciamento de memória altamente complexo, o C não será mais do que Java, isso é fato e não fanatismo…

T+

“jeveaux”:

Oi…

Fanático??? 8O 8O

Eu não diria fanático, mas sim realista, basta fazer os testes… Fazer um contador ou um algoritmo de busca ou ordenaćão simples, não vai mostrar quem é mais rápido ou mais lento… Agora, com aplicaćões como eu citei, com gerenciamento de memória altamente complexo, o C não será mais do que Java, isso é fato e não fanatismo…

T+

A questão de gerenciamento de memória em C/C++, pode parecer inferior a java por que ela deixa muita coisa para o programador fazer, enquanto com java muita coisa a própria JVM faz, facilitando a vida do programador. Um programador experiênte em "C/C++" que sabe otimizar não apenas a compilação mas o código que escreve, concerteza faz aplicativos mais rapidos que em java. 
     Isso explica por que os aplicativos pesados que são programados para rodar em "cluster" e que levão dias para serem processados em sua maioria são escritos em "C".

   Não estou querendo defender C em relação a Java. Estou apenas mostrando meu ponto de vista que na VELOCIDADE ele é melhor, porem java tem inúmeras outras vantagens em relação a C .

jeveaux desculpe pelo fanático, certamente exagerei em minha colocação. Não foi minha intenção te ofender.

obs: ahm… o daniel_bocian pode não responder mais nesse tópico por um tempo pq entrou de férias haeheahe :lol: (ele é meu colega de trabalho)

bom na verdade realmente o java não pode ser mais rapido do q o C, pois o C esta em camadas mais inferiores q o java contando da linguagem de maquina ate a de alto nivel. acho q o interressante aqui é q o java não é tao lento quanto dizem e esta cada vez ficando melhor. no caso do codigo q esta o testando ai quando o java usa mais variaveis ele gasta muito mais tempo q o C, usando ate duas variaveis o C fica mais lento depois usando mais ele gasta menos tempo q o java. ate pelo caso de o java de a gerencia de memoria mais organizada como o garbage etc…

Bom, nao sei como conseguiram estes resultados, porem, reproduzi eles e os resultados nao batem com os encontrados aqui

adriano@gpserver01:~/sources/testes$ for prog in *.c; do gcc $prog -o ${prog%%.c}; done
adriano@gpserver01:~/sources/testes$ time ./bubble ; time ./quicksort ; time ./Teste

real 0m33.292s
user 0m30.242s
sys 0m0.031s

real 1m52.445s
user 1m18.586s
sys 0m0.139s

real 0m7.070s
user 0m6.821s
sys 0m0.002s

adriano@gpserver01:~/sources/testes$ for prog in *.java; do javac $prog; done
adriano@gpserver01:~/sources/testes$ time java Bubble; time java Quicksort; time java Teste

real 0m46.350s
user 0m33.429s
sys 0m0.223s

real 1m44.692s
user 0m50.278s
sys 0m0.643s

real 0m8.230s
user 0m7.134s
sys 0m0.026s

Somente no resultado do quicksort ocorreu uma vantagem do Java, no resto nao. A razao para isto ocorrer eh que a JVM provavelmente utiliza algum mecanismo de pre-fetching/caching, com isto acelerando os enlaces.

Quanto a discussao long vs. int, long e int tem o mesmo tamanho de palavra, 32 bits, int tem 16 bits em compiladores 16 bits.

Outra coisa soh para ser chato :twisted: , Java nao eh 100% orientada a objeto, existem tipos primitivos.

E finalmente, um programa em C geralmente serah mais rapido do que um em Java, o que pode ocorrer eh o compilador Java se utilizar de tecnicas de shortcut e como disse acima, pre-fetching/caching.
A razao para C gerar programas mais rapidos eh simples, a altura que se encontra da base do kernel e sua visao simplificada de tudo.

Falow!

[b] é por isso q existe as classes invólucras(Integer, Double…) com isso vc consegue 100% sacou!

a dados sao reais sim testamos aqui com o time do linux nao tem como errar :lol: [/b]

vc usou o tiger (jdk5.0)? o tiger ta BEM mais rapido que o 1.4…

c é mais rapido que java???

ok, vamos ver então como fica a programação concorrente!

vc usou o tiger (jdk5.0)? o tiger ta BEM mais rapido que o 1.4…

o felipe fizemos o teste aqui no 1.4 e JAVA FOI MAIS RÁPIDO, nem usamos o tiger q é mais rapido. mas de acordo com e q eu escrevi no topico ai de cima sobre o numero de variaveis.

“Ejunior”:

“tanob”:

Outra coisa soh para ser chato :twisted: , Java nao eh 100% orientada a objeto, existem tipos primitivos.

[b] é por isso q existe as classes invólucras(Integer, Double…) com isso vc consegue 100% sacou!

a dados sao reais sim testamos aqui com o time do linux nao tem como errar :lol: [/b]

[risos] Se tem tipos primitivos nao eh 100% OO
Por exemplo, como fazes para saber se um Integer eh maior que outro Integer? usa o metodo intValue() ? …

Quanto a versao da JVM eh o java 1.5 ou 5 ou tiger

Seja processamento paralelo, distribuido, etc. C sempre gerarah um codigo mais rapido.
Mas seja como queiram, continuem acreditando no que lhes convem, eu prefiro ser realista e ter nocao de que nada eh perfeito

Falow!

“tanob”:

“Ejunior”:

“tanob”:

Outra coisa soh para ser chato :twisted: , Java nao eh 100% orientada a objeto, existem tipos primitivos.

[b] é por isso q existe as classes invólucras(Integer, Double…) com isso vc consegue 100% sacou!

a dados sao reais sim testamos aqui com o time do linux nao tem como errar :lol: [/b]

[risos] Se tem tipos primitivos nao eh 100% OO
Por exemplo, como fazes para saber se um Integer eh maior que outro Integer? usa o metodo intValue() ? …

Quanto a versao da JVM eh o java 1.5 ou 5 ou tiger

Seja processamento paralelo, distribuido, etc. C sempre gerarah um codigo mais rapido.
Mas seja como queiram, continuem acreditando no que lhes convem, eu prefiro ser realista e ter nocao de que nada eh perfeito

Falow!

como jah disse, eu nao to dizendo que java eh mais rapido que C, nao eh com um teste simples como esse que vou poder afirmar algo do tipo, o que ocorreu foi que nos testes que eu fiz o java foi mais rapido (com o C nao otimizado)…

acho que ficou bem claro que java nao tao lento quanto dizem por ai… mas pra dizer que eh mais rapido que C teria que ser feito um teste mais preciso, e testando cada aspecto separadamente, ai sim teriamos uma nocao de qual linguagem eh mais rapida e em quais aspectos…

“tanob”:

Seja processamento paralelo, distribuido, etc. C sempre gerarah um codigo mais rapido.
Mas seja como queiram, continuem acreditando no que lhes convem, eu prefiro ser realista e ter nocao de que nada eh perfeito

ai vc jah ta sendo um pouco radical, como vc mesmo disse, nada eh perfeito, C nao eh perfeito, e em alguns casos java pode ser mais rapido que C, como nos testes que eu fiz e java foi mais rapido…

“Felipe”:

como jah disse, eu nao to dizendo que java eh mais rapido que C, nao eh com um teste simples como esse que vou poder afirmar algo do tipo, o que ocorreu foi que nos testes que eu fiz o java foi mais rapido (com o C nao otimizado)…

acho que ficou bem claro que java nao tao lento quanto dizem por ai… mas pra dizer que eh mais rapido que C teria que ser feito um teste mais preciso, e testando cada aspecto separadamente, ai sim teriamos uma nocao de qual linguagem eh mais rapida e em quais aspectos…

“tanob”:

Seja processamento paralelo, distribuido, etc. C sempre gerarah um codigo mais rapido.
Mas seja como queiram, continuem acreditando no que lhes convem, eu prefiro ser realista e ter nocao de que nada eh perfeito

ai vc jah ta sendo um pouco radical, como vc mesmo disse, nada eh perfeito, C nao eh perfeito, e em alguns casos java pode ser mais rapido que C, como nos testes que eu fiz e java foi mais rapido…

Olha eu compilei o codigo C sem otimizacao alguma
e ele foi mais rapido. Voce jah executou o codigo Java com o parametro ‘-verbose’? Eh, entao faca…

Bom, como isso jah estah virando um flamewar entre linguagens e eu nao acredito muito nisso, visto que cada linguagem tem seu proposito, vou deixar ai que continuem iludidos :lol:

Soh para constar:

adriano@gpserver01:~$ gcc -v
Reading specs from /usr/lib/gcc/i486-linux/3.4.4/specs
Configured with: …/src/configure -v --enable-languages=c,c++,java,f77,pascal,objc,ada,treelang --prefix=/usr --libexecdir=/usr/lib --with-gxx-include-dir=/usr/include/c++/3.4 --enable-shared --with-system-zlib --enable-nls --without-included-gettext --program-suffix=-3.4 --enable-__cxa_atexit --enable-libstdcxx-allocator=mt --enable-clocale=gnu --enable-libstdcxx-debug --enable-java-gc=boehm --enable-java-awt=gtk --disable-werror i486-linux
Thread model: posix
gcc version 3.4.4 20041218 (prerelease) (Debian 3.4.3-7)

adriano@gpserver01:~$ java -version
java version “1.5.0”
Java™ 2 Runtime Environment, Standard Edition (build 1.5.0-b64)
Java HotSpot™ Client VM (build 1.5.0-b64, mixed mode, sharing)

“tanob”:

“Felipe”:

como jah disse, eu nao to dizendo que java eh mais rapido que C, nao eh com um teste simples como esse que vou poder afirmar algo do tipo, o que ocorreu foi que nos testes que eu fiz o java foi mais rapido (com o C nao otimizado)…

acho que ficou bem claro que java nao tao lento quanto dizem por ai… mas pra dizer que eh mais rapido que C teria que ser feito um teste mais preciso, e testando cada aspecto separadamente, ai sim teriamos uma nocao de qual linguagem eh mais rapida e em quais aspectos…

“tanob”:

Seja processamento paralelo, distribuido, etc. C sempre gerarah um codigo mais rapido.
Mas seja como queiram, continuem acreditando no que lhes convem, eu prefiro ser realista e ter nocao de que nada eh perfeito

ai vc jah ta sendo um pouco radical, como vc mesmo disse, nada eh perfeito, C nao eh perfeito, e em alguns casos java pode ser mais rapido que C, como nos testes que eu fiz e java foi mais rapido…

Olha eu compilei o codigo C sem otimizacao alguma
e ele foi mais rapido. Voce jah executou o codigo Java com o parametro ‘-verbose’? Eh, entao faca…

Bom, como isso jah estah virando um flamewar entre linguagens e eu nao acredito muito nisso, visto que cada linguagem tem seu proposito, vou deixar ai que continuem iludidos :lol:

Soh para constar:

adriano@gpserver01:~$ gcc -v
Reading specs from /usr/lib/gcc/i486-linux/3.4.4/specs
Configured with: …/src/configure -v --enable-languages=c,c++,java,f77,pascal,objc,ada,treelang --prefix=/usr --libexecdir=/usr/lib --with-gxx-include-dir=/usr/include/c++/3.4 --enable-shared --with-system-zlib --enable-nls --without-included-gettext --program-suffix=-3.4 --enable-__cxa_atexit --enable-libstdcxx-allocator=mt --enable-clocale=gnu --enable-libstdcxx-debug --enable-java-gc=boehm --enable-java-awt=gtk --disable-werror i486-linux
Thread model: posix
gcc version 3.4.4 20041218 (prerelease) (Debian 3.4.3-7)

adriano@gpserver01:~$ java -version
java version “1.5.0”
Java™ 2 Runtime Environment, Standard Edition (build 1.5.0-b64)
Java HotSpot™ Client VM (build 1.5.0-b64, mixed mode, sharing)

CARA SE NAO DA DANDO O RESULTADO Q DEU AQUI É PQ VC AINDA NAO APRENDEU A COMPILA!!

OS TESTES Q FIZERAM TESTAMOS AQUI NA EMPRESA, OS CARA Q TESTARAM AQUI SAO PROGRAMADORES E ESPECIALISTAS EM C ELES NEM SACAM JAVA.

É SOBRE A OO VC PRECISA REVER OS SEUS CONCEITOS!!

ok, então seja feliz usando C :razz:

“Ejunior”:

CARA SE NAO DA DANDO O RESULTADO Q DEU AQUI É PQ VC AINDA NAO APRENDEU A COMPILA!!

[risos] Eu apresentei provas.

“Ejunior”:

OS TESTES Q FIZERAM TESTAMOS AQUI NA EMPRESA, OS CARA Q TESTARAM AQUI SAO PROGRAMADORES E ESPECIALISTAS EM C ELES NEM SACAM JAVA.

Rapaz, eu nao estou sendo porta-voz de programador C como voce, eu sou antes de programador Java programador C :lol:

Mas isto nao importa, o que nao pode ocorrer eh o gosto da linguagem subir a cabeca e ignorar os fatos. C tem seus problemas, mas nao com performance.

“Ejunior”:

É SOBRE A OO VC PRECISA REVER OS SEUS CONCEITOS!!

Olha, acho que vc nao pensou antes de escrever. A meu ver sua critica eh infundada. Me aponte algum lugar na discussao onde apresento alguma ideia equivocada quanto ao paradigma de OO.

E quanto aos resultados, ateh agora eu soh vi resultados cronometrados duvidosamente, mandem resultados baseados em tempo medido pelo sistema operacional e nao com base na mao de voces

“Ejunior”:

“tanob”:

“Felipe”:

como jah disse, eu nao to dizendo que java eh mais rapido que C, nao eh com um teste simples como esse que vou poder afirmar algo do tipo, o que ocorreu foi que nos testes que eu fiz o java foi mais rapido (com o C nao otimizado)…

acho que ficou bem claro que java nao tao lento quanto dizem por ai… mas pra dizer que eh mais rapido que C teria que ser feito um teste mais preciso, e testando cada aspecto separadamente, ai sim teriamos uma nocao de qual linguagem eh mais rapida e em quais aspectos…

“tanob”:

Seja processamento paralelo, distribuido, etc. C sempre gerarah um codigo mais rapido.
Mas seja como queiram, continuem acreditando no que lhes convem, eu prefiro ser realista e ter nocao de que nada eh perfeito

ai vc jah ta sendo um pouco radical, como vc mesmo disse, nada eh perfeito, C nao eh perfeito, e em alguns casos java pode ser mais rapido que C, como nos testes que eu fiz e java foi mais rapido…

Olha eu compilei o codigo C sem otimizacao alguma
e ele foi mais rapido. Voce jah executou o codigo Java com o parametro ‘-verbose’? Eh, entao faca…

Bom, como isso jah estah virando um flamewar entre linguagens e eu nao acredito muito nisso, visto que cada linguagem tem seu proposito, vou deixar ai que continuem iludidos :lol:

Soh para constar:

adriano@gpserver01:~$ gcc -v
Reading specs from /usr/lib/gcc/i486-linux/3.4.4/specs
Configured with: …/src/configure -v --enable-languages=c,c++,java,f77,pascal,objc,ada,treelang --prefix=/usr --libexecdir=/usr/lib --with-gxx-include-dir=/usr/include/c++/3.4 --enable-shared --with-system-zlib --enable-nls --without-included-gettext --program-suffix=-3.4 --enable-__cxa_atexit --enable-libstdcxx-allocator=mt --enable-clocale=gnu --enable-libstdcxx-debug --enable-java-gc=boehm --enable-java-awt=gtk --disable-werror i486-linux
Thread model: posix
gcc version 3.4.4 20041218 (prerelease) (Debian 3.4.3-7)

adriano@gpserver01:~$ java -version
java version “1.5.0”
Java™ 2 Runtime Environment, Standard Edition (build 1.5.0-b64)
Java HotSpot™ Client VM (build 1.5.0-b64, mixed mode, sharing)

CARA SE NAO DA DANDO O RESULTADO Q DEU AQUI É PQ VC AINDA NAO APRENDEU A COMPILA!!

OS TESTES Q FIZERAM TESTAMOS AQUI NA EMPRESA, OS CARA Q TESTARAM AQUI SAO PROGRAMADORES E ESPECIALISTAS EM C ELES NEM SACAM JAVA.

É SOBRE A OO VC PRECISA REVER OS SEUS CONCEITOS!!

Pq tu não manda os resultados obtidos pelo time ou usr/bin/time? Como tu testou os resultados?

Sou programador java, gosto de java, mas daí a java ser uma paixão que defendo mesmo que não haja provas vai uma longa distância.
O único jeito de java ser mais rápido que C ou C++ é por algum recurso de chache ou outro tipo de otimização da JVM. Isto implica de certa forma em uma alteração no algoritmo.

Com relação a java ser orientado a objeto… com certeza não é totalmente. Se o tanob tem que rever conceitor outros tem que aprender estes conceitos, pois os livros de orientação a objeto não fazem referencias a Java, mas sim a Smalltalk como exemplo de linguagem totalmente orienteda a objetos. Java não implementa herança múltipla de classes, nem tampouco sobrecarga de operadores. Se C++ que implementa tudo isto não é considerado totalmente orientado a objetos porque sempre comessa por uma função (main) então java com tipo primitivo tb não pode ser considerado totalmente orientado a objetos.

Falando de problemas de compilação pq não manda a sua linha de comando? É assim, trocando conhecimentos que melhoramos, não com gritos (A não ser que tenha estragado seu CAPSLOCK, ai desculpe).

Programação concorrente realmente java é muito bom, principalmente para o corporativo, mas nos supercomputadores não se usa Java, usa?

T+

Rafael

no resultado do quicksort, C levou 1 minuto a mais que Java, cronometrando pode ateh nao ser preciso, pode ateh variar alguns centesimos, talvez ateh 1 segundo, 2 tb eh possivel, mas dai jah eh dificil… mas agora pra ver uma diferenca de 1 minuto, nao precisa nem de relogio

eu tinha feito isso no relogio pq eu nao conhecia o comando time do linux…

mas como vc faz questao de ver o resultado baseado em tempo medido pelo sistema:

Ae jah perdeu a graça essa discussão aqui…
Levar as parada pro lado pessoal não da certo…
Tava legal ler o topic até o Tanob entrar no meio… ae ferrou tudo…

Mas firmeza…

Fiquei com vontade e tmb fiz o teste!

public class Teste{
 private static final int SIZE = 1000000;
 public static void main(String args[]){
  int array[] = new int[SIZE];
  for (int i = 0; i < SIZE; i++){
   array[i] = i % 100;
  }
  quicksort(0, SIZE - 1, array);
 }
 public static void quicksort(int p, int q, int array[]){
  if (p < q){
   int j = p - 1;
   int aux = array[q];
   for (int i = p; i <= q; i++){
    if (array[i] <= aux){
     int taux = array[i];
     array[i] = array[++j];
     array[j] = taux;
    }
   }
   quicksort(p, j - 1, array);
   quicksort(j + 1, q, array);
  }
 }
}

#define SIZE 1000000
void quicksort(int p, int q, int array[]);
int main(){
 int array[SIZE], i;
 for (i = 0; i < SIZE; i++){
  array[i] = i % 100;
 }
 quicksort(0, SIZE - 1, array);
}
void quicksort(int p, int q, int array[]){
 int j, aux, i, taux;
 if (p < q){
  j = p - 1;
  aux = array[q];
  for (i = p; i <= q; i++){
   if (array[i] <= aux){
    taux = array[i];
    array[i] = array[++j];
    array[j] = taux;
   }
  }
  quicksort(p, j - 1, array);
  quicksort(j + 1, q, array);
 }
}

Info do sistema:

[22:08][sparch@blue:teste]$ uname -a
SunOS blue 5.10 s10_72 i86pc i386 i86pc

CPU: Athlon XP 2800+
RAM: 768Mb

[22:12][sparch@blue:teste]$ java -version
java version "1.5.0_01"
Java(TM) 2 Runtime Environment, Standard Edition (build 1.5.0_01-b05)
Java HotSpot(TM) Client VM (build 1.5.0_01-b05, mixed mode, sharing)

[22:14][sparch@blue:teste]$ gcc -v
Reading specs from /usr/local/lib/gcc-lib/i386-pc-solaris2.10/3.3.2/specs
Configured with: ../configure --with-as=/usr/ccs/bin/as --with-ld=/usr/ccs/bin/ld --disable-nls
Thread model: posix
gcc version 3.3.2

[22:15][sparch@blue:teste]$ time java -Xms16m -Xmx384m -Xss2m Teste

real    0m48.410s
user    0m45.526s
sys     0m0.088s

[22:16][sparch@blue:teste]$ time java -Xms16m -Xmx384m -Xss2m -server Teste

real    0m26.478s
user    0m24.054s
sys     0m0.092s

[22:18][sparch@blue:teste]$ time ./teste

real    1m32.869s
user    1m28.087s
sys     0m0.038s

[22:22][sparch@blue:teste]$ time ./teste

real    0m10.819s
user    0m10.223s
sys     0m0.016s

E agora Joseh?

“sparch”:

Ae jah perdeu a graça essa discussão aqui…
Levar as parada pro lado pessoal não da certo…
Tava legal ler o topic até o Tanob entrar no meio… ae ferrou tudo…

Mas firmeza…

Eh, ferrou pq ateh eu postar ngn apresentava prova/explicacao alguma a favor do C, apenas um bando falando, falando e falando coisas

Com relacao ao seu teste, eu jah havia me referido a ele, analise o codigo em Java e em C, pensa em como ambos funcionam (dica: recursao) e acho que chegas numa conclusao. Se precisar de ajuda eh soh falar.

“rsmendes”:

Pq tu não manda os resultados obtidos pelo time ou usr/bin/time? Como tu testou os resultados?

Sou programador java, gosto de java, mas daí a java ser uma paixão que defendo mesmo que não haja provas vai uma longa distância.
O único jeito de java ser mais rápido que C ou C++ é por algum recurso de chache ou outro tipo de otimização da JVM. Isto implica de certa forma em uma alteração no algoritmo.

Com relação a java ser orientado a objeto… com certeza não é totalmente. Se o tanob tem que rever conceitor outros tem que aprender estes conceitos, pois os livros de orientação a objeto não fazem referencias a Java, mas sim a Smalltalk como exemplo de linguagem totalmente orienteda a objetos. Java não implementa herança múltipla de classes, nem tampouco sobrecarga de operadores. Se C++ que implementa tudo isto não é considerado totalmente orientado a objetos porque sempre comessa por uma função (main) então java com tipo primitivo tb não pode ser considerado totalmente orientado a objetos.

Falando de problemas de compilação pq não manda a sua linha de comando? É assim, trocando conhecimentos que melhoramos, não com gritos (A não ser que tenha estragado seu CAPSLOCK, ai desculpe).

Programação concorrente realmente java é muito bom, principalmente para o corporativo, mas nos supercomputadores não se usa Java, usa?

T+

Rafael

ola realmente me expressei mal com o tanob, peços desculpas …
mas é eu mesmo q tenho q aprender OO como vc ensinuou!
bom Java é completamente orientado a objeto Sim! nao estou dizendo q outra linguagem nao seja, se no livros q vc leu nao esta java, me desculpe mas vc não pode ter lido todos, ou leu? sobre os testes a galera ja postou ai vc não viu?? nao posso fazer nada c não acredita. bom não sou fanatico em java, mas nesse teste específico foi mais rapido, da uma olhada no q eu disse no começo desta pagina sobre as camadas de linguagem de baixo nivel em diante o C esta em vantagem pois esta em nivel mais baixo onde java teria q passar por esses niveis primeiro. como se alguem apostase uma corrida e dissese pr o outro corredor vai na frente depois eu vou. mas java evolui muito desde suas primeiras versoes, e c nem tanto quase nada, ele é rapido, um dia essa rapides vai ter q melhorar. bom sobre o q java nao tem como herança multipla é por isso q ele usa interfaces para q possa suprir muitas das vantagens de HM sem os seus devidos problemas q se associan-se . ta ficando muito grande este texto só pr terminar é estranho um java baby entra aqui so por causa dessa discursao, ou será q é amigo do tanob ou criou outro usuario hehe, bom chega desse assunto.

É uma opinião minha… mas eu acho que o texto q tem embaixo do avatar do cara não quer dizer se ele sabe ou nao… é mais para descontrair =)

Firmeza

É uma opinião minha… mas eu acho que o texto q tem embaixo do avatar do cara não quer dizer se ele sabe ou nao… é mais para descontrair =)

Firmeza

haha, nao sou eu duas vezes nao, nao teria porque, e eu tb nem escolhi essa frase, e nem sei onde muda, nao fucei na configuracao

Eu jah havia te feito uma pergunta sobre isso antes e nao respondeste, como faco pra saber se um java.lang.Long eh maior/igual/menor que outro?
Posso fazer alguma operacao entre estes objetos?

Se refletires um pouco nas respostas das perguntas que fiz, vais ver que Java nao eh 100% OO, veja por curiosidade Python, nao posso falar mto desta linguagem pq sou fan dela

E so pra finalizar, quero deixar claro que nao entrei aqui soh pra defender a linguagem C, jah era cadastrado aqui e trabalho com Java atualmente.

Falow!

Olá Pessoal, iai tanob e rafael… hehe.

Errado. O fato de conseguir manipular dados de um tipo int alocando-o em um objeto Integer não faz disso uma linguagem 100% OO. Ela apenas permite a programação orientada, o que é bem diferente. A linguagem 100% OO não pode fazer distinção entre um tipo primitivo e um objeto. Entenda isso como: “o ‘int’ deveria ser um objeto”, criar uma classe para manipulação é apenas uma “gambiarra”.

Isso desvaloriza o java? Não, assim como ele C++ também não é 100% OO. O fato de permitirem trabalhar com tipos primitivos as torna linguagens OO hibridas, enquanto a OO pura fica com smalltalk e cia.

Na minha opinião isso se torna uma vantagem já que se um sistema fosse realmente feito utilizando todas as normas de orientação a objetos seria muito mais complexo projeta-lo do que desenvolve-lo. Isso levando em conta que o programador tenha total domínio sobre OO Puro, senão pode adicionar mais dias, talvez meses para aprender o paradigma de forma correta e como aplica-lo na linguagem escolhida. Não preciso citar nada sobre desempenho né?

Errado também. Por acaso você desenvolve sistemas em Java SEM UTILIZAR OBJETOS? Me desculpe, mas uma comparação primitive-to-primitive pra mim é inútil.

O resultado desse benchmark é óbvio, vai depender mais da implementação da maquina virtual e/ou flags do compilador do que realmente a tão comparada “velocidade” entre as linguagens.

Se quiser fazer uma comparação correta, construa um codigo OO no Java e compare com o do C (note que voce mesmo esta falando de C e não de C++, portanto o uso de primitivos se mantém).

Aqui é que irão aparecer as diferenças.

Muitos vão dizer: “qualé cara, ai é injusto comparar desse jeito”, então devo lembrar que C é quase uma linguagem universal para comparação. Toda e qualquer linguagem será sempre comparada a ela.

E se fosse Java vs C++? Bem… dependeria muito da aplicação, não teriamos um real vencedor. Discutir isso é como debater sobre futebol, religião, mulher, ati vs nvidia, intel vs amd e por ai vai, resumindo é questão de gosto.

Querendo ou não Java é infinitamente mais organizado que um C++ e isso tras consequencias vantajosas no aspecto tecnico - facilita manutenção, fica um codigo mais legivel etc- por outro lado, com certeza tera uma perda consideravel de performance quando comparado a uma linguagem que pode “descer” o nível muito além de uma VM.

Um exemplo claro são as interfaces, para montar telinhas mais complexas o programa de vocês no java carrega uma verdadeira pilha de objetos, containers e tal. Não tem como não ficar “levemente” mais lento. Antes do Swing dar uma melhorada, pessoal tentava otimizar AWT na unha mesmo.

Tinha mais uns lance pra falar, mas agora bateu sono, cansei de digitar. heioawehiowahioe. flw ae.

É uma opinião minha… mas eu acho que o texto q tem embaixo do avatar do cara não quer dizer se ele sabe ou nao… é mais para descontrair =)

Firmeza

o sparch blz, quando disse essa frasse não estou dizendo q a frase embaixo é relacionado ao conhecimento do cara, eu sei q isso não tem nada a ver! eu só quis dizer q é estranho um pessoa q acabou de entrar no portal venha direto pr esse topico, pq “geralmente” elas gostumam tirar duvidas em outros topicos. eu só achei estranho! falou

Oi gente, desculpa o que eu vou dizer, mas é o seguinte: acho que este tópico já deu o que tinha que dar.
Digo isso porque acompanhei esta discussão, embora não tenha postado nenhum tópico nela.
O que entendi a princípio foi que quando o Felipe abriu este tópico, ele quis mostrar que o Java tá evoluindo cada vez mais, o que é muito bom.
A idéia, acredito eu, era usar o C como um referencial para mostrar como o velho tabu que Java é uma linguagem lenta já está ficando pra trás. E não fazer comparações de qual é melhor, ou mais veloz.
Deveríamos ficar felizes por isso e não começar mais uma vez essa velha baboseira de que Java é melhor que C, e vice-versa. Até porque isso nunca levou (e nem levará) ninguém a lugar algum.
Não programo em C, nem tenho nada contra a linguagem, até acho que se não tivesse me afeiçoado ao Java, com certeza, C seria a minha opção.
São linguagens diferentes, paradigmas diferentes, métodos diferentes e formas diferentes de se programar.
Francamente, é besteira continuar falando nisso. As palavras acabam sendo mal interpretadas, e isso pode gerar conflito nas relações entre nós, membros do portal.

Gostei de saber que o Java tá melhorando e é isso que esse tópico deveria visar…

Abraços a todos…
… e, por favor, não interpretem mal minhas palavras.

“thai”:

Oi gente, desculpa o que eu vou dizer, mas é o seguinte: acho que este tópico já deu o que tinha que dar.
Digo isso porque acompanhei esta discussão, embora não tenha postado nenhum tópico nela.
O que entendi a princípio foi que quando o Felipe abriu este tópico, ele quis mostrar que o Java tá evoluindo cada vez mais, o que é muito bom.
A idéia, acredito eu, era usar o C como um referencial para mostrar como o velho tabu que Java é uma linguagem lenta já está ficando pra trás. E não fazer comparações de qual é melhor, ou mais veloz.
Deveríamos ficar felizes por isso e não começar mais uma vez essa velha baboseira de que Java é melhor que C, e vice-versa. Até porque isso nunca levou (e nem levará) ninguém a lugar algum.
Não programo em C, nem tenho nada contra a linguagem, até acho que se não tivesse me afeiçoado ao Java, com certeza, C seria a minha opção.
São linguagens diferentes, paradigmas diferentes, métodos diferentes e formas diferentes de se programar.

Francamente, é besteira continuar falando nisso. As palavras acabam sendo mal interpretadas, e isso pode gerar conflito nas relações entre nós, membros do portal.

Gostei de saber que o Java tá melhorando e é isso que esse tópico deveria visar…

Abraços a todos…
… e, por favor, não interpretem mal minhas palavras.

mandou muito bem thai estou totalmente de acordo com vc, acho tbm q isso ja esta indo para um lado não muito legal.
fico por aqui tambem.

cÊ é foda hein?
uau…

q q tem o cara ter poucos posts no portal java e por isso estar na classificação de java baby?

o cara pode saber mais que vc e vc não sabe!

numero de posts não quer dizer nada, se fosse assim eu tava manjando mais que o vinci, por exemplo

aff… cada um…

“microfilo”:

cÊ é foda hein?
uau…

q q tem o cara ter poucos posts no portal java e por isso estar na classificação de java baby?

o cara pode saber mais que vc e vc não sabe!

numero de posts não quer dizer nada, se fosse assim eu tava manjando mais que o vinci, por exemplo

aff… cada um…

caramba vc fica com preguiça de ler os topicos todos eu ja expliquei isso num topico depois, para de interpretar as coisas errado rapais!!!
eu nao quis dize nada disso eu ja falei. nao quero mais falar nesse topico c quizer falar alguma coisa refente a esse topico manda uma mensagem pr mim falou. chega!!

“Ejunior”:

ola realmente me expressei mal com o tanob, peços desculpas …
mas é eu mesmo q tenho q aprender OO como vc ensinuou!
bom Java é completamente orientado a objeto Sim! nao estou dizendo q outra linguagem nao seja, se no livros q vc leu nao esta java, me desculpe mas vc não pode ter lido todos, ou leu? sobre os testes a galera ja postou ai vc não viu?? nao posso fazer nada c não acredita. bom não sou fanatico em java, mas nesse teste específico foi mais rapido, da uma olhada no q eu disse no começo desta pagina sobre as camadas de linguagem de baixo nivel em diante o C esta em vantagem pois esta em nivel mais baixo onde java teria q passar por esses niveis primeiro. como se alguem apostase uma corrida e dissese pr o outro corredor vai na frente depois eu vou. mas java evolui muito desde suas primeiras versoes, e c nem tanto quase nada, ele é rapido, um dia essa rapides vai ter q melhorar. bom sobre o q java nao tem como herança multipla é por isso q ele usa interfaces para q possa suprir muitas das vantagens de HM sem os seus devidos problemas q se associan-se . ta ficando muito grande este texto só pr terminar é estranho um java baby entra aqui so por causa dessa discursao, ou será q é amigo do tanob ou criou outro usuario hehe, bom chega desse assunto.

Java Baby é legal! Espero nunca deixar de ser Java Baby, nem C Baby, C++ Baby, Assembly Baby, Perl Baby, Prolog Baby, Lisp Baby, etc Baby. Julguem o que eu sei ou o que eu deixo de saber pelo que falo, e pela coerência do que falo, mesmo que não concordem. Realmente não li todos os livros de OO, mas li alguns do Booch, do Rumbaugh, Jacobson e Kristen Nygaard(considerado o pai da orientação a objeto). Mas com certeza o Gustavo se expressou muitíssimo melhor que eu.

Me envolvi na discução porque achei que tinha muita paixão envolvida. Guardemos as paixões para as moças e os times de futebol. Linguagem é linguagem, tem que ter dado devidamente cronometrado como o sparch mandou. Ai tem fundamento. Baseado em dados posso dizer para o meu chefe que vamos botar o sistema no cliente X baseado em Java pq é mais rápido.

Acredito que java é mais rápido principalmente para aplicações corporativas. Por exemplo, todo mundo sabe que servlet é mais rápido que script cgi, seja ele escrito em perl, python ou c. Pq? pq o tomcat fornece mecanismos de cache e outras mutretas. Java tende a crescer mais que C ou C++ pelo simples fato de o mercado estar se dividindo em Java e .NET. Ai não tem como competir, vão se gerar mecanismos de otimização que realmente vão suplantar C e C++. Mas por enquanto ainda sinto a máquina dar uma agachadinha para aplicações desenvolvidas em Java, não teste, mas aplicações reais. Trabalho com ferramentas como Visual Paradigm, OptimalJ e Eclipse e realmente dá uma agachada em relação a concorrentes como o Rational Rose e o Anjuta.

Espero ter contribuído.

T+

Rafael

Somente comentando uma coisa que li acima…

Java não é 100% orientado a objetos não!
Muita gente pensa que é… mas não é… e pq?!
Pq, ele tem tipos primitivos, assim como o C++, apesar de ter essas classes Wrapper Integer, Float, Boolean, etc etc… Smaltalk é puramente OO!!!

Abraços!

nunca senti falta de java não ser “puramente” OO

Acho que ninguém sente. Linguagens puristas são ruins de trabalhar. Contudo a definição do conceito é importante para que saibamos do que estamos falando.

Olá Pessoal,

Fiquei contente qdo soube q as aplicações em Java melhoraram seu rendimento, isso me fez acreditar muito mais na linguagem. Não espero q Java seja mais rapido q o C, só espero q as aplicações graficas rodem em desktop sem precisar d um PC top d linha pra isso.
Outra coisa, C é uma linguagem q por permitir trabalhar com ponteiros e registros, facilita o desenvolvimento d aplicaçòes d baixo nivel, como por exemplo a criação d drivers ou compiladores, ou ainda Maquinas Virtuais.
Acredito, q essas linguagens vao continuar por muito tempo, pq nao sao concorrentes. São linguagens criadas com propósitos específicos e servem muito bem à esse propósito.

Cara, esses testes só levam em consideração o incremento de variáveis primárias e atribuição de memória!

A fama de lentidão do java é por causa da alocação de memória, imagino que se tu desse uns new x malloc teria um resultado bem diferente, mas aí o c estaria em vantagem tb, não dah pra comparar um objeto java com uma estrutura c. Não tem como comparar java e c puramente, pq pra isso ou tu vai estar subutilizando o java, ou favorecendo o C. Tente JAVA x C++, é mais justo

[]´s

Daniel Gazineu

O problema de velocidade em Java é carregar classes pra memória, principalmente quando se tem telas (interface). Telas em Java são lentas.

Havendo muita memória, sem problemas.

Onde seja que haja lentidão em Java, não é por culpa da linguagem em si, mas é culpa da JVM que precisam interpretar o bytecode e convertê-los em instruções executáveis apropriadas para a plataforma na qual está rodando o programa.

Sem mais,
Rodrigo

um swing bem programado é bem rápido

Uma coisa que vale lembrar é que para construir uma VM é necessário passar por mais de 23 mil testes de compatibilidade.

Porêm TODOS os testes são de compatibilidade. Não existe nenhum de desempenho…

Hoje a VM da sun esta bastante rapida, inclusive com Swing. Mas isso não garante que se pegarmos uma outra VM os resultados de desempenho serão bons também…

[]´s Victor…

mais um teste, agora com C++

codigo C++:

#define LOOP 100000000
class teste{
 int x;
 public:
  teste(): x(0){}
};
int main(){
 teste *t;
 for (int i = 0; i < LOOP; i++){
  t = new teste();
  delete(t);
 }
}

codigo Java:

public class Teste{
 private static final int LOOP = 100000000;
 public static void main(String args[]){
  X x;
  for (int i = 0; i < LOOP; i++){
   x = new X();
  }
 }
}
class X{
 private int x;
 public X(){
  x = 0;
 }
}

resultado:

Ja que todos estavam fazendo o seu, resolvi eu tambem fazer meu teste.
. Não utilizei nenhum tipo de otimização.
. Não utilizei relógio, acho mais fácil calcular o tempo dentro do próprio programa.
. Não peguei nenhum programa listado aqui anteriormente, até porque existiam aqui alguns que nem compilavam ou tinha excessões que não eram tratadas.

Os dados que encontrei estão ai e espero que ajude a quem precise desta informação.

Java e C são linguagens de programação que tem seus devidos propósitos. Ao invés desta discução que ja dura cerca de nove paginas e não chega a lugar nenhum, porque não discutir quais propósitos que uma ou outra melhor se aplica.
Eu pelo menos não pretendo deixar de programar em uma linguagem ou outra por motivo de uma deficiencia encontrata em uma ou outra linguagem.
Guerra santa todos sabemos como acabam.

Sujestão:
Vamos aproveitar o forum para avaliar um código, talvez o proposto abaixo ou outro qualquer (que compile), vamos executar cada um em nossa própria maquina e postar os resutados, se assim vocês ficarem felizes, vamos controlar o tempo via o próprio programa, sabe como é não confio em relogio que eu não estou vendo.
Então quem sabe depois postamos os resultados, geramos uma planilha, quem sabe até usamos a do exell ou calc (openoffice) e chegamos a um resultado mais preciso.
Mesmo assim todos continuarão trabalhando e usando suas linguagens para seus devidos propósitos e então haverá paz na terra aos programadores de boa vontade novamente.

Agradecimentos especiais :
A Galera la do trabalho, que apesar desta guerra santa consegue tocar as coisas na esportiva e cumprir seus prazo cada um com sua especialidade e Tbem ao Cassio que deu uma força com um código legal para o teste.

Uma observação quanto ao propósito de uso de uma linguagem:
O forum do portaljava que tem mensagens como “o php nunca vai ser tão bom quanto o java” é feito em PHP

#include <stdio.h>
#include <stdlib.h>
#include <time.h>

#define LIMIT 200000

static void qsort_b(int *c,int start,int end){
	int comp = c[start], tmp;
	int i = start,j = end + 1;
	if(end <= start) return;
	for(;;){
		do i++; while(i<end && c[i]<comp);
		do j--; while(j>start && c[j]>comp);
		if(j <= i)   break;
		tmp = c[i];
		c[i] = c[j];
		c[j] = tmp;
	}
	c[start] = c[j];
	c[j] = comp;
	qsort_b(c,start,j-1);
	qsort_b(c,j+1,end);
}

static void qsort_a(int *c){
	printf("Ordenando...\n");
	qsort_b(c,0,LIMIT-1);
}

int main(int argc, char **argv){
	int i;
	int arr[LIMIT];
	time_t stm, etm;

	for(i=0;i<LIMIT;i++){
		arr[i] = rand();
	}

	printf("Programa Carregado... \n");

	time(&stm);
	qsort_a(arr);
	time(&etm);
	printf("Time =  %ld\n", (etm -stm) );

/*
	for(i=0;i<LIMIT;i++)
		printf("%d ", arr[i]);

	printf("\nDone ;-)\n");
*/

	return 0;
}

public class pSimpleQuicksort {

	private static final int LIMIT = 200000;

	public static void qsort(Comparable[] c,int start,int end){
		if(end <= start) return;
		Comparable comp = c[start];
		int i = start,j = end + 1;
		for(;;){
			do i++; while(i<end && c[i].compareTo(comp)<0);
			do j--; while(j>start && c[j].compareTo(comp)>0);
			if(j <= i)   break;
			Comparable tmp = c[i];
			c[i] = c[j];
			c[j] = tmp;
		}
		c[start] = c[j];
		c[j] = comp;
		qsort(c,start,j-1);
		qsort(c,j+1,end);
	}

	public static void qsort(Comparable[] c){
		System.out.println("Ordenando...");
		qsort(c,0,c.length-1);
	}

	public static void main(String[] args){
		int i;
		Integer[] arr = new Integer[LIMIT];

		for(i=0;i<arr.length;i++){
			arr[i] = new Integer((int)(Math.random()*99));
		}

		System.out.println("Programa Carregado... \n");

		double time1 = System.currentTimeMillis();
		pSimpleQuicksort.qsort(arr);
		double time2 = System.currentTimeMillis();
		System.out.println("Time =  " + (time2 -time1) );

/*
		for(i=0;i<arr.length;i++)
			System.out.print(arr[i]+" ");

			System.out.println("\nDone ;-)");
*/
	}
}

Maquina : Sun-Blade-100
SO: SunOS 5.9
Cpu Type: sparcv9
FPU Type: sparcv9
Mhz: 502
Memoria: 256MB

for ((i=0; i<5; i++)) ; do
> time ./pSimpleQuicksort
> done
Programa Carregado…
Ordenando…
Time = 0

real 0m0.478s
user 0m0.360s
sys 0m0.020s
Programa Carregado…
Ordenando…
Time = 0

real 0m0.487s
user 0m0.370s
sys 0m0.020s
Programa Carregado…
Ordenando…
Time = 0

real 0m0.488s
user 0m0.390s
sys 0m0.010s
Programa Carregado…
Ordenando…
Time = 0

real 0m0.419s
user 0m0.390s
sys 0m0.020s
Programa Carregado…
Ordenando…
Time = 0

real 0m0.470s
user 0m0.370s
sys 0m0.010s

[ tmp]$ java131
[ tmp]$ javac pSimpleQuicksort.java
[ tmp]$ for ((i=0; i<5; i++)) ; do time java pSimpleQuicksort; done
Programa Carregado…

Ordenando…
Time = 1007.0

real 0m2.092s
user 0m1.680s
sys 0m0.250s
Programa Carregado…

Ordenando…
Time = 1025.0

real 0m2.080s
user 0m1.730s
sys 0m0.240s
Programa Carregado…

Ordenando…
Time = 979.0

real 0m1.990s
user 0m1.710s
sys 0m0.210s
Programa Carregado…

Ordenando…
Time = 971.0

real 0m1.979s
user 0m1.630s
sys 0m0.280s
Programa Carregado…

Ordenando…
Time = 976.0

real 0m2.000s
user 0m1.630s
sys 0m0.260s

[ tmp]$ java142
[ tmp]$ javac pSimpleQuicksort.java
[ tmp]$ for ((i=0; i<5; i++)) ; do time java pSimpleQuicksort; done
Programa Carregado…

Ordenando…
Time = 950.0

real 0m2.216s
user 0m1.680s
sys 0m0.150s
Programa Carregado…

Ordenando…
Time = 916.0

real 0m1.923s
user 0m1.710s
sys 0m0.130s
Programa Carregado…

Ordenando…
Time = 949.0

real 0m1.986s
user 0m1.690s
sys 0m0.150s
Programa Carregado…

Ordenando…
Time = 927.0

real 0m1.960s
user 0m1.750s
sys 0m0.120s
Programa Carregado…

Ordenando…
Time = 992.0

real 0m2.000s
user 0m1.750s
sys 0m0.170s

[ tmp]$ java150
[ tmp]$ javac pSimpleQuicksort.java
Note: pSimpleQuicksort.java uses unchecked or unsafe operations.
Note: Recompile with -Xlint:unchecked for details.
[ tmp]$ for ((i=0; i<5; i++)) ; do time java pSimpleQuicksort; done
Programa Carregado…

Ordenando…
Time = 1204.0

real 0m3.030s
user 0m2.140s
sys 0m0.190s
Programa Carregado…

Ordenando…
Time = 1212.0

real 0m2.439s
user 0m2.140s
sys 0m0.160s
Programa Carregado…

Ordenando…
Time = 1153.0

real 0m2.370s
user 0m2.100s
sys 0m0.190s
Programa Carregado…

Ordenando…
Time = 1168.0

real 0m2.389s
user 0m2.050s
sys 0m0.220s
Programa Carregado…

Ordenando…
Time = 1153.0

real 0m2.420s
user 0m2.050s
sys 0m0.220s

Maquina : i386
SO: Linux (kernel 2.4.18-3)
Cpu Type: Intell Pentium II
FPU Type: Intell Pentium II
Mhz: 350
Memoria: 256MB

processor : 0
vendor_id : GenuineIntel
cpu family : 6
model : 5
model name : Pentium II (Deschutes)
stepping : 2
cpu MHz : 349.201
cache size : 512 KB
fdiv_bug : no
hlt_bug : no
f00f_bug : no
coma_bug : no
fpu : yes
fpu_exception : yes
cpuid level : 2
wp : yes
flags : fpu vme de pse tsc msr pae mce cx8 sep mtrr pge mca cmov pat pse36 mmx fxsr
bogomips : 696.32

[pleao@Hipolitta tmp]$ for ((i=0; i<5; i++)) ; do time ./pSimpleQuicksort ; done
Programa Carregado…
Ordenando…
Time = 0

real 0m0.370s
user 0m0.340s
sys 0m0.000s
Programa Carregado…
Ordenando…
Time = 0

real 0m0.362s
user 0m0.330s
sys 0m0.000s
Programa Carregado…
Ordenando…
Time = 1

real 0m0.364s
user 0m0.330s
sys 0m0.020s
Programa Carregado…
Ordenando…
Time = 0

real 0m0.364s
user 0m0.350s
sys 0m0.010s
Programa Carregado…
Ordenando…
Time = 0

real 0m0.366s
user 0m0.350s
sys 0m0.000s
[pleao@Hipolitta tmp]$ for ((i=0; i<5; i++)) ; do time java pSimpleQuicksort ; done
Programa Carregado…

Ordenando…
Time = 1012.0

real 0m2.335s
user 0m2.080s
sys 0m0.120s
Programa Carregado…

Ordenando…
Time = 1045.0

real 0m2.370s
user 0m2.180s
sys 0m0.080s
Programa Carregado…

Ordenando…
Time = 975.0

real 0m2.270s
user 0m2.060s
sys 0m0.070s
Programa Carregado…

Ordenando…
Time = 1730.0

real 0m3.070s
user 0m2.630s
sys 0m0.330s
Programa Carregado…

Ordenando…
Time = 957.0

real 0m2.320s
user 0m2.160s
sys 0m0.030s
[pleao@Hipolitta tmp]$ java -version
java version “1.5.0_02”
Java™ 2 Runtime Environment, Standard Edition (build 1.5.0_02-b09)
Java HotSpot™ Client VM (build 1.5.0_02-b09, mixed mode, sharing)[

Reaquecendo o tópico:

http://kano.net/javabench/

é a velocidade hibersonica do tiger

Olha soh…
Eu botei o seguinte codigo:

public class Teste{
 private static final int LOOP = [telefone removido];
 public static void main(String args[]){
  X x;
  long ini,fim;
  ini=System.currentTimeMillis();
  for (int i = 0; i < LOOP; i++){
   x = new X();
  }
  fim=System.currentTimeMillis();
  System.out.println("Time: "+(float)( (float)(fim-ini)/1000.0f)+" s");
 }
}
class X{
 private int x;
 public X(){
  x = 0;
 }
}

java Teste
Time: 68.89 s

java -server Teste
Time: 61.265 s

Excelsior JET (Java native compiler) - (Gera código nativo!!!)
Teste.exe
Time: 1.031 s

8O 8O 8O 8O 8O 8O 8O

Fiquei de cara!!!

O o JET é evaluation (30 dias) mas gostei muito!!!
Eu compilei o SwingSet2 do jdk pra ver se tinha suporte a Swing e tudo… e ficou perfect!!!
SwingSet2.exe!!!
Achei sensacional pra quem quer desenpenho e nao precisa de portabilidade!
Não sei se existe o JET pra linux… mas pra linux tem o GCJ que também compila em native code, mas nao tem suporte a Swing… parece que o suporte é pra Java1.1

Mas acho legal vcs q tem linux na mão aí… tentarem algo aí!!!
Ele vem com o GCC.

É isso aí… alguem ja usou o JET por aí?!

mas compilando com o JET, o usuario vai precisar ter o jre instalado? (se nao me engano o JBuilder compila pra .exe, mas mesmo assim precisa do jre)

o arquivo fica com mais de 10MB?

Teoricamente não, mas ainda tenho q testar isso!!

What is required for a JET-compiled application to work: JRE, JET run-time DLLs?
The answer is complex:

The run-time DLLs are not required if you are using the JetPerfect Global Optimizer plug-in (available only for the Professional Edition.)

  The JRE is not required if:
     1. You are using Excelsior JET, Professional Edition;
     2. Your application runs on J2SE 1.3 or 1.4; and
     3. Your application does not use any of the GUI-related Java 2 platform classes (AWT, Swing, JPEG, etc.) or the JDBC-ODBC bridge

…
Pois intaum… se vc usar Swing, AWT, JDBC… aí precisa da JRE.
Ele precisa das DLLs da JRE.
Mas ele não é como o gerador de EXE do JBuilder não, ele gera código nativo!!! Como se fosse C mesmo.
Mas é claro, precisa linkar alguns recursos da JRE se necessário.
So lembrando que na instalação de JET ele demorou uma hora e meia mais ou menos no meu AThlon 2800+ 512Mb , ele compila um monte de coisas!
É, não é o ideal, mas é legal conhecer essas coisas!!

Falow!

PS.:http://www.excelsior-usa.com/jetfaq.html

se com a Professional Edition o aplicativo alem de rodar sem a jre ele nao ficar enorme, ai sim eh interecante… pois dai eh possivel fornecer aos clientes o arquivo .jar portavel e para facilitar pro usuario fornesse o arquivo nativo tambem…

eu pesquisei na internet e parece que tem versao do JET pra linux tb!

Windows:

1. Click on the link below to begin the download:

http://www.excelsior-usa.com/download/jet-370-eval-en-win32-90days.exe

2. Launch the downloaded executable and follow the on-line prompts.

Linux:

1. Click on the link below to begin the download:

http://www.excelsior-usa.com/download/jet-370-eval-en-linux-90days.bin

Mas é trial… :sad:

Hohoho

que tesão hein!!!

Botei fé agora nos benchmarks feitos ai

very very cool!!!

Poderia aparecer um loko que manjasse horrores de C/C++ para esquentar mais isso ai né!!

quem sabe!!!

Divulguem por ai!

Cya!

que comédia.
mas cada um enxerga o que quer ver…