Introdução à linha de comandos: parte II

Neste post vamos continuar a falar sobre a linha de comandos, mais especificamente sobre os comandos mais utilizados para interagir com o sistema de ficheiros. No entanto, convém primeiro introduzir alguns conceitos sobre a hierarquia de pastas e sistema de permissões.

Vamos começar pela hierarquia de pastas. Abrimos um terminal, e executamos o  seguinte comando:

$ ls /

O comando ls serve para listar os ficheiros existentes numa determinada pasta, como já referimos em posts anteriores. Ao escrevermos "/" como pasta, estamos a dizer ao comando para listar os conteúdos da raiz do sistema de ficheiros. O sistema de ficheiros é equivalente a uma árvore, em que as pastas e sub-pastas são os ramos da árvore; por sua vez os ficheiros são as folhas da árvore. Assim sendo, a raiz é a base do sistema de ficheiros, ou seja, o tronco da árvore. O comando anterior vai dar algo parecido com o seguinte:

bin    etc             lib         lost+found  proc  selinux  usr
boot   home            lib32       media       root  srv      var
cdrom  initrd.img      lib64       mnt         run   sys      vmlinuz
dev    initrd.img.old  libnss3.so  opt         sbin  tmp      vmlinuz.old

Estas são as pastas e ficheiros que existem na raiz do nosso sistema de ficheiros. Podemos usar o gestor de ficheiros gráfico para ver esta mesma informação. Na grande maioria das distribuições Linux basta clicar no ícone com uma pasta, e clicar de novo, no lado direito, onde diz "File System" ou "Sistema de Ficheiros", tal como indicado na imagem seguinte.

Não é crucial saber o significado de todos estes ficheiros e pastas que estão presentes na raiz do sistema de ficheiros. No entanto, pode ser importante pelo menos ter ideia para que servem três ou quatro destas pastas¹. Antes de nos debruçarmos sobre isso, o leitor mais atento reparou que a listagem apresentada pelo comando ls não diferencia entre ficheiros, pastas e atalhos; para isso basta usar a opção "-l" (formato longo), ou "-g" (igual a "-l", mas não especifica o proprietário dos conteúdos). Todas as opções do comando ls podem ser analisadas com o comando man ls, como explicado no post anterior. Repetindo o comando anterior, desta feita com a opção "-l", vamos obter algo parecido com o seguinte:

drwxr-xr-x   2 root root  4096 Oct 19 22:37 bin
drwxr-xr-x   3 root root  4096 Oct 19 22:59 boot
drwxr-xr-x   2 root root  4096 May  6 18:09 cdrom
drwxr-xr-x  17 root root  4140 Oct 23 17:21 dev
drwxr-xr-x 173 root root 12288 Oct 23 17:21 etc
drwxr-xr-x   5 root root  4096 May  6 18:10 home
lrwxrwxrwx   1 root root    32 Oct 19 22:36 initrd.img -> boot/initrd.img-3.5.0-17-generic
lrwxrwxrwx   1 root root    33 Oct 19 22:30 initrd.img.old -> /boot/initrd.img-3.5.0-17-generic
drwxr-xr-x  25 root root  4096 Oct 19 22:42 lib
drwxr-xr-x   2 root root  4096 Oct 19 21:48 lib32
drwxr-xr-x   2 root root  4096 Oct 19 22:42 lib64
lrwxrwxrwx   1 root root    36 Oct 19 22:22 libnss3.so -> /usr/lib/x86_64-linux-gnu/libnss3.so
drwx------   2 root root 16384 May  6 18:04 lost+found
drwxr-xr-x   3 root root  4096 Oct 21 01:28 media
drwxr-xr-x   2 root root  4096 May  7 20:19 mnt
drwxr-xr-x   9 root root  4096 Sep  4 16:17 opt
dr-xr-xr-x 289 root root     0 Oct 23 16:46 proc
drwx------  11 root root  409drwxr-xr-x   2 root root  4096 Oct 19 22:37 bin
drwxr-xr-x   3 root root  4096 Oct 19 22:59 boot
drwxr-xr-x   2 root root  4096 May  6 18:09 cdrom
drwxr-xr-x  17 root root  4140 Oct 23 17:21 dev
drwxr-xr-x 173 root root 12288 Oct 23 17:21 etc
drwxr-xr-x   5 root root  4096 May  6 18:10 home
lrwxrwxrwx   1 root root    32 Oct 19 22:36 initrd.img -> boot/initrd.img-3.5.0-17-generic
lrwxrwxrwx   1 root root    33 Oct 19 22:30 initrd.img.old -> /boot/initrd.img-3.5.0-17-generic
drwxr-xr-x  25 root root  4096 Oct 19 22:42 lib
drwxr-xr-x   2 root root  4096 Oct 19 21:48 lib32
drwxr-xr-x   2 root root  4096 Oct 19 22:42 lib64
lrwxrwxrwx   1 root root    36 Oct 19 22:22 libnss3.so -> /usr/lib/x86_64-linux-gnu/libnss3.so
drwx------   2 root root 16384 May  6 18:04 lost+found
drwxr-xr-x   3 root root  4096 Oct 21 01:28 media
drwxr-xr-x   2 root root  4096 May  7 20:19 mnt
drwxr-xr-x   9 root root  4096 Sep  4 16:17 opt
dr-xr-xr-x 289 root root     0 Oct 23 16:46 proc
drwx------  11 root root  4096 Oct 19 22:26 root
drwxr-xr-x  25 root root   860 Oct 23 17:56 run
drwxr-xr-x   2 root root 12288 Oct 19 22:15 sbin
drwxr-xr-x   2 root root  4096 Mar  5  2012 selinux
drwxr-xr-x   2 root root  4096 Apr 25 17:04 srv
dr-xr-xr-x  13 root root     0 Oct 23 16:46 sys
drwxrwxrwt  19 root root 12288 Oct 23 19:33 tmp
drwxr-xr-x  12 root root  4096 Oct 19 20:00 usr
drwxr-xr-x  14 root root  4096 Oct 23 15:45 var
lrwxrwxrwx   1 root root    29 Oct 19 22:36 vmlinuz -> boot/vmlinuz-3.5.0-17-generic
lrwxrwxrwx   1 root root    29 Oct 19 22:30 vmlinuz.old -> boot/vmlinuz-3.5.0-17-generic

