Linguagens de programação

Os computadores são funcionários quase perfeitos. Fazem tudo o que mandamos, não reclamam, não se importam de trabalhar até tarde da noite, não cobram hora extra nem tiram férias. Mas, em compensação, também não pensam. Para que façam qualquer coisa é preciso explicar tudo com os mínimos detalhes e na língua deles.

Considerando que tudo o que os computadores conseguem entender são seqüências intermináveis de números binários, fornecer estas “instruções” pode ser muito penoso para um ser humano. Você consegue se imaginar lendo um manual de 5.000 páginas e decorando um a um centenas de códigos binários que representam as instruções do processador?

Se os programadores precisassem programar diretamente em binários, decorando seqüências como 10111011101101101110110011001010 para cada instrução do processador e para cada endereço de memória a ser acessado, provavelmente não teríamos mais programadores; já estariam todos loucos.

Para facilitar as coisas, começaram a ser desenvolvidas as linguagens de programação, que diferem na sintaxe e recursos, mas têm um ponto em comum, que é a existência de um compilador. Seja programando em C, ou seja em Kylix, você usará um editor para escrever seu programa, respeitando as regras da linguagem escolhida e em seguida rodará o compilador, que interpretará os comandos que formam o seu programa e os transformará em um arquivo binário, que contém as instruções binárias que são entendidas pelo processador.

No Windows não temos muito contato com código fonte, pois os programas são quase sempre distribuídos apenas em formato binário, que você não tem como alterar. Mas, no caso do Linux, temos a possibilidade de baixar o código fonte de praticamente todos os programas que usamos no dia-a-dia. Muita gente aprende a programar fuçando no código fonte de algum programa que conhece bem, começando com pequenas traduções e mudanças, e acaba entendendo bem a sintaxe da linguagem e vários dos truques usados. Depois de cada rodada de alterações, é possível compilar todo o código, abrir o programa e verificar de que forma elas alteraram o programa final.

A vantagem de usar linguagens de programação é que o desenvolvedor passa a trabalhar com instruções como “if”, “else”, etc. além de todas as facilidades oferecidas pela linguagem ao invés de gigantescos endereços binários. Sem dúvida muito mais simples.

Existem diversas linguagens de programação. Meu objetivo aqui é dar algumas noções básicas sobre as peculiaridades e utilidade de algumas delas

Para começar, existe uma linguagem “básica” para quem quer aprender a programar, ensinada nos cursos de lógica da programação, o pseudocódigo. Ele não é uma linguagem “de verdade”, mas sim uma maneira mais simples para aprender os fundamentos usados em todas as linguagens de programação.

Podemos começar com um exemplo simples. Vamos fazer um programa capaz de tomar uma decisão fácil. Ele pergunta a nota do aluno e diz se ele passou ou não. Para um ser humano isso seria um problema muito elementar, mas para o computador as coisas não são assim tão simples. Lembre-se de que ele é burro e precisa ser orientado passo a passo. Nosso programinha em pseudocódigo poderia ficar assim:

escreva: “Qual é a nota do aluno?”
leia nota

se nota maior ou igual a sete
então:
escreva “Ele passou”
senão:
escreva: “Ele foi reprovado”

fim do se
fim do programa

Este programinha perguntaria a nota e, com base no número que for digitado, avisaria se o aluno passou ou não.

Ele poderia ser escrito em qualquer linguagem, mas a lógica seria a mesma. De acordo com os recursos oferecidos pela linguagem escolhida, ele poderia ter uma interface simples em modo texto, uma interface gráfica mais trabalhada, aparecer no meio de uma pagina web e assim por diante. O mesmo programinha escrito em shell script, a linguagem mais elementar que temos no Linux, onde utilizamos comandos de terminal, poderia ficar assim:

echo “Qual é a nota do aluno”
read nota

if [ “$nota” -ge “7” ] then
echo “Ele passou”
else
echo “Ele foi reprovado”
fi

As linguagens de programação são conjuntos de padrões e comandos que você pode usar para dar ordens para nossos amigos burros.

Assim como nas línguas faladas, existem diferenças de sintaxe, gramática e existem linguagens mais simples ou mais complicadas de aprender e linguagens mais adequadas para cada tipo de tarefa a realizar. Veja alguns exemplos de linguagens de programação:

– Assembly: O Assembly foi provavelmente a primeira linguagem de programação da história, surgida na década de 50, época em que os computadores ainda usavam válvulas. A idéia do Assembly é usar um comando em substituição a cada instrução de máquina.

