mslomp
(usa Slackware)
Enviado em 30/09/2008 - 22:00h
e particularmente para quem deseja aprender C e/ou C++, o Assembly fará com que alguns conceitos sejam trazidos à luz de forma mais prática e menos cabalística, como é o caso dos ponteiros (que são famosos por causarem confusão tanto para iniciantes quanto para experts).
é claro que, no caso do Pedro (o autor do tópico), não há necessidade de que ele deva tornar-se um guru da progrmação, haja visto que ele está estudando estatística, e não algo como ciência da computação. porém, mesmo como matemático, é importante observar que a matemática hoje utiliza a computação largamente, por motivos óbvios. sendo assim, um sólido conhecimento em programação irá agregar a ele muito valor como profissional, e com certeza isso será um grande diferencial num mercado concorrido como o atual.
em relação a linguagens como Java, conforme citado pelo stremer, há um fator crucial no que tange o desempenho da mesma em aplicações realmente críticas, e essa nem sempre é culpa do fato de possuir uma máquina virtual como pano de fundo, e sim do programador. uma máquina virtual nada mais é do que uma camada executiva operando sobre outra (o hardware real). a máquina virtual executará suas instruções, baseada nos seus bytecodes pré-programados e então a partir de cada combinação irá instruir (ou traduzir) o hardware real, que enfim executará no ambiente real. a grosso modo, uma máquina virtual é um interpretador de bytecodes. embora o compilador (tradutor para bytecodes) do java efetue diversas otimizações, a máquina virtual (que é um software) já possui estaticamente embutidos diversos métodos de operação conforme os bytecodes fornecidos. é aí que começa o problema. eu sei, fãs do Java, ela não é interpretada. ao menos não no sentido literal, mas comporta-se como tal sob alguns aspectos (como o que citei acima). exemplo clássico aplicado às linguagens interpretadas (amigos fãs de php, python e etc, reflitam isso) e que de certa maneira também afeta as baseadas em máquinas virtuais: o problema do laço for. na máquina virtual (ou num interpretador) já estão lá "impressas" as instruções sobre como traduzir o for para a máquina real (digamos, através de comparações e instruções do tipo jump).
aí o programador faz algo tipo:
for(i=0;i<=1000;i++)
x=i;
ok. como o exemplo é simples, mais uma vez a fins de entendimento apenas, desconsidere otimizações para o caso do compilador Java, supondo que esse laço for seja realmente transformado em uma série de jumps e comparações (em bytecode) conforme o pré-determinado na máquina virtual.
então suponhamos que a máquina virtual faça a seguinte tradução para o hardware real, baseando-se em seu template embutido para o laço for:
; eax fará o papel de x. ecx fará o papel de i
xor ecx,ecx
loop:
cmp ecx,1000d
jg exit
mov eax,ecx
inc ecx
jmp loop
exit:
ou seja: entre loop: e jmp loop (inclusive), serão executadas 5 instruções 1001 vezes (pois começa com ecx=0, e não estou contando a última vez incompleta com ecx=1001).
mas aí o programador recebe uma luz divina e resolve mudar tudo, fazendo pelo método mais difícil, tedioso, ilegível e aparentemente burro:
x = 0;
x = 1;
x = 2;
...
x = 1000;
dá uma trabalheira né? para nós sim, mas olhemos lá no outro lado da história:
mov eax,0d
mov eax,1d
...
mov eax,1000d
nosso amigo processador deve agora uma cerveja ao programador, pois reduziu seu trabalho a 1/5 do anterior - apenas 1 instrução sendo executada 1001 vezes, mudando-se apenas a abordagem lá na camada humana da coisa. o prejuízo está apenas no tamanho de código, mas aumentamos mais do que consideravelmente seu desempenho.
mas claro que isso não desmerece Java nem qualquer outra linguagem que se comporte de maneira semelhante. apenas discutimos aqui o uso das linguagens em aplicações (realmente) críticas, e para tais aplicações o melhor mesmo é permanecermos mais próximos da máquina (real), ainda que isso nos distancie um pouco da linguagem humana.