A opção "-l" dá-nos muito mais informação. Aqui fica uma breve explicação sobre o significado desta informação, coluna a coluna, tendo como exemplo a primeira linha:

drwxr-xr-x   2 root root  4096 Oct 19 22:37 bin

• drwxr-xr-x = A primeira letra indica o tipo de arquivo, enquanto as restante letras indicam as permissões do arquivo (sobre isto falaremos adiante). Sobre a primeira letra, eis os códigos mais relevantes:
• d= pasta
• l = atalho (soft link)
• - = ficheiro
• 2 = Número de hard links para o arquivo. Se se tratar de uma pasta este valor indica o número de sub-pastas + a própria pasta + a pasta mãe (a pasta em questão, bin, tem o valor 2 pois não tem sub-pastas, ou seja, este valor corresponde a ela própria e à pasta mãe, neste caso a raiz). Se se tratar de um ficheiro, então este valor indica por quantos nomes é conhecido o ficheiro em questão no sistema de ficheiros².
• root = Nome do utilizador proprietário do arquivo. Neste caso, root corresponde ao nome dado ao administrador principal de todos os sistemas Linux (também conhecido como super-utilizador).
• root = Corresponde do nome do grupo a que pertence o utilizador proprietário do ficheiro. Para os utilizadores normais, o nome do grupo a que pertencem é tipicamente igual ao seu nome de utilizador (como é o caso no arquivo em questão).
• 4096 = Tamanho do arquivo em bytes. Em Linux, as pastas normalmente ocupam 4096 bytes (ou 4 Kb).
• Oct 19 22:37 = Data e hora de última modificação do arquivo.
• bin = Nome do arquivo.

Alguma desta informação também pode ser obtida na maioria dos gestores de ficheiros gráficos, bastando para isso carregar nas teclas Ctrl+2 (primeira das imagens seguintes). Se quisermos mais pormenores sobre uma pasta ou ficheiros podemos clicar com o botão direito em cima da respetiva pasta ou ficheiro e selecionar "Properties" ou "Propriedades" (segunda das imagens seguintes).

Voltando à questão das permissões, vamos olhar de novo para a primeira linha da listagem, mais concretamente para a informação na primeira coluna:

drwxr-xr-x   2 root root  4096 Oct 19 22:37 bin

Como já mencionamos, a primeira letra indica o tipo de arquivo. No caso em questão, o arquivo bin é uma pasta, tal como indicado pela primeira letra, d (de directoria). Os restante nove caracteres podem ser divididos em três partes com três caracteres cada, que correspondem às permissões para: 1) o proprietário do arquivo; 2) para o grupo a que pertence o proprietário do arquivo; e, 3) para todos os outros utilizadores. No caso da pasta bin, temos que:

• rwx = Permissões para o proprietário (owner) do arquivo (utilizador root).
• r-x = Permissões para o grupo (group) a que pertence o proprietário do arquivo (grupo root).
• r-x = Permissões para todos os outros (other).

Existem três tipos de permissões. O primeiro caractere de cada parte corresponde à permissão de leitura (read), o segundo caractere é a permissão de escrita (write) e o terceiro caractere é a permissão de execução (execute). O que significam então cada uma destas permissões?

• read = Permissão de leitura, isto é, é possível ler/aceder aos conteúdos do arquivo.
• write = Permissão de escrita, isto é, é possível modificar os conteúdos do arquivo ou até mesmo eliminar o arquivo.
• execute = Permissão de execução, isto é, é possível executar o arquivo como um programa³.

Podemos então concluir que diferentes utilizadores vão estar sujeitos a diferentes permissões para determinado arquivo consoante sejam proprietários (owner), pertencentes ao grupo do proprietário (group) ou outra coisa qualquer (other). Voltando ao caso da pasta bin:

• rwx = O proprietário (owner), ou seja o utilizador root, pode ler, escrever e executar o arquivo⁴.
• r-x = Os utilizadores que pertencem ao grupo (group) de nome root podem ler os conteúdos do arquivo (neste caso, podem fazer ls à pasta) e executar o arquivo (neste caso, podem fazer cd à pasta); no entanto não podem escrever no arquivo (neste caso, não podem adicionar ou remover outros arquivos dentro da pasta).
• r-x = Os restantes utilizadores (other) têm as mesmas permissões que os utilizadores do grupo (group), ou seja, podem ler e executar o arquivo, mas não podem escrever.