No Assembly, cada uma destas instruções equivale a uma instrução do processador. Ao invés de usar instruções como 10101011, você pode usar outras bem mais fáceis de entender e de memorizar, como add, div, mul, and, or, not, etc. Você também pode criar variáveis, que são pequenos espaços na memória RAM reservados para guardar algum tipo de informação, que o programa precisará mais tarde. Você pode usar aquelas instruções que citei para lidar com elas. Por exemplo, a instrução “add” faz com que o processador some duas variáveis; “add x, y” por exemplo, soma os valores de x e y.

Apesar de ser exaustivamente trabalhoso, você pode perfeitamente desenvolver pequenos programas em Assembly. Para isso só vai precisar de um compilador e bastante paciência para aprender. Um bom ponto de partida é baixar o MenuetOS, um sistema operacional aberto, inteiramente escrito em Assembly, que inclui todas as ferramentas e compiladores necessários para começar a programar. Na página você encontra também alguns tutoriais e exemplos:
http://www.menuetos.net/

O compilador transforma o código escrito em Assembly em linguagem de máquina, que finalmente poderá ser entendida pelo processador.

Existem também os decompiladores, que fazem o trabalho inverso, de transformar um programa já compilado em código Assembly. Este recurso é chamado de engenharia reversa. É assim que conseguem crackear programas, quebrar códigos de proteção (como o do DVD), etc. Claro que para isso, é preciso alguém que conheça muito de Assembly e que tenha disposição para ficar estudando o código até encontrar o que procura.

Por causa desta característica de permitir trabalhar diretamente com as instruções do processador, o Assembly é uma linguagem de baixo nível. Existem também linguagens de alto nível, como C++ ou Pascal, onde é possível usar várias funções já prontas ou mesmo ferramentas visuais, como o Kdeveloper ou o Kylix, que são ainda mais fáceis.

Em se tratando de programação, o fato de uma linguagem ser “de baixo nível”, não significa que ela é ruim, mas apenas que ela manipula diretamente as instruções e endereços de memória e, por isso, é mais trabalhosa e voltada para o desenvolvimento de aplicativos otimizados.

– Fortran: O Fortran foi uma das primeiras linguagens de alto nível da história. Enquanto o Assembly é chamado de linguagem de baixo nível, por nele utilizarmos diretamente as instruções e endereços do processador e memória, numa linguagem de alto nível temos várias funções prontas, o que facilita muito a programação, mas em compensação torna em muitos casos o programa maior e mais pesado, já que o compilador jamais conseguirá gerar um código tão otimizado quanto um programador experiente conseguiria.

Fortran é a contração de “Formula Translator”. A primeira versão do Fortran foi criada no final da década de 50, mas a linguagem começou a ser usada em larga escala a partir da metade da década de 60, quando surgiram várias versões diferentes. Atualmente o Fortran é ainda usado em diversos aplicativos relacionados a engenharia. Ele é também ensinado em várias universidades, como uma forma mais prática de ensinar lógica da programação.

– Pascal: O Pascal é outra linguagem de alto nível, criada durante a década de 60. O Pascal é uma linguagem bastante estruturada, com regras bastante rígidas, o que a torna difícil de usar. Hoje em dia o Pascal original é pouco usado, mas seus descendentes diretos como o Free Pascal evoluíram muito. O próprio Kylix (junto com o Delphi) é uma evolução do Pascal.

– Cobol: Cobol significa “Common Business Oriented Language”. Esta linguagem foi desenvolvida no final da década de 50, com o objetivo de ser uma plataforma de desenvolvimento para aplicações bancárias e financeiras em geral. Comparado com o Pascal e o Assembly, comuns na época, o Cobol é uma linguagem relativamente amigável, o que garantiu uma grande aceitação. Até hoje esta linguagem é usada em muitos sistemas bancários, o que explica a grande procura por programadores experientes nesta linguagem na época do bug do ano 2000.

– C: O C foi desenvolvido durante a década de 70, mas ainda é largamente utilizado. A grande vantagem do C é permitir escrever tanto programas extremamente otimizados para a máquina, como seria possível apenas em Assembly, e ao mesmo tempo vir com várias funções prontas, como uma linguagem de alto nível, que podem ser utilizadas quando não for necessário gerar um código tão otimizado.

A maior parte dos programas Linux e quase todo o Kernel foram escritos em C, o que explica o porquê do sistema ser tão rápido em algumas tarefas.

