Me siga na Odysee

Eu estava lendo um texto que eu encontrei em um portal na rede Gopher e pensei "hey, isso é interessante, vou levar para o pessoal da Odysee". Então, eu comecei a traduzir os textos aos poucos e fazendo leves modificações até o ponto em que eu não tinha mais o texto original em mãos, mas algo diferente. Na prática eu acabei gastando duas semanas da minha vida para traduzir dois capítulos, e agora eu vou tentar trazer os capítulos de forma mais curta e adaptada a nossa realidade de hoje.

Eu pensava em trazer todos os capítulos em um arquivo só, mas, sinceramente, vai ser um saco ler tudo isso de uma vez só. Seria como você tentar ler um livro de faculdade em uma noite, e todos sabemos que isso não dá certo. Por isso, meu plano de lançamento é traduzir e adaptar todos os 15 capítulos mantidos por Lowe, juntar com opiniões pessoais minhas, misturar com alguns conhecimentos atuais e criar algo diferente, algo que seja útil para quem está começando agora.

Ao contrário dos textos disponibilizados por Lowe, no entanto, caso façam um razoável sucesso, eu não vou simplesmente parar, apenas apresentar mais e mais conceitos de ciência de computação com o passar do tempo, passando por aspectos técnicos de sistemas operacionais, inteligência artificial e diversos outros.

Claro que não vai ser uma tarefa fácil, muito menos simples, mas acredito que vá ajudar a muitos, então, se isso for útil pra você de alguma forma, ajude compartilhando com seus amigos, dando uma gorjeta nos comentários, comentando, engajando, doando ou tentando ajudar a chegar a mais pessoas, para me incentivar a continuar.

Agradeço a Robert Lowe, que manteve essa jóia da computação de 1989 ainda viva até hoje. Você pode, inclusive, ler os textos originais aqui, através do proxy Gopher da Floodgap.

Também agradeço a Herbert Schildt pelos excelentes livros C++: guia para iniciantes e C Completo e Total e pelo site sololearn, que me ajudaram a tirar algumas dúvidas sobre programação para desenvolver esses artigos.

Terminado esse tópico, vamos ao texto.

Considerações especiais

O texto a seguir assume que você está utilizando Linux como seu sistema operacional. Se você não utiliza um sistema baseado em Linux, eu recomendo que você alterne para um ou utilize uma máquina virtual para poder realizar as atividades propostas com mais facilidade.

Introdução ao Unix

Introdução

Esse capítulo te ensinará um pouco sobre a interface do terminal de sistemas Unix, incluindo:

• Manipular arquivos, criar, excluir, renomear e copiar arquivos
• Usar páginas de manual
• Organizar arquivos usando diretórios

Esse é um laboratório guiado. Isso significa que você só precisa ler as instruções e repetir os comandos para ter os resultados esperados.

Trabalhando com arquivos e com os manuais

Abra o seu terminal.

1. Assim que você tiver aberto o terminal, você irá parar no diretório home do seu sistema. Assim como o Windows ou o Mac OSX, sistemas Linux dividem o sistema em diretórios (pastas) e arquivos, e a sua pasta home, em geral, será a única parte do sistema onde você realmente vai mexer (e, se você não for o dono do sistema, a única em que você terá permissão de mexer). Vamos ver onde você está agora. Digite o seguinte comando:

$ pwd

O comando pwd significa algo como "present working directory", ou "diretório atual de trabalho", e vai retornar o caminho da pasta atual. No seu caso, vai ser algo como /home/usuario.

1. Outro comando legal é o comando hostname. Ele mostra o nome do servidor ou sistema atual em que você está conectado.
2. Como em todo o sistema, você pode não estar conectado sozinho ao servidor. Ao usar o comando who, você vê uma lista dos usuários conectados atualmente ao sistema.
3. Agora sua tela deve estar completamente cheia de lixo. Digite clear para limpá-la.
4. Agora vamos brincar um pouco com algumas partes aleatórias da interface. Comece apertando as teclas de cima (↑) e baixo (↓): você perceberá que pode navegar pelo histórico de comandos do seu usuário. Usando a tecla "apagar" (backspace), você pode alterar um comando que esteja selecionado. Brinque um pouco com isso...
5. Ok, hora de mexer um pouco com arquivos. Digite ls para ver os arquivos de dentro da pasta atual.
6. Beleza, você consegue ver os arquivos de dentro da sua pasta, mas isso não serve pra muita coisa, certo? Exiba os dados com mais dados, como proprietário e data de alteração, usando o comando ls -al:

Aqui temos algumas informações interessantes sobre o comando. Primeiramente, você deve ter percebido as pastas . e .., que significam, respectivamente, o diretório atual e o diretório anterior.

O l de -al significa "list details", ou "listar detalhes", e entrega os detalhes dos arquivos separados em colunas. A primeira coluna parece algum tipo de código secreto de hackers, não é mesmo? Na verdade, é um registro das permissões dos arquivos e dos tipos do mesmo, sendo que o primeiro caractere indica se é um diretório ou não, e os 9 caracteres seguintes indicam as permissões dos arquivos e pastas, seguindo o seguinte padrão:

• r → permissão de leitura
• w → permissão de escrita
• x → permissão de execução

Há três categorias de permissões que podemos definir para cada arquivo. Os primeiros três dígitos de permissão se referem aos poderes do proprietário do arquivo, os três seguintes se referem aos poderes de um grupo de usuários e os três últimos mostram as permissões do resto das pessoas.

Por exemplo, imagine que eu tenho o seguinte arquivo:

-rwxr-xr-- 1 Fulano Users 0 fev 21 19:27 meu-arquivo.txt

O primeiro dígito não é um d, mas sim um traço (-), o que significa que não é um diretório. As permissões do proprietário são rwx, o que significa que o usuário Fulano pode ler, alterar e executar o arquivo. As permissões do grupo são r-x, o que significa que os usuários que pertencem ao grupo Users podem ler e executar o arquivo, mas não podem editá-lo, e as permissões do resto dos usuários são r--, o que significa que, se você não for o usuário Fulano nem pertencer ao grupo Users, você só vai poder ler.

Um detalhe importante de se mencionar e que, caso você queira abrir um diretório, ele deve ter permissão de execução. Caso contrário, você não poderá abrí-lo.

Um dos "superpoderes" do superusuário é ignorar essas permissões especiais, podendo ler, editar e executar o que bem entender.

1. Uma coisa legal é que, se as permissões não forem restritivas demais, você pode visualizar dados de outros usuário. O atalho ~ redireciona para a pasta home do usuário, mas você pode usar o mesmo atalho assim: ~<nome do usuário>. Isso te permite usar esse atalho para redirecionar para a pasta de algum usuário em específico. Exemplo:

$ ls ~admlab

Isso vai mostrar o retorno do comando ls rodado dentro da pasta home do usuário admlab. Observe alguns outros exemplos:

1. Agora vamos usar a pasta ~/gopher/files que eu criei previamente (mas isso vale para qualquer outra pasta). Vou entrar nela e digitar o comando ls:

São arquivos de texto. Você provavelmente até mesmo presumiu isso pela extensão .txt. Mas e os últimos dois arquivos? Eles não tem extensão, não é mesmo? Ao contrário do Windows, em sistemas Unix o uso de extensões para definir o tipo de arquivo é mais uma recomendação do que, de fato, uma obrigação. Quer dizer, ainda podemos fazer isso, e realmente fazemos, mas não porque somos obrigados. No entanto, isso pode acabar causando alguns transtornos, e é por isso que existe o comando file. A sintaxe dele é essa:

$ file arquivo[.extensão]

Vamos executar os comandos para cada um dos arquivos:

E agora temos certeza de que os arquivos são arquivos de texto puro.

1. Ok, e você quer ler o conteúdo do arquivo, certo? Para isso usamos o comando cat. A sintaxe é:

$ cat arquivo

Vamos abrir o arquivo 1.txt como exemplo:

$ cat 1.txt

E o conteúdo do arquivo vai ser impresso no terminal.

1. Digamos que o arquivo 2.txt seja grande demais para ser impresso normalmente no terminal. Para isso serve o comando more. A sintaxe é:

$ more arquivo

Isso vai imprimir na tela o conteúdo do arquivo, assim como o cat. Porém, ao invés de somente imprimir o arquivo até o final, o comando vai escrever na tela o conteúdo até que a tela esteja cheia, aí vai esperar que o usuário aperte espaço ou enter para imprimir mais texto na tela.