No próximo post falaremos sobre as várias formas de alterar as permissões de pastas ou ficheiros, nomeadamente usando o comando chmod. Além disso, discutiremos ainda a possibilidade de alterar o proprietário (owner) de um ficheiro ou pasta através do comando chown.

Vamos então discutir os comandos mais utilizados para interagir com o sistema de ficheiros. Antes de mais, vamos situar-nos na nossa pasta "Home" (por defeito, ao abrirmos uma nova janela de terminal, vamos estar automaticamente situados na nossa pasta "Home"):

$ cd /home/<o_meu_username>

No Linux, o simbolo "~" significa a pasta "Home" do utilizador atual. Ou seja, o comando anterior é igual a fazer:

$ cd ~

Usando o comando mkdir (make directory) vamos criar uma pasta para fazermos as experiências:

$ mkdir explica

Através do comando cd (change directory) vamos entrar na nova pasta:

$ cd explica

É possível sabermos em que pasta estamos através do comando pwd:

$ pwd

Com o editor de texto nano (podes usar o gedit ou outro editor se preferires), vamos criar um novo ficheiro:

$ nano teste.txt

Queremos encher este ficheiro com texto para fazermos algumas experiências. Seleciona todo o texto deste blog com o rato (ou então faz Ctrl+A que faz automaticamente o select all), faz Editar=>Copiar (ou Edit=>Copy), e voltando ao terminal, clica com o botão direito do rato em cima do terminal e faz Colar (ou Paste) - se tiveres no terminal podes também fazer Ctrl+Shift+V. Agora temos o nosso ficheiro de texto. No nano faz Ctrl+O para guardar o ficheiro e Ctrl+X para sair. Podemos experimentar ver o conteúdo do ficheiro usando o comando cat:

$ cat teste.txt

Era muito conteúdo? Passou muito rápido? Não há problema, podemos usar o comando more ou o comando less para ir vendo o conteúdo do ficheiro linha a linha:

$ more teste.txt
$ less teste.txt

O comando more só permite andar para baixo com a tecla Enter (ou seja, não podemos voltar a ler linhas que já passámos). Por sua vez, o comando less permite andar para trás e para a  frente no ficheiro usando as teclas de direção⁵.

Se quisermos mudar o nome ao ficheiro, usamos o comando mv:

$ mv teste.txt novonome.txt 

O comando mv faz mais do que mudar o nome a ficheiros. mv é diminuitivo de move, ou seja, o seu propósito é mover ficheiros ou pastas de um lado para outro. Para verificar isto, vamos criar uma nova pasta (dentro da atual pasta "explica"):

$ mkdir uma_subpasta

Agora vamos mover o ficheiro que criámos para esta sub-pasta:

$ mv novonome.txt uma_subpasta

Em vez de mudar o nome do ficheiro, o comando mv moveu o ficheiro "novonome.txt" para o directório "uma_subpasta". Podemos confirmar isto com o comando

$ ls -l 

que nos dará um resultado parecido com o seguinte (repara nas permissões, etc.):

drwxrwxr-x 2 explica explica 16384 Oct 24 22:49 uma_subpasta

Ou seja, vemos a pasta que criámos, mas não vemos o ficheiro "novonome.txt". Vamos entrar na sub-pasta

$ cd uma_subpasta

e fazer de novo

$ ls -l

comando que nos dará aproximadamente a seguinte informação (repara nas permissões, etc.) :

-rw-rw-r-- 1 explica explica 25347 Oct 24 22:49 novonome.txt 

Ou seja, confirmamos que efetivamente o ficheiro foi movido para a sub-pasta. Então e se quisermos apenas copiar o ficheiro (e não movê-lo) ficando com uma cópia do ficheiro na pasta "explica" e outra cópia na pasta "uma_subpasta"? Nesse caso usamos o comando cp (copy):

$ cp novonome.txt ..

O comando anterior copia o ficheiro "novonome.txt" para a pasta mãe da pasta "uma_subpasta", que é a pasta atual. A pasta mãe é é a pasta "explica".

Estamos quase a chegar ao fim deste post, mas antes de terminarmos vamos eliminar os ficheiros e pastas que criámos. Podemos começar pelo ficheiro "novonome.txt":

$ rm novonome.txt

Vamos voltar à pasta anterior, fazendo:

$ cd ..

Agora vamos apagar a sub-pasta...

$ rmdir uma_subpasta

...e a cópia do ficheiro que copiámos para a pasta "explica":

$ rm novonome.txt 

Voltamos agora à pasta anterior (a nossa pasta "Home"):

$ cd ..

E removemos a primeira pasta que criámos:

$ rmdir explica

Não é possível remover pastas que não estão vazias com o comando rmdir (remove directory). No entanto estas remoções poderiam ser feitas de uma assentada usando as opções "r" e "f" do comando rm (remove). Assumindo que estamos na nossa pasta "Home":

$ rm -rf explica

Muito cuidado com as opções "r" e "f". A primeira apaga os conteúdos de todas as sub-pastas da pasta indicada, enquanto a segunda força a remoção de tudo e não pergunta nada. É por isso muito fácil fazer asneira com estas opções.