– C++: O C++ mantém os recursos do C original, mas traz muitos recursos novos, como recursos orientados a objetos, sendo também bem mais fácil de utilizar. O C++ é bastante usado atualmente para desenvolver muitos programas para várias plataformas. Ele é, por exemplo, a linguagem oficial do KDE e da maioria dos programas para ele.

– Python: O Python é uma linguagem de programação com uma sintaxe muito simples e intuitiva e ao mesmo tempo bastante poderosa, que pode ser usada por toda classe de usuários. É uma boa opção de linguagem para quem está começando a programar. No Kurumin, você pode abrir o interpretador do Python em Iniciar > Sistema > Desenvolvimento.

A maior parte das distribuições instalam o Python por default. Basta abrir um terminal e chamar o comando “python”. Existe também uma versão for Windows que pode ser baixada no: http://www.python.org/download/. Ao abrir um programa, você verá um prompt como este:

Este é o interpretador do Python, um prompt onde você pode digitar um comando de cada vez e já ir vendo os resultados. Bom para ir testando os comandos enquanto você não quiser realmente desenvolver nenhum programa completo.

Vamos começar com uma coisa simples. Que tal ouvir um bom dia? Para isso podemos usar o “print” que é o comando para escrever coisas na tela. Este comando é simples de usar, basta escrever a frase entre aspas: print “Bom Dia!”.

E você terá um:

Podemos personalizar um pouco isto, fazendo com que ele primeiro pergunte o seu nome e depois dê bom dia. Para isso, podemos usar o comando “raw_input”, que lê texto digitado no teclado. Este texto precisa ser guardado em algum lugar, para armazená-lo usamos uma variável, que é um pequeno espaço de memória reservado e que pode ser usado mais tarde.

Experimente usar a linha abaixo:

nome = raw_input(“Olá, qual é o seu nome? “)

Isso faz com que ele pergunte o seu nome e fique esperando você digitar alguma coisa e dar Enter. Em seguida ele armazena o texto digitado na variável “nome” e volta para o prompt. O texto entre aspas pode ser substituído por outra coisa se quiser.

Como disse, a variável armazena dados que podem ser usados mais tarde. Como agora já temos o seu nome armazenado na variável “nome”, podemos completar nosso bom dia, fazendo com que ele escreva junto o seu nome (ou o que for que você tenha digitado no passo anterior :-):

print “Bom dia”, nome

Ele escreve a frase “Bom Dia” que está entre aspas e em seguida completa com o texto armazenado na variável “nome”. Não se esqueça da vírgula, ela indica que além de escrever o texto armazenado na variável, o interpretador deve adicionar a palavra “nome” em seguida.

Experimente agora abrir o kedit (ou outro editor de textos qualquer) e salvar nosso pequeno programa num arquivo de texto. Ele pode se chamar, por exemplo, “programa.py” (.py de python). Eu enfeitei um pouco mais o meu. Os “\n” no meio do texto são quebras de linha:

Este arquivo pode ser executado usando o interpretador do Python. Para isso, abra um terminal e chame o comando:

$ python programa.py

O programa vai fazer o mesmo que no prompt do Python, a diferença é que agora ele executa os comandos escritos no arquivo de texto ao invés de ir perguntando.

Podemos agora fazer algo usando uma instrução de tomada de decisão. Que tal perguntar a idade e com base nela decidir qual será a próxima frase do diálogo? Se o interlocutor responder que menos de 18 anos, ele pode receber um “Beleza, tem aula hoje?” e se tiver 18 ou mais recebe um “Ei, você não vai trabalhar hoje?”.

Para isso precisamos começar perguntando a idade. De volta ao nosso editor de textos acrescentamos ao que já tínhamos feito:

idade = input(“Quantos anos você tem? “)

Veja que mudamos o “raw_input” para apenas “input”. A diferença entre os dois é que o raw_input pode ser qualquer tipo de dados (letras, números, binários), enquanto o “input” serve para armazenar números.

Agora chegamos à parte mais importante, que é fazer o programa descobrir se o número digitado é maior ou menor que 18 e depois decidir qual frase deve escrever. Para isso, vamos usar a instrução “if” (se) que tem sua companheira inseparável, a “elif” (então se). Funciona assim:

if idade < 18:
print “Beleza, tem aula hoje?”

elif idade >= 18:
print “Ei, você não vai trabalhar hoje?”

Parece complicado à primeira vista, mas não é. O primeiro if verifica se o número é menor (<) que 18. Caso seja, ele escreve o “Beleza, tem aula hoje?” e o programa acaba.