1. E se eu quiser copiar um desses arquivos da pasta ~/gopher/files para a pasta ~/Documentos? Para isso serve o comando cp. A sintaxe é a seguinte:

$ cp arquivo-de-origem arquivo-de-destino

Vamos copiar o arquivo ~/gopher/files/1.txt para a pasta ~/Documentos. Primeiro, mostrando como se eu estivesse dentro da mesma pasta do arquivo:

$ cp 1.txt ~/Documentos/1.txt

Agora, em uma outra pasta aleatória:

$ cp ~/gopher/files/1.txt ~/Documentos/1.txt

Você pode salvar a cópia com um nome diferente do original, para diferenciar os dois:

$ cp ~/gopher/files/1.txt ~/Documentos/backup.txt

E, é claro, se você não vai salvar ele com um nome diferente do original, pode apenas passar o nome da pasta de destino:

$ cp ~/gopher/files/1.txt ~/Documentos

1. Pode não ser interessante manter várias cópias de um mesmo arquivo, então vamos remover o nosso arquivo ~/gopher/files/1.txt, que é o arquivo original. Entre na pasta e execute:

$ rm -i 1.txt

A flag -i faz o comando de remover perguntar se você realmente quer remover o documento. Coloquei mais por segurança, mas você não precisa, necessariamente, colocar essa flag:

$ rm 1.txt

Você também pode passar o caminho do arquivo como passamos antes:

$ rm ~/gopher/files/1.txt

E pode também remover uma pasta, mas, para tal, é preciso lembrar que, se ela não estiver vazia, você vai ter que usar a flag -r, para excluir os arquivos de dentro dela também:

$ rm -r files

Lembrando que essa operação é irreversível.

1. Que droga, agora temos um monte de comandos com um monte de opções diferentes, e é difícil de lembrar o que cada um deles faz. Então que tal usar um comando para mostrar o que outros comandos fazem? O comando man nos mostra o manual dos programas. Vamos abrir o manual do comando file:

$ man file

Isso vai mostrar todos os parâmetros do comando file, suas instruções de uso e outras coisas mais.

Organizando diretórios

Agora você consegue copiar arquivos, consegue ler o manual e sabe usar o seu terminal para a maior parte das tarefas do cotidiano. Agora você precisa aprender a organizar seus arquivos.

1. Vamos começar criando um diretório:

$ mkdir meu_diretorio

1. Agora vamos entrar dentro dele:

$ cd meu_diretorio

Você também pode usar o comando cd passando um caminho absoluto:

$ cd ~/meu_diretorio

E se não passar nada como parâmetro ele vai voltar para sua pasta home:

$ cd

1. Agora que estamos dentro de meu_diretorio, vamos copiar todos os arquivos da pasta ~/Documentos para a pasta atual:

$ cp ~/Documentos/* .

1. Divirta-se :)

Escolha seu lado na guerra de editores e construa suas próprias pernas com C++

No capítulo anterior você aprendeu o básico de um sistema Unix. Agora está na hora de você escolher um editor de texto para poder começar a programar. Nesse capítulo, você dará seus primeiros passos em C++.

O primeiro passo vai ser "escolher sua arma", o seu editor de texto. Um editor de texto é onde você vai passar a maior parte do seu tempo enquanto programa, afinal, um código de um programa é, antes de tudo, texto. Existem muitas opções no mercado, mas eu recomendo você escolher emacs ou vi/vim.

Depois de você optar pelo vim... quero dizer, depois de você escolher seu editor, vai ser a hora de você criar seu primeiro programa. Você vai vai receber um esqueleto de um programa-base, mas o código e as ideias vão vir de você. Agora, hora de escolher seu editor.

Parte I - Escolhendo o seu editor

ed

O ed é um dos editores mais antigos a serem usados em sistemas Unix. Criado em 1971 por Ken Thompson, possui alguns recursos avançados para a época e influenciou editores criados posteriosmente. Ele foi criado em uma época em que sistemas Unix eram executados em uma grande gama de dispositivos, inclusive por causa disso você, teoricamente, conseguiria usar tranquilamente o editor ed sem rejuízo até mesmo em uma "teletype" (uma máquina de escrever conectada a um computador). Por causa disso, o ed não é um editor visualmente interativo, afinal, como ser interativo se o que você escrever vai ser colado diretamente no papel?

Como o ed é um editor de textos modal. Isso significa que existem três modos de entrada que o editor aceita, variando sua forma. Existem três modos:

1. command - comandos são digitados nesse modo, como append text ou edit file
2. input - você digita texto nesse modo
3. view - o conteúdo do arquivo é mostrado na tela. Você pode visualizar o arquivo inteiro, sessões do arquivo ou apenas uma linha única

Se você tem interesse em aprender como usar o ed, você pode ler seu manual digitando man ed no terminal, mas o ed é um editor definitivamente antigo e quase nem é mais utilizado hoje, tanto que praticamente só é usado por curiosidade histórica

vi

O editor vi é um editor derivado do editor ex, que, por sua vez, é um editor derivado do ed, então podemos considerar o vi um "neto" do ed. O vi é um editor orientado a telas, ao contrário do seu avô orientado a papel, e se tornou tão popular que hoje em dia existem diversos editores derivados dele, sendo o mais popular o vim (VI iMproved).

Assim como o ed, o vi é baseado em modos, consistindo em dois modos:

1. Command - permite a inserção de comandos no editor
2. Insert - permite a inserção de texto ao arquivo

Quando o vi é aberto, ele inicia no modo de comandos. Você pode trocar para o modo de inserção apertando a tecla "i", e voltando para o modo de comandos apertando a tecla ESC. Claro que é um pouco contraintuitivo fazer isso no início, mas, depois de alguns dias de uso, você já estará acostumado.

vim

O vim é um editor derivado do antigo vi, mas com algumas coisinhas extras. Eu, pessoalmente, recomendo ele, já que a maioria dos sistemas atuais substituiu o vi original pelo vim entre os pacotes instalados por padrão no sistema.

Os recursos padrão do antigo vi estão todos no vim, junto com outros recursos, como adição de plugins e configuração de sintaxe.

emacs

O emacs, editor criado por Stallman em 1976, foi um dos primeiros programas a fazer parte do projeto GNU. Sendo desenvolvido em C e lisp, o emacs é um dos editores mais extensíveis entre os editores criados para terminal.

Ao contrário do ed e do vim, o emacs não é um editor modal. Isso significa que ele não usa dois modos diferentes para realizar ações diferentes, mas sim um mesmo modo e uma combinação de teclas para realizar ações diferentes.

nano

O editor nano seria o equivalente de terminal ao bloco de notas. Criado para ser fácil de se utilizar e baseado no antigo editor pico, o editor possui apenas uma lista pequena de funcionalidades.

cat > file

Ok, este não é realmente um editor, mas pensei em mencioná-lo como sendo a maneira mais minimalista de inserir texto. Ocat lê um arquivo e o imprime na tela. Se você chamar cat sem nenhum argumento, ele apenas repetirá o que você digitar stdin para stdout. Se você redirecionar isso para um arquivo, como no caso acima, ele permitirá que você digite um texto que o sistema salvará em um arquivo. Pressionar Ctrl+D sairá do programa.

A principal desvantagem aqui é que você não tem como alterar o texto. Mesmo o texto inserido na mesma linha não pode ser alterado. Se você é o tipo de pessoa que faz tudo perfeitamente na primeira vez, o cat é o seu "editor" preferido!

Editores visuais

Depois dos anos 2000 surgiram diversos editores de texto visuais, como o Notepad++. Atualmente, esses editores possuem diversas funcionalidades avançadas, como o uso de plugins de inteligência artificial para criar códigos de template. Se for a sua escolha, recomendo o uso de alguns editores que possuem diversos recursos avançados e são facilmente extensíveis, como:

• Sublime Text
• VS Code
• Atom
• IDEs, como o Code::Blocks ou o KDevelop

Apesar disso, utilizar um editor de linha de comando será útil em determinados momentos, e recomendo que seja feito (até porque um servidor acessado via SSH não tem interface gráfica).

Parte II - criando seu primeiro programa

1. Vá para a pasta que você deseja salvar seu programa no final

2. Digite vimtutor na sua linha de comando. Isso abrirá um tutorial interativo para o editor vim (ignore se já sabe o utilizar)

3. Vamos criar um arquivo chamado hello.cpp. Para isso, digite:

$ vi hello.cpp

4. Adicione o seguinte conteúdo ao arquivo:

#include <iostream>

using namespace std;

int main(void)
{     
    cout << "Hello, world!" << endl;

    return 0;
}

5. Salve o arquivo e saia do vi

6. Agora vamos compilar o arquivo. Como estamos usando um sistema Linux, o compilador utilizado será o g++, que faz parte do pacote gcc. A forma mais simples de compilar é executar:

$ g++ hello.cpp

Isso vai salvar o arquivo compilado em um executável com o nome a.out

7. Execute o código assim:

$ ./a.out

8. Ok, mas ninguém vai querer compilar um arquivo para ter o nome final a.out, certo? Para compilar com o nome HelloWorld, execute assim:

$ g++ hello.cpp -o HelloWorld

E agora você pode executar novamente o seu programa assim:

$ ./HelloWorld

Nota: cuidado quando for executar esse código. Um erro muito comum seria digitar g++ hello.cpp -o hello.cpp, mas isso substituiria o arquivo onde tem seu código. Você tem que ser capaz de rodar seu programa, mas também tem que ser capaz de continuar visualizando e alterando seu código.

9. Agora vamos editar nosso programa. Observe o código e adicione uma linha abaixo da anterior para escrever a frase "Este é meu primeiro programa" abaixo da frase anterior.

Dica: o comando cout serve para imprimir mensagens na tela.

1. Compile e execute seu programa modificado.

Parte III - Área do Círculo

O exercício a seguir foi extraído da Beecrowd, com algumas adaptações.

Problema

A fórmula para calcular a área de uma circunferência é: area = π * raio². Considerando para este problema que π = 3.14159:

• Efetue o cálculo da área, elevando o valor de raio ao quadrado e multiplicando por π.

Entrada

O programa exibirá a mensagem "Digite o raio: ", e, em seguida, pedirá a entrada. A entrada contém um valor de ponto flutuante (dupla precisão), no caso, a variável raio.

Saída

Apresentar a mensagem "A área do seu círculo é: " seguido pelo valor da variável area, conforme exemplo abaixo, com 4 casas após o ponto decimal. Utilize variáveis de dupla precisão (double).

Dicas iniciais

1. Escreva seu pseudocódigo mostrando como você pretende implementar seu programa. Ele deve conter:

• Uma lista com as entradas do programa
• Uma lista com as saídas do programa
• Os passos a serem executados no programa

1. Defina uma série de casos de teste (ao menos cinco). Esses testes devem incluir uma série de exemplos de entrada e os valores esperados.
2. Use seu editor de código preferido e crie um "esqueleto" do seu código, para conseguir compreender como o programa vai ser executado
3. Traduza esse texto para C++ e execute-o.

Passo a passo

Você vai começar criando três variáveis de tipo float:

float PI;
float area;
float raio;

Existem vários tipos de dados em C++. O tipo int representa números inteiros, por exemplo, enquanto o tipo char representa caracteres. O tipo float representa um número de ponto flutuante, ou seja, um número com vírgula, e é por isso que criamos nossas variáveis com o tipo float.

Agora vamos colocar alguns dados nas nossas variáveis. Comece adicionando uma linha ao seu código que vai alterar a variável PI assim:

PI = 3.14159

Como não vamos alterar essa variável posteriormente, eu prefiro colocar a atribuição de valor junto com a declaração da variável:

float PI = 1.34359;

Agora, precisamos pegar os dados que o usuário digitar. Já vimos que o cout serve para fazer o output, ou seja, escrever coisas no terminal. Mas, ao invés de escrevermos algo no terminal, queremos pegar dados digitados nele. Então, para isso, usaremos o cin:

cout << "Digite o raio: "; cin >> raio;

Isso vai colocar os dados que você escrever no terminal dentro da variável raio para que você possa usar. Hora de aplicar a fórmula. Atribua o valor a variável area assim:

area = PI * raio * raio;

E, por fim, termine escrevendo o resultado na tela:

cout << "A área do seu círculo é: " << area << endl;

No final, seu código vai ficar mais ou menos parecido com isso:

#include <iostream>
using namespace std;

int main() {
    float PI = 3.14159;
    float area;
    float raio;

    cout << "Digite o raio: ";
    cin >> raio;
    cout << endl;

    area = PI * raio * raio;

    cout << "A área do seu círculo é: " << area << endl;

    return 0;
}

E é isso. Gostou do texto de hoje? Tem algo a acrescentar? Alguma dica? Comentário? Crítica? Conta pra mim nos comentários ☺️❤️