Hoje ficamos por aqui. Se tiveres dúvidas em alguns dos comandos aqui usados não hesites em usar o comando man para tirar dúvidas. No próximo post falaremos de wildcards, que servem para selecionar vários ficheiros e/ou pastas de uma assentada, bem como de alguns comando úteis tais como o ln, grep, find, sudo, chmod, chown e apt-get.

Até breve!

¹Deixo aqui uma lista sucinta sobre os conteúdos de algumas das pastas mais importantes presentes na raiz:

• /bin = Contém os comandos mais importantes, que podem ser utilizados por todos os utilizadores do sistema. Experimenta fazer ls /bin, e vais imediatamente reconhecer alguns dos comandos presentes.
• /etc = Contém ficheiros de configuração do sistema e de algumas aplicações instaladas no sistema.
• /home = Contém as pastas "Home" de todos os utilizadores do sistema. Cada uma destas pastas contém os documentos, imagens, vídeos, música, etc. de cada utilizador. Se fizeres ls /home/<o_teu_username> vais ver todos os ficheiros e pastas presentes na tua pasta "Home". Se fizeres ls ~ vais ter o mesmo efeito, pois o Linux substitui o ~ pelo caminho completo da pasta "Home" do utilizador atual (isto é, substitui o ~ por /home/<o_teu_username>). 
• /lib, /lib32 e /lib64 = Bibliotecas (conjuntos de funções) essenciais e módulos importantes do núcleo do sistema (kernel). 
• /mnt e /media = Contém sub-pastas que são mapeadas em sistemas de ficheiros amovíveis (pens USB, CD-ROM, discos externos, etc.).
• /opt = Pasta onde normalmente são instaladas aplicações externas, isto é, que não estão presentes no AppCenter da distribuição Linux.
•  /usr = Pasta muito importante do sistema, com dados partilhados entre todos os utilizadores. Estes dados estão divididos em sub-pastas:
• /usr/doc = Documentação das aplicações instaladas.
• /usr/share = Ficheiros de configuração, icones, gráficos, etc. das aplicações instaladas
• /usr/src = Código fonte do software instalado no sistema, incluindo o núcleo (kernel) do Linux.
• /usr/include = Ficheiros de cabeçalho (com extensão .h) para o compilador C/C++. Estes ficheiros definem as estruturas e constantes que são necessárias para compilar a maioria dos programas. Já usámos um destes ficheiros, chamado stdio.h, no nosso primeiro programa em C.
• /usr/local = Tem uma funcionalidade semelhante à pasta /opt.
• /var = Contém ficheiros de dados que mudam permanentemente, tais como spools de impressão, dados de registos (logs) e de admistração e outros ficheiros temporários.
• /tmp = Contém ficheiros temporários, como por exemplo downloads efetuados com o browser.

²Esta explicação não está inteiramente correcta do ponto de vista técnico. A questão dos hard links em Linux não é muito simples, mas está bem explicada aqui (nomeadamente a diferença para os soft links). Os hard links não são atalhos, mas sim nomes alternativos para uma pasta ou ficheiro. No mínimo um ficheiro tem um hard link (ele próprio), e uma pasta tem no mínimo dois hard links: ela própria e uma referência a ela própria chamada "." (se fizermos ls -a para vermos os arquivos escondidos começados por ".", podemos verificar que existe sempre um "." dentro de todas as pastas, incluindo a raiz; existe também um arquivo chamado "..", que corresponde à pasta mãe da pasta actual - a raiz não tem pasta mãe, logo não tem ".."). Em Linux, os atalhos correspondem àquilo que se designa por soft link, que são na prática ficheiros independentes e que correspondem a atalhos para outros arquivos (ficheiros ou pastas). Tanto os hard links como os soft links são criados com o comando ln.

³O nosso primeiro programa em C é um ficheiro com permissão execute, uma vez que é possível executar/correr o programa. Ao compilar um programa, o comando gcc atribui sempre a permissão execute ao ficheiro gerado.

⁴ No caso de pastas, a permissão execute significa poder entrar na pasta, ou seja, no caso em questão significa poder fazer cd bin.

⁵Por isso se costuma dizer que less is more, ou seja, menos é mais...

Introdução à linha de comandos: parte I

A linha de comandos, também conhecida como interpretador de comandos ou consola, foi uma das primeiras formas de um utilizador poder dar instruções a um computador, antes do aparecimento de qualquer interface gráfica. Hoje em dia, a linha de comandos, que consiste numa interface de texto entre o ser humano e a máquina, continua a ser a mais direta forma de comunicação entre ambos. A interface gráfica não é mais do que um intermediário intuitivo¹ e atraente¹ entre o utilizador e a linha de comandos².

Muitas tarefas podem ser executadas na linha de comandos, tais como criar, copiar, apagar, mover e editar ficheiros, alterar a configuração do sistema, criar e remover utilizadores, alterar passwords dos utilizadores, editar imagens, editar vídeos, criar menus para DVDs, gravar CDs e DVDs, ver páginas web, ver e alterar configurações de rede, testar o acesso a servidores remotos, procurar ficheiros e sequências de caracteres dentro de ficheiros no nosso disco, e até programar (pois a própria linha de comando tem uma linguagem de programação, até no Windows!). Certamente que nem todas estas tarefas são muito adequadas para a linha de comandos (editar um vídeo!?), mas garanto que em certas e determinadas situações a linha de comandos pode ser muito prática e produtiva. Nesta primeira série de posts sobre a linha de comandos vou apenas falar de coisas básicas, nomeadamente a gestão de ficheiros, a hierarquia de pastas no Linux, bem como outros comandos simples e úteis. Um bom entendimento destas questões é essencial para um bom programador.