Caso o número seja maior que 18, então o primeiro if não faz nada e ele passa para o elif que vai verificar se o número é maior ou igual (>=) a 18. Caso seja, ele imprime a frase “Ei, você não vai trabalhar hoje?”. Veja que eu aproveitei pra colocar mais quebras de linha, que servem para deixar a saída de texto do programa mais legível.

Como vimos, o Python pode trabalhar com expressões aritméticas, usando números e os operadores:

+ (mais)
– (menos)
* (multiplicação)
/ (divisão)
== (igual a)
!= (diferente de)
> (maior que)
>= (maior ou igual a)
< (menor que)
<= (menor ou igual a)
** (exponenciação, elevado à)

Podemos usá-los para resolver aquele problema clássico de tirar a média das notas do aluno e dizer se ele passou de ano. Digamos que sejam 4 provas e a média para passar seja 7. Precisaríamos perguntar as notas das quatro provas, tirar a média e depois usar o if e o elif para descobrir se a média é maior ou menor que 7.

O programa poderia ficar assim:

aluno = raw_input(“\n Qual o nome do aluno? “)
prova1 = input(“\n Nota da primeira prova: “)
prova2 = input(“\n Nota da segunda prova: “)
prova3 = input(“\n Nota da terceira prova: “)
prova4 = input(“\n Nota da quarta prova: “)

media = (prova1 + prova2 + prova3 + prova4) / 4
if media < 7:
print “\n Média”, media,”. Que vergonha”, aluno,”. Levou bomba!”
elif media >=7:
print “\n Média”, media,”.”, aluno, “passou. Parabéns!”

Imagine agora que você não queria saber apenas a média de um aluno, mas da sala inteira. Você precisaria que o programa ficasse perguntando as notas de todos os alunos, um por vez e depois desse a média geral.

Para isso precisamos usar a instrução “while” (enquanto), que repete uma seqüência de instruções até que uma condição seja atingida. Podemos começar o programa perguntando o número de alunos na sala e criar uma variável “contagem” com o valor zero. Cada vez que são dadas as notas de um aluno, a variável “contagem” aumenta em 1. Quando ela chegar ao número de alunos da sala, sabemos que todos foram contados. O programa ficaria assim:

alunos = input(“\n Quantos alunos esta sala tem?”)
contagem = 0
total = 0

while contagem < alunos:
contagem = contagem + 1
print “\n Notas do aluno “, contagem
prova1 = input(” Nota da primeira prova: “)
prova2 = input(” Nota da segunda prova: “)
prova3 = input(” Nota da terceira prova: “)
prova4 = input(” Nota da quarta prova: “)
total = total + prova1 + prova2 + prova3 + prova4

media = total / alunos / 4
print “\n\n A média geral da sala é”, media, “\n\n”

Este já ficou um pouco mais complexo que o anterior. Temos três novas variáveis. A variável “alunos” armazena o número de alunos da sala. A variável “contagem” começa com zero mais vai aumentando em 1 a cada vez que o programa roda. O while vai perguntando as notas e vai somando tudo na variável total. Quando finalmente o número de alunos é atingido, vamos para a parte final do programa, onde a média é calculada e escrita na tela.

Ao ser executado, o programa primeiro pergunta o número de alunos da sala e depois vai perguntando as notas de cada prova até chegar ao resultado.

O Python reconhece a parte do texto que pertence ao while pela indentação do texto. Quando acaba a indentação, acaba o while. Para indentar uma linha, basta pressionar espaço quatro vezes. Alguns editores, como o Kwrite e o Kate, possuem botões para indentar blocos de texto, o que facilita seu trabalho neste caso.

– Java: O Java é uma linguagem de programação multiplataforma, com uma sintaxe até certo ponto parecida com o C++, porém com bibliotecas diferentes. Os programas em Java podem ser executados em qualquer sistema operacional, desde que o interpretador esteja instalado.

A JVM é um programa que converte o código Java em comandos que o sistema operacional possa executar. Existem máquinas virtuais para vários sistemas operacionais: o problema é que, devido ao processamento executado pela máquina virtual, o programa torna-se mais pesado do que seria caso escrito diretamente para a plataforma.

Um exemplo de programa desenvolvido desta forma é o Mercury (um cliente MSN com versões para Linux e Windows, um dos primeiros a oferecer suporte a webcam e por isso bastante famoso). Embora o código fonte do programa seja relativamente simples e bem escrito, ele é bem mais pesado que outros programas similares, por causa da máquina virtual.

