Programar é simplesmente conversar com o computador. Ele é como uma pessoa que só sabe seu idioma nativo, a linguagem de máquina (código binário). Esta é extramamente difícil para humanos lidar. Nós temos facilidade de memorizar palavras e construir frases de natureza alfabética. Porque frases alfabéticas possuem poucas variedades de sentido.
O que é mais fácil para você decorar e entender?
1 - "Olá, meu nome é Caio e tenho 21 anos"
2 - "12367181822929292929292929292004004100"
Eu nem sei o que significa a frase 2. Pode ser muita coisa, depende do contexto.
A linguagagem de máquina é composta somente por 0 e 1.
103 -> linguagem de máquina -> 01100111
Porque é desse jeito? Simples, porque as unidades básicas de processamento do computador, as portas lógicas, operam em duas voltagens 0V e 5V. Respectivamente, 0 e 1. Sobre essas circunstâncias é mais fácil trabalhar com binário.
Agora, imagine nós conversamos com o computador em binário. Inferno é a palavra para descrevermos isso. E como conversa? Através de mudanças diretas nas voltagens do computador, nas placas de hardware.
Então, alguns caras inventaram modos mais simples. A pessoa escreve em texto naquela linguagem e manda para um tradutor, o qual passa o texto para linguagem de máquina. Este é chamado de compilador.
Atualmente, existem muitas linguagens de programação. Basicamente, são separadas em linguagens de baixo e alto nível.
Programar em baixo nível significa escrever programas em linguagens muito "próximas" do computador.
Ex: Assembly
Nesta linguagem a pessoa tem que dar instruções específicas para o processador. Como qual seguimento de memória acessar, com quais registradores trabalhar e muito mais.
Programar em alto nível significa ficar mais "distante" do computador.
Ex: Java, C/C++
O compilador destas linguagens são muito mais inteligentes. O processamento é bem mais intenso. Contudo, isso é transparente para quem está programando.
Exemplo:
Código de soma de matrizes.
Assembly - retirado de http://www.forumpcs.com.br/viewtopic.php?t=42554, postado por "Target"
TITLE Matriz
.MODEL SMALL
.STACK 100H
.DATA
LF EQU 0AH
CR EQU 0DH
MSG1 DB 'Digite a primeira matriz:',LF,CR,'$'
MSG2 DB 'Digite a segunda matriz:',LF,CR,'$'
MSG3 DB 'A matriz soma e:',LF,CR,'$'
MATRIZ1 Dw ?,?,?
Dw ?,?,?
Dw ?,?,?
MATRIZ2 Dw ?,?,?
Dw ?,?,?
Dw ?,?,?
.CODE
MOV AX,@DATA ;inicializando DS
MOV DS,AX
;matriz 1
LEA DX,MSG1
MOV AH,9
INT 21H
XOR BX,BX ;zerando BX e SI
XOR SI,SI
MOV CX,3
M1: MOV AH,1
INT 21H
MOV MATRIZ1[BX][SI],Ax ;pegando os dados da primeira matriz
MOV AH,2
MOV DL,' '
INT 21H
ADD SI,2
DEC CX
JNZ M1
MOV AH,2 ;pulando de linha
MOV DL,CR
INT 21H
MOV DL,LF
INT 21H
MOV CX,3
ADD BX,2
MOV AX,4
CMP BX,AX
JBE M1 ;salta para M1 se BX for menor ou igual a 4
MOV AH,2 ;pulando de linha
MOV DL,CR
INT 21H
MOV DL,LF
INT 21H
;matriz 2
LEA DX,MSG2
MOV AH,9
INT 21H
XOR BX,BX ;zerando BX e SI
XOR SI,SI
MOV CX,3
M2: MOV AH,1
INT 21H
MOV MATRIZ2[BX][SI],Ax ;pegando os dados da primeira matriz
MOV AH,2
MOV DL,' '
INT 21H
ADD SI,2
DEC CX
JNZ M2
MOV AH,2 ;pulando de linha
MOV DL,CR
INT 21H
MOV DL,LF
INT 21H
MOV CX,3
ADD BX,2
MOV AX,4
CMP BX,AX
JBE M2 ;salta para M2 se BX for menor ou igual a 4
;somando
LEA DX,MSG3
MOV AH,9
INT 21H
XOR BX,BX ;zerando BX e SI
XOR SI,SI
MOV CX,3
SOMA: XOR DX,DX
XOR AX,AX
MOV DX,MATRIZ1[BX][SI] ;somando as matrizes
MOV AX,MATRIZ2[BX][SI]
ADD AX,DX
SUB AX,30H
MOV DX,AX
MOV AH,2
INT 21H
MOV DL,' '
INT 21H
ADD SI,2
DEC CX
JNZ SOMA
MOV AH,2 ;pulando de linha
MOV DL,CR
INT 21H
MOV DL,LF
INT 21H
MOV CX,3
ADD BX,2
MOV AX,4
CMP BX,AX
JBE SOMA ;salta para SOMA se BX for menor ou igual a 4
MOV AH,4CH ;finalizando para o DOS
INT 21H
END
Em Java o mesmo código:
public class MatrizSoma {
private byte[][] matriz;
public MatrizSoma(byte[][] matriz) {
this.matriz = matriz;
}
public byte[][] somar(byte[][] mt) {
byte[][] mat = new byte[mt.length][mt[0].length];
for(int i = 0; i < matriz.length; i++) {
for(int j = 0; j < matriz[i].length; j++) {
mat[i][j] = (byte) (matriz[i][j] + mt[i][j]);
}
}
return mat;
}
}
Percebeu as diferenças?
Em linguagens de alto-nível o código é mais enxuto e mais fácil de entender. Na maioria delas a única coisa que você tem controle é sobre o que fazer e não de como fazer. Perde-se o controle do que internamente está sendo feito.
Existem linguagens de alto-nível que estão mais perto do computador do que as outras.
C/C++ é mais baixo-nível que Java