Vamos começar então pelo sistema de ficheiros, bem como a sua listagem. Vamos abrir o gestor de ficheiros, que automaticamente nos vai situar na pasta "Home". Nesta pasta vamos ver as típicas sub-pastas contendo o ambiente de trabalho (desktop), os vídeos, imagens, etc. Agora abrimos um terminal, de modo a acederemos à linha de comandos. Por defeito, o terminal também é inicialmente aberto na tua pasta "Home". No terminal escreve:

$ ls

No linux Mint vais ver algo parecido com a imagem seguinte (noutras distribuições deverás ver algo muito semelhante):

Podemos verificar que o comando ls fornece a mesma informação que o gestor de ficheiros gráfico, embora numa forma puramente textual. Quando executado sem mais parâmetros, o comando ls (diminutivo de list) lista os conteúdos da pasta atual (neste caso, a pasta "Home"). No entanto podemos adicionar vários parâmetros para modificar a informação retornada pelo ls. Por exemplo, para mostrar o conteúdo em forma de lista, com informação adicional sobre cada ficheiro, podemos fazer:

$ ls -l

Para mostrar o conteúdo da sub-pasta "Videos" (assumindo que estamos na pasta "Home"), podemos fazer:

$ ls Videos

Numa instalação recente de Linux o mais certo é a pasta "Videos" estar vazia. Podemos ainda juntar os dois parâmetros anteriores para listar o conteúdo da sub-pasta "Videos" em forma de lista:

$ ls -l Videos

É muito fácil obter ajuda para os comandos existentes. Para isso basta usar o comando man (manual de referência), que coloca no ecrã o manual do comando que quisermos. Para obter ajuda para o comando ls, fazemos:

$ man ls

Podemos inclusive obter ajuda para o próprio comando man! Para isso basta fazer:

$ man man

A informação devolvida pelo comando man pode por vezes parecer confusa, mas uma leitura mais aprofundada dá sempre resultado. Nomeadamente, ao executarmos o comando anterior, obtemos a explicação de como interpretar a sinopse (resumo) de qualquer comando. Basicamente, indica o seguinte:

• texto negrito »» escrever exactamente como indicado.
• texto sublinhado »» substituir com argumento apropriado.
• [-abc] »» quaisquer argumentos dentro de [ ] são opcionais. 
• -a|-b »» opções delimitadas por | não podem ser usadas em simultâneo. 
• argument ...  »» argumento pode ser usado várias vezes. 
• [expression] ... »» toda a expressão dentro de [ ] pode ser usada várias vezes.

No manual do ls podemos verificar que a sinopse deste comando é:

ls [OPTION]... [FILE]...

Ou seja, podemos concluir que:

• ls deve ser escrito exactamente como indicado, pois está a negrito.
• Todos os argumentos do ls são opcionais (estão dentro de [ ]).
• Todos os argumentos do ls podem ser usados várias vezes, devido às reticencias...
• Os argumentos indicados devem ser substituídos pelo argumento certo, pois estão em texto sublinhado (no exemplo mais atrás substituímos OPTION por -l e FILE por Videos).

Vamos experimentar ver o manual dos comandos que executamos no post anterior:

$ man sudo
$ man apt-get
$ man gedit
$ man mkdir
$ man gcc


Talvez seja mais fácil perceber algumas das coisas que fizemos. É de notar que o comando cd não tem manual, visto que é demasiado simples, pois basta fazer cd pastaDeDestino. Sugiro ainda a leitura ou observação rápida do manual dos seguintes comandos comuns e/ou essenciais:

• rmdir - Remover pasta
• rm - Remover ficheiro(s)
• mv - Mover ou renomear ficheiros ou pastas
• cat - Ver o conteúdo de um ficheiro
• zip/unzip - Comprimir/descomprimir um ficheiro .zip
• pwd - Ver o caminho completo da pasta atual
• ps - Ver processos/programas em execução
• kill - Terminar um processo em execução
• passwd - Alterar a password de utilizador

No próximo post falarei mais em pormenor sobre a gestão de ficheiros, nomeadamente os comandos para esse efeito, a hierarquia de pastas e o sistema de permissões. Em princípio serão um total de três ou quatro posts sobre a linha de comando, antes de voltarmos ao nosso primeiro programa em C.

Até breve!

¹Discutível e depende do caso.

²As interfaces gráficas usam a linha de comandos de uma forma escondida do utilizador, seja no Windows, MacOS X ou Linux. Por exemplo, no Linux Mint, podemos ver que comando é na realidade executado ao clicarmos em qualquer aplicação na interface gráfica: Menu => Preferências (ou Preferences) => Menu Principal (ou Main Menu). A aplicação que acabámos de abrir serve para organizar o nosso menu (raramente o precisamos de fazer, mas em todo o caso temos essa opção). Se clicarmos onde diz "Internet", e clicarmos duas vezes em cima de "Firefox Web Browser", aparece-nos uma nova janelinha com vários campos, um dos quais diz "Comando" (ou "Command"). Podemos ver que o comando a executar é firefox %u, em que o %u é substituído por um endereço web (URL) na altura da execução (ver imagem em baixo). Para verificares isto, abre um terminal e escreve firefox www.publico.pt. Senão quiseres que o terminal pendure à espera que o Firefox termine a execução, podes escrever firefox www.publico.pt &, tal como indiquei no post anterior. Notar que a forma de organizar o menu principal pode variar de distribuição para distribuição.