Explicando de forma mais elaborada, linguagens de programação “tradicionais”, como o C e o C++, utilizam um compilador diferente para cada plataforma ou sistema operacional em que o programa irá rodar. O código fonte em si pode ser escrito de forma a ser facilmente portável, ou seja, rodar em diferentes versões do Unix ou em várias famílias de processadores diferentes sem muitas alterações, mas ainda assim será necessário recompilar o código fonte, gerando um binário diferente para cada caso.

Embora o trabalho inicial seja maior, a vantagem desta abordagem é que o desempenho é o melhor possível, já que sempre teremos um programa binário otimizado para a plataforma.

O Java utiliza um conceito diferente. Ao invés de gerar um binário diferente para cada plataforma, é gerado um binário que pode ser executado em qualquer plataforma, dentro de uma máquina virtual. Este binário “universal” é chamado de bytecode.

A idéia é criar aplicativos que possam ser escritos uma vez e a partir daí serem executados em qualquer plataforma, reduzindo os custos de desenvolvimento. Apenas o software da máquina virtual é que precisa ser reescrito para cada plataforma, mas isso é problema dos desenvolvedores da linguagem, não do programador.

Existe ainda a opção de abrir mão da flexibilidade do bytecode em troca de um maior desempenho, passando a compilar os programas com otimizações para uma determinada plataforma. Isso é muito útil quando o programa será executado apenas dentro de computadores de uma certa plataforma, como PCs rodando Linux, por exemplo.

No caso do Java, a máquina virtual que executa os programas é chamada de Java Virtual Machine. Muitas páginas web utilizam applets Java, por isso a maioria das pessoas acaba instalando o suporte a Java. Hoje em dia, além do Java da Sun, temos versões alternativas, como o Blackdown e o Kofee, que possuem conjuntos de recursos variados, mas são a princípio compatíveis com o código gerado para o Java da Sun.

Embora tenha ganhado relevância com o Java, este conceito não é exatamente novo. Linguagens mais antigas como o LISP e o Prolog já utilizam bytecode e máquinas virtuais.

– Shell Script: Qualquer distribuição Linux inclui um número absurdo de comandos e pequenos utilitários de modo texto, que são o terror dos iniciantes, mas a alegria dos usuários mais avançados. O motivo de utilitários como o “tar”, “dump”, “dd”, “rsync” e muitos outros terem sobrevivido durante tantas décadas sem muitas modificações, não é apenas resultado do saudosismo de alguns, mas resultado do fato de que, ao contrário da maioria dos utilitários gráficos, eles podem ser combinados com outros comandos e entre si, formando scripts poderosos de backup, automatização de tarefas diversas e muitas outras coisas.

O shell script é uma espécie de linguagem universal no Linux, pois combina comandos de terminal com estruturas lógicas, similares às encontradas em outras linguagens para criar programas de poucas linhas, capazes de executar tarefas complexas. Via shell script é possível desenvolver em minutos ferramentas que demandariam horas de trabalho em outras linguagens.

Muitos dos utilitários de configuração usados nas distribuições (embora muitas vezes não pareçam) são na verdade shell scripts elaborados, que aparentam ser muito mais complexos do que realmente são.

Um exemplo de uso de shell scripts são os ícones mágicos, painéis e outras ferramentas que desenvolvi para uso no Kurumin. Uma outra vantagem é que estes programas não precisam ser compilados. Você simplesmente escreve os comandos num arquivo de texto e executa diretamente. Quando precisa fazer alguma alteração você altera o arquivo e pronto, o problema está resolvido.

Um exemplo de shell script, que serve só para mostrar uma janelinha dando olá na tela seria simplesmente: kdialog –msgbox “Olá, tudo bem?”

Não escrevi errado, ele só tem uma linha mesmo. Na verdade, quando você escreve um shell script, você simplesmente usa funções de outros programas que estão instalados, por isso ele é tão simples se comparado às linguagens de programação “de verdade” que vimos acima.

Você pode encontrar os scripts usados no Kurumin dentro da pasta “/usr/local/bin/“. Para estudá-los, você pode abrí-los em qualquer editor de texto e começar fazendo pequenas modificações, para ir aprendendo como eles funcionam.

Os painéis gráficos são desenvolvidos com a ajuda do Kommander, que permite criar scripts gráficos, usando as funções do KDE. Os arquivos vão na pasta “/etc/Painel/” e podem ser abertos usando o “kmdr-editor”, no “Iniciar > Sistema > Desenvolvimento”.