Preparar o PC para aprender C: parte II

Vamos então finalizar a configuração do sistema Linux para que possamos escrever o primeiro programa em C. Vou assumir que o leitor deu uma olhada no post anterior e está a usar uma versão do Linux baseada em Debian, como por exemplo o Ubuntu, Mint, Bodhi ou Pear¹.

Antes de começarmos a programar, temos de verificar se o software necessário para esse efeito está instalado, e isso leva-nos temporariamente a outro tópico: a gestão e instalação de programas em Linux. A boa notícia é que, regra geral, é muito mais fácil instalar e desinstalar aplicações em Linux do que, por exemplo, em Windows. Por outro lado, a enorme quantidade de maneiras de realizar essa tarefa pode confundir o utilizador inexperiente. Vamos então tentar simplificar: cada distribuição de Linux tem o seu gestor gráfico de aplicações e pacotes (o seu "AppCenter" em linguagem corrente), cujo objetivo é apresentar, instalar e remover o software disponível (99% do qual gratuito e aberto) de forma apelativa; por exemplo, o Ubuntu tem o Ubuntu Software Center, enquanto o Mint tem o Mint Software Center. Existe no entanto um programa comum a todas as distribuições, embora menos "bonito", e que faz a mesma coisa: chama-se Synaptic Package Manager e vem instalado de raiz em algumas distribuições (e caso não venha, é fácil instalar). Todos estes diferentes "AppCenters" não são mais do que interfaces gráficas para o sistema base de gestão de aplicações e pacotes, chamado Apt. O Apt faz parte do núcleo duro do Debian e seus derivados, e vem sempre instalado de raiz. Ao contrário dos restantes "AppCenters", o Apt é usado através da temível linha de comando. Vou usar o Apt na demonstração da instalação de quaisquer aplicações (que neste post são as aplicações necessárias para programarmos em C). No entanto é bom ter a noção de que instalar ou remover um programa usando o Apt tem exatamente o mesmo efeito que fazê-lo com o Ubuntu Software Center, Synaptic, etc. (por exemplo, se instalarmos um programa com o Apt, esse mesmo programa vai aparecer como "Instalado" no Ubuntu Software Center).

A primeira coisa que temos de verificar é se o sistema básico de desenvolvimento de programas está instalado. Algumas distribuições trazem este sistema instalado de raiz, mas outras mais minimalistas (como o Bodhi) nem por isso. Vamos então usar o Apt para instalar (ou confirmar se está instalado) o sistema de desenvolvimento de programas. Para tal, basta abrir a linha de comandos², e escrever (não meter o $!):

$ sudo apt-get install build-essential

Este comando pode ser críptico para quem não está habituado ao Apt, mas é na realidade bastante simples: estamos a pedir ao Apt para instalar o build-essential, que é o nome do pacote que contém o sistema básico de desenvolvimento de programas. O comando sudo indica que o Apt deve ser executado em modo super-utilizador/administrador, o que normalmente implica a solicitação da palavra-passe ao utilizador. No próximo post vou falar sobre sobre a linha de comandos (incluindo o Apt), pois trata-se de um tópico muito importante para quem deseja perceber como um computador funciona na realidade. Caso o build-essential já esteja instalado, o Apt vai indicar uma mensagem do género:

build-essential is already the newest version.

Caso contrário, o Apt vai pedir confirmação para instalar o pacote e as respectivas dependências³. Estamos prontos para escrever o nosso primeiro programa em C. Para criar o programa é necessário um editor de texto, de preferência com realce de sintaxe, para facilitar a escrita desse mesmo programa. Todas as distribuições de Linux costumam trazer três editores de texto, dois baseados na linha de comando (nano e vi⁴) e um com interface gráfica. O Ubuntu e o Mint trazem o gedit por defeito, embora distribuições mais leves normalmente optem pelo LeafPad ou MousePad, que são bastante limitados. Caso não encontrem o gedit nos menus da vossa distribuição Linux, é fácil instalar usando o Apt no terminal (ou a tua "AppCenter" preferida):

$ sudo apt-get install gedit

Neste blog vou usar o gedit a maior parte das vezes, pois é rápido, simples e realça a sintaxe de todas as linguagens de programação que vão ser discutidas neste blog. Além disso, o gedit não esconde os detalhes do desenvolvimento do software, e permite ao programador iniciante entender completamente o que se está a passar, ao contrário de alguns IDEs⁵. As distribuições baseadas no ambiente gráfico KDE⁶ (tais como o Kubuntu) normalmente trazem o editor Kate, que é do mesmo nível de qualidade do gedit, ou até superior;  caso optem por usar o ambiente KDE, podem perfeitamente usar o Kate em vez do gedit.

Vamos então escrever o nosso primeiro programa em C. Abre um terminal e cria uma pasta onde vamos colocar o nosso primeiro código C:

$ mkdir aprender_c

O comando anterior significa "make directory", ou seja, cria uma pasta ou diretoria. Em seguida vamos para "dentro" dessa diretoria:

$ cd aprender_c

O comando anterior significa "change directory" e vai-nos colocar "dentro" da pasta que acabamos de criar. Em seguida vamos criar o nosso programa em C usando o gedit (ou o teu editor preferido):

$ gedit primeiroprog.c &

O comando anterior invoca o editor gedit, que vai assumir um novo ficheiro chamado primeiroprog.c, localizado na pasta que acabamos de criar. O caractere & no final do comando indica que queremos voltar a ter o controlo do terminal após invocar o gedit (se experimentares o mesmo comando sem o & no fim, vais verificar que o terminal fica bloqueado até fechares o gedit). Obviamente, também é possível invocar o gedit diretamente através do menu, e guardar posteriormente o novo ficheiro na pasta criada. Agora, faz copy-paste do código em baixo para dentro do gedit, e guarda o ficheiro.

 
#include <stdio.h>

int main() {
    printf("O meu primeiro programa em C!\n");
    return 0;
}

Agora vamos compilar o programa, ou por outras palavras, vamos transformar o nosso código C num ficheiro executável. Para tal, executa o seguinte comando no terminal:

$ gcc primeiroprog.c -ansi -Wall -pedantic -g -o primeiroprog

Em princípio não deverás ter erros neste processo. Vamos então executar o nosso programa:

$ ./primeiroprog

O resultado deverá ser:

O meu primeiro programa em C!

Sucesso! Não te preocupes se não percebeste estes últimos passos do processo. Estamos apenas a verificar se o nosso sistema Linux está de facto preparado para desenvolvermos programas em C. Vamos voltar a este primeiro programa mais tarde e dissecar ponto por ponto o que cada um dos passos indicados significa.

Até breve!

¹ Não referi estas duas últimas distribuições no meu último post, mas resumindo muito rapidamente, o Bodhi Linux é super-leve e minimalista (usa uma interface gráfica chamada Enlightenment), sendo necessário instalar praticamente tudo o que o utilizador quer usar. Por usa vez, o Pear Linux é basicamente o Ubuntu com uma interface Gnome-shell personalizada para se parecer com a interface do MacOS X.

² A aplicação Terminal dá-nos acesso à linha de comandos. No Ubuntu ou no Mint basta carregar na tecla "Start" (com o logotipo do Windows, entre o Ctrl e o Alt, do lado esquerdo), começar a escrever "Term...", e a aplicação Terminal aparece logo. Noutras distribuições, o terminal pode ser acedido através do menu "Acessórios => Terminal". Por vezes as distribuições trazem diferentes tipos de aplicações Terminal, que podem ter nomes como LXTerm, Terminology, Konsole, ROXTerm, Sakura,  XTerm, etc. Normalmente é possível invocar a aplicação Terminal em qualquer distribuição pressionando as teclas Ctrl+Alt+T.

³ Muitos programas dependem bibliotecas ou aplicações de terceiros para funcionar, evitando assim "reinventar a roda" para realizar algumas das suas funcionalidades (o mesmo acontece no Windows através dos ficheiros .dll, que por vezes dão problemas e conflitos). Nos sistemas modernos de Linux todas as dependências das aplicações disponíveis nos repositórios são geridas automaticamente pelo Apt (ou pelo "AppCenter" que estivermos a usar), poupando muitas preocupações ao utilizador.

⁴ O vi, bem como a sua versão melhorada, vim, são editores de texto do mais diferente e estranho que se possa imaginar. Inicialmente são totalmente contra-intuitivos, porém, os fiéis juram a pés juntos que após dominar um ou outro, a produtividade na programação mais que duplica. Não sei se isto é verdade, pois eu não uso nem um nem outro, mas fica a dica.

⁵ IDEs - Ambientes de desenvolvimento integrado tais como o Eclipse, NetBeans, Code::Blocks ou Kdevelop (ou o Visual Studio no Windows), podem facilitar e acelerar imenso o desenvolvimento de software; porém, para o programador iniciante, os IDEs podem complicar mais do que simplificar, pois ofuscam detalhes importantes do que está na realidade a acontecer, tornando difícil a resolução de certos problemas. Na minha opinião, o programador só deverá começar a usar um IDE quando dominar minimamente a linguagem de programação em questão (especialmente C); até lá, a melhor opção é usar um editor simples tipo gedit para editar o código juntamente com a linha de comando para compilar e executar os programas desenvolvidos. Existe um programa chamado Geany, que oferece algumas facilidades de um IDE sem esconder a complexidade do desenvolvimento de programas (tem inclusive uma linha de comando incorporada...). Todos estes IDEs podem ser instalados na tua distribuição de Linux através da tua "AppCenter" preferida (Apt, Synaptic, etc...).

⁶ O KDE consiste num ambiente gráfico, bibliotecas gráficas e conjunto de aplicações para Linux. A sua interface é das mais avançadas hoje em dia, embora nem toda a gente o aprecie. Os seu principal concorrente é o Gnome 3 (bibliotecas gráficas + conjunto de aplicações), embora este esteja fragmentado em vários ambientes gráficos tais como o Gnome-shell (ambiente gráfico por defeito no Gnome 3), Unity (ambiente gráfico do Ubuntu) e Cinnamon (ambiente gráfico do Mint).

Preparar o PC para aprender C: parte I