Um shell script nada mais é do que um arquivo de texto comum, contendo os comandos que serão executados, em ordem. Basicamente, se você sabe como fazer alguma tarefa via linha de comando, você não tem problemas em fazer o mesmo via shell script. Este é um exemplo de script simples, que serve para fazer backup dos arquivos de uma pasta num segundo HD, usando o rsync:

#!/bin/sh
rsync -av /mnt/hda6/ARQUIVOS/ /mnt/hdb6/ARQUIVOS

Todo shell script deve começar com a linha “#!/bin/sh” (ou “#!/bin/bash”, que tem exatamente a mesma função), que indica quem irá executar os comandos a seguir, neste caso o próprio bash, o interpretador de comandos do Linux. Na verdade, estas linhas não são realmente necessárias, pois o bash é o padrão de qualquer forma, mas não custa nada fazer as coisas de forma elegante ;-).

O rsync é eficiente para este tipo de tarefa, pois ele sincroniza o conteúdo das duas pastas transferindo apenas as modificações e não os arquivos completos, como aconteceria se você fizesse uma cópia simples. Para que este arquivo de texto vire um script, é necessário que ele tenha permissão para ser executado, o que é feito usando o comando “chmod +x”, como em “chmod +x script”.

Este é um exemplo de script bem mais complexo, que faz parte do ícone mágico para instalar o VMware Player no Kurumin. Ele faz download do arquivo, verifica se foi baixado corretamente e, se necessário, remove o arquivo e começa de novo, até ter certeza de que ele está ok. Depois, são executados os passos necessários para instalar o programa via linha de comando. No final, ele verifica se o programa foi mesmo instalado e exibe a mensagem apropriada. Este exemplo é mais complexo que os anteriores, pois minha idéia é dar um exemplo de script que é usado na prática:

#!/bin/sh
cd /packages
md5sum=`md5sum vmware-player-distrib.tar.bz2`

while [ “$md5sum” != \
“9e41fed4b2d15d3f44522e5861b4bf5a vmware-player-distrib.tar.bz2” ] do

cd /packages
rm -f vmware-player-distrib.tar.bz2
wget -c http://downloads-guiadohardware.net/vmware-player-distrib.tar.bz2
md5sum=`md5sum vmware-player-distrib.tar.bz2`
done

tar -jxvf vmware-player-distrib.tar.bz2
cd vmware-player-distrib/
sudo ./vmware-install.pl
rm -rf vmware-player-distrib/

if [ -e /usr/bin/vmplayer ]; then
kdialog –msgbox “O VMware Player foi instalado com sucesso. Você pode criar novas máquinas virtuais e alterar suas configurações usando o Kurumin-EMU, encontrado no Iniciar > Escritório e Utilitários.”

else
kdialog –msgbox “Aparentemente houve algum problema durante a instalação. Verifique se está conectado à Internet. Se o servidor do arquivo estiver fora do ar, espere alguns minutos e tente novamente.”
fi

À primeira vista, o script não parece tão simples assim, mas sem dúvida é bem mais simples que programas escritos em outras linguagens. Dentro do código, podemos notar algumas funções lógicas, como o while (enquanto), o “if” (então) e o “else” (senão).

O script começa acessando a pasta onde será feito o download e verificando se o arquivo já não foi baixado. Isso evita que ele baixe de novo se ele já foi instalado anteriormente. Em seguida temos um while, que faz com que ele execute um trecho de código repetidamente, até que uma determinada condição seja satisfeita. No caso, a condição é que o md5sum do arquivo precisa estar correto. Se necessário, ele deleta o arquivo e começa de novo.

Depois de baixar o arquivo e verificar o md5sum, ele parte para a instalação, descompactando o arquivo, acessando a pasta que é criada e executando o programa de instalação. No final ele verifica (if [ -e ) se o executável “/usr/bin/vmware” existe, um indício de que o programa foi realmente instalado. Se algo de errado aconteceu e o executável não existe, ele exibe uma mensagem avisando do problema.

Hoje em dia, muitos programas gráficos podem ser controlados via linha de comando. Graças a isso, um script pode fazer coisas como abrir e fechar programas, criar novas janelas, minimizá-las ou maximizá-las, alterar seu conteúdo e assim por diante. Via script também é possível acessar bancos de dados, modificar arquivos de configuração de outros programas ou alterar a configuração do sistema e assim por diante. Você pode ler mais sobre o desenvolvimento de shell scripts no meu livro Linux, Ferramentas Técnicas.