A melhor forma de aprender e desenvolver programas na linguagem de programação C é através de um sistema operativo (OS) baseado em Unix, como por exemplo Linux ou MacOS X (sim, o MacOS X é baseado em Unix...). Porquê? Bem, porque basicamente o Unix e o C foram desenvolvidos mais ou menos em simultâneo por dois génios da computação (Ken Thompson e Dennis Ritchie¹), e têm uma relação tão próxima que por vezes se confundem. Deixo aqui um excelente artigo sobre a história do Unix, a meu ver indispensável para qualquer aluno de Engenharia Informática ou Electrotécnica. Neste blog vou focar-me sempre no Linux, pois além de ser gratuito e aberto e de correr em qualquer PC (ou Mac!), por muito antigo que seja, não tenho (nem quero ter) acesso ao MacOS X. Aliás, por uns meros 25€ podemos comprar um pequeno computador que corre linux...

Dito isto, é possível - embora não aconselhável - aprender² C em Windows. As (muitas e boas) razões para tal não ser aconselhável deixo para mais tarde. No entanto para os mais teimosos existem duas possibilidades: MinGW e Cygwin.

Não é necessário largar o Windows para aprender C num ambiente 100% Linux. Para tal basta fazer download de um gestor de máquinas virtuais (sugiro o VirtualBox) e instalar uma distribuição de Linux dentro do Windows (ou do MacOS X). Neste caso, podem inicializar e desligar o Linux apenas quando quiserem programar, podendo usar o Windows (ou o MacOS X) normalmente. O Linux vai "pensar" que está a correr num hardware físico, quando na realidade está a correr num ambiente virtual. Em todo o caso, se tiverem coragem, sugiro que deitem fora o Windows e comecem a usar Linux: muito mais seguro, muito mais rápido, mais aplicações e mais fáceis de instalar... mas isto é apenas a minha opinião e já estou a fugir do assunto em questão: aprender C.

Se começarem a procurar por uma distribuição Linux para instalar, vão verificar que existem muitas, e com tanta escolha pode tornar-se difícil escolher qual usar. Deixo aqui uma curta lista de distribuições, com indicação das principais vantagens e desvantagens de cada uma:

• Ubuntu - Excelente distribuição, qualidade em toda a linha. No entanto tem uma interface muito moderna (chamada Unity) que requer um PC relativamente recente (não mais antigo que 2007) e que pode ser estranha ao princípio, embora após uma ou duas horas de habituação seja talvez a interface gráfica mais avançada e produtiva nos dias que correm.
• Lubuntu ou Xubuntu - São versões do Ubuntu com interface gráficas mais tradicionais e muito mais leves em termos de requisitos. Basicamente têm todo o poder e qualidade do Ubuntu, mas correm com grande desempenho até em PCs do século passado. São boas opções para instalar dentro do VirtualBox, pois puxam muito pouco pelo sistema.
• Mint (versão Cinnamon) - É uma distribuição baseada em Ubuntu mas com uma interface mais tradicional (chamada Cinnamon), embora inovadora e moderna. Talvez seja a interface mais familiar para quem vem do Windows 7 ou Vista. Tal como o Ubuntu, requer um PC relativamente moderno, com aceleração 3D. Existem outras versões do Mint, mais leves, como por exemplo o Mint Xfce, que usa a mesma interface que o Xubuntu. A única desvantagem do Mint em relação ao Ubuntu, é que parece um bocadinho menos profissional e estável no uso diário; mas não é por isso que não deixa de ser um OS excelente.

Talvez mais tarde publique qualquer coisa sobre a história das distribuições. Para já refiro apenas que todas as distribuições que mencionei derivam do Debian, uma das primeiras distribuições de Linux, muito estável e segura, mas com desenvolvimento um bocado lento e com repositórios de aplicações um pouco desactualizados. Uma lista completa (?) das distribuições existentes está disponível aqui (ver coluna do lado direito, um pouco mais em baixo).

Comecei este post por referir que um OS baseado em Unix (como o Linux) é a melhor forma para aprender a programar em C. Podem tirar as duas últimas palavras da frase anterior. Um OS baseado em Unix (e.g. Linux) é a melhor forma de aprender a programar, ponto. No caso do Linux, as ferramentas para programar em 99% das linguagens de programação existentes já estão instaladas de raiz ou podem ser instaladas com poucos clicks. Em posts futuros darei exemplos em Python, Java, PHP e Matlab (sem usar o Matlab!).

No próximo post vou escrever sobre o software que se pode usar em Linux para desenvolver programas em C, bem como sobre a linha de comando e o porquê de ser importante dominar esta ferramenta que tanto medo mete a tanta gente.

Até breve!

¹ Dennis Ritchie faleceu recentemente, sem que isso tenha sido referido na imprensa, ao contrário do que aconteceu, por exemplo, com Steve Jobs. Acerca disto li um comentário muito interessante que dizia o seguinte: "If the ghosts of Jobs and Ritchie were to find themselves marooned on a desert island, it might be Jobs who managed to light the fire, but it would be Ritchie who showed up with the wood". Façam a vossa interpretação.

² Refiro-me apenas a aprender C e não a desenvolver software em C para Windows, pois nesse caso o melhor é usar uma ferramenta integrada como o Visual Studio. No entanto, para aprendizagem de C considero que este género de abordagem é péssima, mas sobre isso falarei depois...