Tudo bem, pessoal, obrigado por virem.

Esse é o semestre que faltava na sua 
fomação em ciência da computação.

Ou, pelo menos, é assim que decidimos
nomear

este curso. Se não é pra essa aula que

você veio, então você entrou na sala
errada. Nós

estaremos aqui por mais ou menos 1h só

para ajustar suas expectativas e... 
eu quero falar

um pouco com vocês sobre o por quê

de estarmos dando este curso. O curso

se originou de uma observação que o Anish,

o José e eu fizemos enquanto dávamos 
monitoria para vários

cursos no MIT. Basicamente,

todos nós, cientistas da computação, 
sabemos

que computadores são ótimos em fazer

tarefas repetitivas e automatizar coisas.

Mas muitas vezes não percebemos que há

muitas ferramentas que podem fazer nossos
próprios

processos de desenvolvimento melhores.
Nós podemos ser

bem mais eficientes sobre como usamos 
nossos

computadores porque podemos usá-los

como uma ferramenta para nós mesmos, não

apenas para criar websites ou software ou

coisas do gênero. Este curso é

uma tentativa de abordar isso e uma
tentativa

de mostrar para vocês algumas ferramentas 
que vocês

podem usar para um ótimo efeito seu 
dia a dia

em pesquisa e nos estudos.

Este vai ser um curso no qual nós

queremos ensinar tanto como aproveitar

ao máximo as ferramentas que você já

conhece, mas também, assim esperamos, 
ensinar vocês sobre

algumas ferramentas novas,

além de como combinar essas ferramentas

para produzir coisas mais poderosas do que

vocês imaginam ser capaz de fazer 
com o que

já sabem atualmente. Este curso está

estruturado em uma séria de aulas de 1h

e cada aula vai cobrir

um tópico em paticular. Vocês podem checar

o website, que está escrito lá, para

acessar a lista de tópicos e datas

de cada um. As aulas serão, em geral,

independentes, então vocês podem

comparecer às que lhes interessa.

Porém vamos assumir que

vocês vêm acompanhando o conteúdo, de modo

que, ao chegarmos às aulas futuras, não

vou ficar ensinando bash tudo outra vez.

Por exemplo, nós também vamos postar

tanto as notas de aula quanto as gravações

das aulas online. Ainda não decidimos

exatamente quando vamos fazer isso,

mas será após as aulas. Obviamente, os

vídeos têm de ser postados depois 
que a aula ocorre.

O curso vai ser ministrado por mim, John e

Anish, sentados ali, e pelo Jose,

que não está aqui mas vai dar

a aula de amanhã. Lembrem-se que

estamos tentando abordar um monte

de assuntos neste curso de apenas 11

aulas de 1h, então vamos avançar

relativamente rápido. Mas, por favor,

interrompam se houver algo que vocês

não estiverem conseguindo acompanhar.

Se você achar que devemos dedicar

mais tempo a algum tópico, fale conosco.

Por favor, interrompa com perguntas.

Além disso, após cada aula estaremos

disponíveis no nono andar do

prédio 30 no Stata Center,

o prédio de ciência da computação. Então, 
se você

aparecer no nono andar

lá, na Gates Tower, pode vir

e tentar fazer os exercícios que

vamos dar em cada aula ou simplesmente
fazer perguntas

sobre outras assuntos que tivermos

tratado nas aulas ou outras coisas,

como umar seu computador de forma 
eficiente.

Devido ao tempo limitado que temos

disponível, não vai ser possível

abordar todas as ferramentas em detalhe,

então tentaremos salientar ferramentas

importantes e formas interessantes de
usá-las.

Não vamos, necessariamente, ir a fundo

nos detalhes de como tudo funciona or

discutir casos mais elaborados, mas
se vocês tiverem

perguntas sobre isso, por favor,
venha falar conosco

sobre isso também. Muitas dessas 
ferramentas são

ferramentas que temos usado por anos

e podemos lhes direcionar a mais coisas

interessantes que vocês podem fazer 
com elas.

Então, aproveitem que estamos aqui.

Esta aula vai... não quero dizer

escalar rapidamente, mas

o que vai acontecer no decorrer

dessa aula em particular é que vamos

abordar bastante do básico, e assumiremos

que vocês já sabem isso no restante do

semetre. Coisas como usar o

shell e o terminal (vou explicar o que são

para os que não conhecem ainda),

e depois, bem rapidamente, vamos

escalar para ferramentas mais avançadas

e como usá-las. Vocês já podem ver nas

notas de aula o tipo de

tópicos que vamos cobrir.

Então isso nos traz à aula de hoje

na qual vamos cobrir o shell.

O shell vai ser uma

das formas primárias de interagir com seu

computador. Quando você quiser fazer mais
coisas

do que as que são possíveis com as 
interfaces visuais,

com as quais talvez você esteja 
acostumada/o, lhe permitam fazer.

As interfaces visuais são limitadas no

que

elas lhe permitem fazer, porque você só

pode fazer as coisas para as quais há

botões, sliders ou campos de inputs.

Geralmente essas ferramentas textuais 
são construídas

para serem combinadas umas com as outras, 
mas

há também diversas formas diferentes de

combiná-las, programá-las ou

automatizá-las e é por isso que,

neste curso, vamos focar na

linha de comando ou em ferramentas
baseadas em texto.

O shell é o local se faz a

maioria desse trabalho. Então para 
aqueles que

não estão acostumados com o shell, 
a maioria

das plataformas oferecem algum tipo 
de shell.

No Windows, há o PowerShell, mas

há também outros shell disponíveis

no Windows. Já no Linux vocês vão 
encontrar um monte de

terminais, que são janelas que lhes 
permitem

visualizar shells e vocês também vão

encontrar diversos tipos de shells. O mais

comum deles é o bash, ou 'born

again shell'. Por ser um shell tão comum,

é basicamente esse que vamos

usar nessas aulas.

Se você usa Mac OS, você provavelmente

já tem o bash ou uma versão antiga dele

se você abrir o app do terminal. Então,

se você quiser acompanhar em qualquer uma

dessas plataformas, fique à vontade, mas

tenha em mente que o curso vai ser

meio que baseado em Linux no que diz
respeito a como

vamos ensinar, ainda que a maioria dessas
ferramentas

funcione em todas as plataformas. 
Se você quiser

instalar um terminal e um shell e

não sabe como fazer isso muito bem,
ficaremos felizes em

lhes ajudar na nossa sala ou, geralmente,

é bem fácil buscar no Google

'sua plataforma' mais 'terminal' e você

vai achar um. Bom, quando você abre um

terminal você vê algo que se parece com

isso. Normalmente vai ter

uma única linha no topo, o que é

conhecido como prompt do shell.

Você pode ver que meu prompt do shell

parece com isso, tem meu nome de usuário,
o nome

da máquina que estou usando, o caminho

da pasta onde estou (vamos falar de 
caminhos

um pouco mais tarde) e daí ele

fica piscando lá, pedindo

um input. Esse é o prompt do shell

onde você diz ao shell o que quer

que ele faça. Dá pra customizar

bastante esse prompt, quando você abri-lo

na sua máquina talvez ele não vai ter 
exatamente

essa aparência. Talvez um pouco,

se você já tiver configurado,

ou pode ter muitas outras

formas. Não vamos falar muito

sobre customizar seu shell nesta

aula em particular,

faremos isso mais tarde. Aqui vamos

só falar sobre como usar esse

shell para fazer coisas úteis. Esta é

a principal interface de texto que você

tem para seu computador, através do shell.

No shell, você pode digitar

comandos e os comandos podem ser

coisas relativamente simples. Geralmente

você vai executar programas com

argumentos. Como isso funciona? Bem,

um programa que podemos executar é o 
de data.

É só digitar date e apertar

enter, aí ele vai

te mostrar a data e hora. Você também

pode executar um programa com argumentos.

Isso é uma forma de modificar o
comportamento

do programa. Por exemplo, há um

programa chamado echo. O echo imprime

os argumentos que você passa, e esses

arugmentos são simplesmente coisas

separadas por um espaço em branco logo 
após o nome.

Então podemos dizer hello e ele vai 
imprimir

hello de volta.

Talvez não muito surpreendente, mas isso

é uma das coisas básicas dos argumentos.

Uma coisa que vocês vão notar é que 
eu disse

que argumentos são separados por

espaços em branco. Talveu vocês se 
perguntem, "bom,

e se eu quiser um argumento com várias

palavras?" Você pode pôr essas coisas
entre aspas, e aí dá para

fazer coisas como echo hello espaço

world e agora o programa echo recebe

um argumento que contém a string

hello world com um espaço. Bom, também dá

para usar aspas simples para isso. 
Vou explicar a

diferença entre aspas simples e

aspas duplas quando falarmos

sobre scripting em bash. Vocês também

podem escapar um caracter, então, por

exemplo, hello world. Isso também

funciona. Todas as regras sobre

como escapar e como analisar e

dar vários argumentos e variáveis

nós vamos cobrir mais tarde. Espero

que não encontrem muitas coisas esquisitas
sobre isso. Nós temos de

provocar vocês sobre isso. Lembrem-se pelo

menos que argumentos são separados 
por espaços, então,

se você quiser fazer algo como criar um

diretório chamado "my photos",

não dá para simplesmente digitar
make directory my photos.

Assim ele vai criar dois diretórios,

um chamado my e outro chamado photos e

provavelmente não é isso que você quer.

Uma coisa que você pode se perguntar é
como o

shell sabe o que são esses programas 
quando

eu digito date ou echo. Como ele

sabe o que esses programas devem

fazer. A resposta é que o seu

programa, seu

computador tem um monte de programas

embutidos que já vêm com a máquina.

Assim como seu computador pode vir com o

aplicativo do terminal, ou com

o Windows Explorer ou

com algum tipo de navegador, ele também

já vem com aplicações específicas para

o terminal, e elas ficam salvas no

seu sistema de arquivos e o shell tem

uma maneira de determinar onde um
programa está

localizado. Basicamente, ele tem uma 
forma de buscar

por programas. Ele faz isso através de

algo chamado variável de ambiente

invariante. Uma variável de ambiente

é uma variável que pode ser

usada para linguagens de programação.

Na verdade, o shell e o bash

em particular é

uma linguagem de programação. Esse

prompt que aparece aqui

é capaz não somente de rodar um programa

com argumentos. Ele também pode fazer 
outras coisas como

while loops, for loops, condicionais...

Tudo isso. Você pode definir

funções, pode ter variáveis, todas essas

coisas você consegue fazer no shell.

Vamos abordar boa parte disso na próxima

aula sobre shell scripting. Mas, por ora,

vamos olhar para

essa variável de ambiente em particular.

Variáveis de ambiente são coisas que

estão definidas toda vez que você inicia 
o shell.

Vocês não precisam defini-las toda vez

que abrem o shell, há

várias delas que já estão definidas, como

onde fica seu diretório home, qual

é seu nome de usuário. Há uma que é
essencial

para esse caso em particular

que é a variável de caminho. Então se

eu digitar echo $PATH, ele vai

me mostrar todos os caminhos na minha 
máquina

onde o shell vai buscar por programas.

Vocês vão notar que isso é uma lista

separada por dois pontos. Ela pode ser

um pouco longa e difícil de ler, mas o
importante

é que, sempre que você digitar o nome de

um programa, o shell vai buscar nesta

lista de caminhos da sua máquina, olhando

em cada diretório em busca de um

programa ou arquivo cujo nome coincida

com o comando que você está tentando 
rodar. No meu caso,

quando tento rodar date ou echo, ele

vai rodar por essa lista um por vez

até achar um que contenha o

programa chamado date ou echo, e aí

ele vai rodá-lo. Se quisermos saber

qual exatamente ele roda, há um

comando chamado which. O which nos permite

fazer isso, então quando eu posso digitar 
which echo e ele

vai me dizer que, se eu quiser rodar um 
programa

chamado echo, ele iria rodar deste aqui.

Vale a pena pausar aqui e falar sobre o

que são caminhos. Caminhos são uma forma 
nomear a

localização de um arquivo em seu 
computador.

No Linux e no MacOS esses caminhos são

separados por /, então

você vai ver aqui que este está no

diretório root. O / logo no começo

indica que o caminho começa

no topo do sistema de arquivos.

Depois olha no diretório chamado

usr, depois no diretório chamado bin

e depois olha no arquivo chamado echo.

No Windows, caminhos como esse são
geralmente

separados por \.

Quando estamos no Linux ou MacOS,

tudo mora no root, então

todos os caminhos começam com um /, 
ou melhor, todos os

caminhos absolutos. No Windows, há um root

cada cada partição. Vocês já devem ter

visto coisas como C:\ ou D:\ .

No Windows, há um tipo de hierarquia

de caminhos de sistema para cada drive

que você tem,

enquanto no Linux e no MacOS

fica tudo sob um único nome.

Vocês devem ter notado que eu mencionei

caminho absoluto e talvez saibam o que 
isso

significa. Caminhos absolutos são caminhos

que determinam por completo a localização 
de um arquivo.

Neste caso, isso quer dizer que

queremos nos referir a um arquivo 
específico chamado echo

e estamos dando o caminho completo até

esse arquivo. Mas também há outro tipo

conhecido como caminhos relativos. Um

caminho relativo se refere a onde estamos
no momento.

Então a forma de saber onde estamos no

momento é digitando pwd que significa

"imprima o diretório atual".

Então, se eu digitar pwd, ele

vai mostrar o caminho atual onde estou

agora, ou seja, estou no diretório

home sob o diretório root e depois

john, depois dev e assim por diante.

Daqui eu posso então decidir mudar

meu diretório atual, e todos os

caminhos relativos são ligados ao

diretório atual, que é

basicamente onde estamos no momento.

Por exemplo, neste caso, eu posso digitar

cd \home. cd quer dizer 
"mudar de diretório".

Essa é uma forma de mudar meu diretório

atual. Neste caso, eu mudei

para o home e vocês vêem que

o prompt do shell mudou, agora dizendo

que estou no home. Ele simplesmente mostra

o nome do último segmento do caminho,

mas vocês também podem configurar o 
terminal para mostrar

o caminho completo onde quer que

vocês estejam. Agora se eu digitar pwd
de novo, ele

vai me dizer que estou no /home. Há alguns

diretórios especiais

aqui. Há o . e o .. . O .

se refere ao diretório atual e o ..

se refere ao diretório acima. Essa é uma

forma de navegar facilmente pelo

sistema. Por exemplo, se eu digitar cd ..

ele vai me dizer que estou agora no /,

ou seja, no root do sistema de

arquivos. Eu estava no /home e agora estou

no /. De fato, se eu digitar pwd, ele 
mostra

exatamente isso. Também posso usar

caminhos relativos para descer um nível no

caminho de arquivos. Então, se eu der 
cd . /home

ele vai me mover para o

diretório home sob o diretório atual.

E isso me leva

de volta ao /home. Se eu tentar agora
cd ./home

de novo, ele me avisa que não há nenhum

diretório com esse nome porque não há um

diretório home sob o diretório em que

estou agora, no qual entrei com o cd.

Eu consigo usar cd para voltar todo 
o caminho

que percorri, usando

caminhos relativos, e eu posso fazer
outras coisas

como ../../../../jon/ para voltar

para algum lugar lá dentro do meu sistema 
de arquivos.

Ocorre que ele está lá no root.

Aqui temos o diretório bin, e nele

há o arquivo echo. Daí eu

posso dar world e ele roda o

programa echo que está no bin.

Essa é uma forma com a qual vocês podem
construir caminhos para

atravessar arbitrariamente seu sistema
de arquivos.

Às vezes vocês vão querer usar caminhos
absolutos e

às vezes, relativos. Geralmente

vocês vão querer usar o que for mais curto

mas se vocês quiserem, por exemplo, rodar

um programa ou escrever

um programa que roda esse programa, como

echo ou date, e vocês querem poder

rodá-lo a partir de qualquer local, ou

vocês dão o nome do

programa, como date ou echo, e deixam o

shell usar o caminho para descobrir onde

ele está, ou vocês dão o caminho

absoluto, porque se vocês derem um
caminho relativo,

e eu for lá e rodar no meu diretório home,

e vocês rodarem em um outro diretório,

pode ser que funcione para mim mas não
para vocês.

Em geral, quando rodamos um programa, ele

vai operar no diretório

atual, ao menos esse é o padrão,

a não ser que passemos outros argumentos.

Isso é bem útil porque significa

que muitas vezes não temos de dar

o caminho completo para as coisas, podemos
simplesmente

usar o nome dos arquivos no diretório

em que estamos. Uma coisa

bem útil é descobrir em que diretório

estamos. Nós já

vimos o pwd que imprime o local

onde estamos, e há um comando chamado

ls que vai listar os

arquivos no diretório atual. Então se eu

digitar ls aqui, vemos todos os arquivos

no diretório atual, certo? É uma forma

boa de rapidamente navegar

através do sistema de arquivos. Vocês vão

ver que se eu der cd .. e depois ls, ele

me mostra os arquivos naquele diretório,

mas com o ls eu posso dar

ls .. e um caminho e

aí ele lista o que tiver naquele aquivo em

vez do que o que estou agora. Ele lista 
o outro

diretório. E vocês podem ver que se eu

for até o root também, certo, o root

tem outros arquivos. Um truque legal

que talvez vocês não conheçam aqui: há

dois outras coisas especiais que você
pode fazer.

Uma é usar o til. Esse

caractere te leva pro diretório

home. Então o til sempre se expande para

o diretório home e você pode usar

caminhos relativos a ele. Posso dar 
til / dev

/pdos/classes/missing-semester/ e

agora estou lá porque esse til se expandiu

para /home/john. Um outro argumento legal

que vocês podem dar para o cd 
especificamente

é, se vocêm derem cd -,

ele vai cd para o diretório onde você

estava antes. Se eu der cd -, volto

para o root.

Se der cd - de novo, volto para o 
missing-semester.

É uma maneira útil de ficar indo e vindo

entre dois diretórios diferentes.

Em caso do ls, ou em caso

do cd, pode haver argumentos que vocês

não conhecem, certo? Até agora, ainda não

fizemos muito mais do que

dar caminhos, mas como é que descobrimos

que é possível passar um caminho para o ls

pra começo de conversa? Bem, a maioria

dos programas aceitam o que chamamos de
argumentos, como

flags e opções. Essas são coisas que

geralmente são precedidas por um -. Um dos

usos mais úteis é --help. Muitos programas

implementam esse, então se vocês rodarem,

por exemplo, ls -help, ele proveitosamente

imprime um monte de informações sobre

aquele comando. Vocêm podem ver que ele

dize que o uso é ls e que é possível dar

um número de opções, e um número de

arquivos. A forma de se ler essa linha é

três pontos significa zero ou um

ou mais e os colchetes

querem dizer opcional. Nesse caso,

há um número opcional de opções

e um número opcional de arquivos.

Vejam que ele explica o que o programa

faz e também especifica um número

de diferentes tipos de flags e opções

que podemos escolher. Geralmente
chamamos essas coisas

com um - e uma única letra

de flag ou qualquer coisa que

não leva um valor de flag, e qualquer

coisa que leva um valor chamamos de
opção. Então,

por exemplo, - a and - all são ambos flags

e -C ou --color é uma opção. Uma coisa

que vocês vão ver se descerem bastante a

tela é a flag -l. Ops.

A flag -l usa

o formato de lista longa. Isso é

especialmente útil por si só,

mas vamos ver o que ela faz.

Se eu der ls -l, ele imprime

os arquivos no diretório atual, mas ele

dá muito mais informação sobre esses

arquivos. Vocês vão ver que vão usar

bastante isso porque

essas informações adicionais que ele

mostra são geralmente bem úteis. Vamos

ver um pouco dessas informações.

Primeiramente, o d no começo

de alguns desses itens

indica que aquele item é um diretório.

Então o _data aqui, por exemplo,

é um diretório,

enquanto o html não é um diretório,

mas sim um arquivo. As letras seguintes

indicam as permissões que estão

definidas para este arquivo. Então, como

vimos antes, talvez eu não consiga abrir

um certo arquivo ou não consiga

entrar em um diretório. Tudo isso é

regido pelas permissões daquele arquivo

ou diretório em particular. A maneira de

interpretar isso é: o primeiro dos três

grupos são as permissões definidas para o

dono do arquivo. Todos esses arquivos

que estamos vendo têm eu dono como.

O segundo grupo de três caraceteres se 
refere

às permissões do grupo que é dono desse

arquivo. Neste caso, todos esses arquivos

também pertencem ao grupo john.

Já o último grupo de três é uma lista

das permissões para todo o restante, 
ou seja,

qualquer um que não seja nem dono nem 
membro do grupo.

Esse diretório está um pouco sem graça

porque eu sou o dono de todos os itens,

mas se dermos cd /

ls -l vocês vão ver que

aqui todos os arquivos pertencem ao root.

Vamos voltar para esse assunto do 
usuário root, só vejam

que aqui as permissões são

um pouco mais interessantes. Os grupos de

três significam leitura, escrita e 
execução.

Isso signifca coisas diferentes para 
arquivos e para

diretórios. Para arquivos, é bem simples:

se vocês tiverem permissão de leitura para

um arquivo, vocês conseguem ler seu

conteído. Se tiver permissão de escrita

para um arquivo, podem salvá-lo

e adicionar conteúdo a ele, ou até

substitui-lo completamente. E se você

tiver x na execução de um arquivo,

você pode executá-lo. Então,

se dermos ls -l /usr/bin,

vocês verão que todos

têm a permissão de execução ativada

para todas as pessoas que não forem donas

do arquivo. É assim porque o programa

echo, por exemplo, queremos que possa

ser executado por qualquer um usando
o computador.

Não há motivo pra dizer que apenas

alguns usuários podem rodar o echo.

Isso não faz sentido.

Já para diretórios, essas permissões

são um pouco diferentes. Leitura

quer dizer que podemos olhar quais

arquivos existem dentro desse diretório.

Associem leitura como list para 
diretórios.

Estamos autorizados a listar seu conteúdo?

Escrita para um diretório diz se estamos

autorizados a renomear, criar ou remover

arquivos dentro dele. Faz sentido,

mas lembrem-se de que isso significa que,

se vocês têm permissão de escrita em um 
arquivo

mas não têm permissão de escrita no

diretório dele, vocês não podem deletar o
arquivo.

Você pode esvaziá-lo, mas não deletá-lo,

porque para isso seria preciso escrever

no diretório em si. Finalmente, execução

em diretórios é algo que confunde bastante

as pessoas. Executar em um diretório

é o que se chama buscar. O nome

não ajuda muito, mas o que quer dizer é

que podemos acessar esse diretório se

quisermos chegar a um arquivo.

Se quisermos abri-lo, lê-lo ou

escrever nele, ou qualquer outra coisa,

para dar cd e entrar em um diretório

é preciso ter permissão de execução em

todos os diretórios acima dele e

no próprio diretório. Por exemplo,

para eu acessar um arquivo dentro de

/usr/bin como o /usr/bin/echo, preciso

ter permissão de execução no root,

no usr, no

bin. Se eu não tiver algum deles,

não terei permissão

de acessar aquele arquivo, porque

não terei acesso aos diretórios ao longo
do caminho até ele.

Vocês podem encontrar outros bits,

por exemplo, vocês podem ver

s ou t nessas listas, ou l.

Podemos conversar no tira-dúvidas

se ficarem curiosos,

a maioria não importa muito para

os assuntos que vocês vão ver neste curso,

mas é legal conhecer. Então, se quiserem

saber mais sobre eles, pesquisem

ou venham falar conosco.

Há outros programas que é bom

conhecer. Desculpa, uma coisa mais.

Como eu mencionei, se vocês só verem um -

significa que vocês não têm aquela

respectiva permissão. Por exemplo, se

houver r-x, quer dizer que vocês podem

ler e executar, mas não ler.

Há outros programas úteis

para vermos agora.

Um deles é o comando move ou mv.

Se eu der cd de volta para 
missing-semester, aqui o mv

me permite renomear um arquivo usando

dois caminhos, o caminho antigo e o

caminho novo. Ou seja, move nos permite

tanto renomear um arquivo, como quando

mudamos o nome do arquivo mas não o

diretório, ou ele permite mover

um arquivo para um diretório diferente.

É só dar o caminho atual do arquivo

e o caminho para onde vocês querem movê-lo

e isso vai alterar sua localização e

seu nome. Por exemplo, eu posso mover

dotfiles.md para foo.md

e, da mesma forma, posso mover

de volta. Há também o comando cp.

O cp ou copy é bem parecido,

ele nos permite copiar um arquivo também

usando dois argumentos, o caminho de onde

queremos copiar e o caminho para onde

queremos copiar. Esses são caminhos 
completos, então eu poderia

usar isso, por exemplo, para dizer que 
quero

copiar dotfiles.md to ../foo.md.

E agora se eu der ls .

vocês podem ver que há um arquivo foo.md

naquele diretório. O cp também

recebe dois caminhos, não é preciso ser no

mesmo diretório. Igualmente existe o

comando rm que nos permite remover

um arquivo e também dá para dar caminhos.

Nesse caso, estou removendo ../foo.

Lembrem-se que o remover,

especialmente no Linux, por default

não é recursivo, então não dá para remover

um diretório usando rm. É preciso passar

a flag -r que nos permite

remover recursivamente e depois o

caminho que quer remover. Daí ele

remove tudo que estiver sob este 
diretório. Há também

o comando rmdir que permite

remover um diretório mas só se

ele estiver vazio. Então a

ideia aqui é criar um mecanismo pra

nos dar uma certa segurança, para não

jogarmos fora acidentalmente um monte

de arquivos. O último comandozinho

que é útil usar é o mkdir que

permite criar um novo diretório.

Como falamos antes, você não quer fazer

algo assim porque senão ele vai

criar dois diretórios, um chamado

my e outro chamado photos. Para criar

um diretório assim é preciso escapar

o character de

espaço ou usar aspas.

Quando vocês quiserem mais informação

sobre como qualquer comando

nessas plataformas funciona, há um

comando bem útil para isso, que

invoca o programa chamado man,

que significa manual pages. Este programa

pede como argumento o nome de outro 
programa

e retorna seu manual. Então, por exemplo,

podemos digitar man ls e isso vai mostrar

a página do manual do ls. Vocês vão ver

que, nesse caso do ls, o resultado é bem

parecido com o que vemos com ls -help,

porém é mais fácil navegar e

ler. Mais pro final da página vocês

encontram exemplos

sobre quem escreveu o programa,

onde encontrar mais informação e esse

tipo de coisa. Algo que pode causar 
confusão

às vezes,

ao menos até a versão mais atual em que

eles adicionaram essa árvore no final,

que diz q para sair, é que eles não 
costumavam

dizer isso, aperte q para sair deste

programa. Pode ser bem difícil de sair

pra quem não conhece. Falando nisso,

um atalho de teclado legal aqui é
ctrl+l

que limpa o terminal e volta pro topo.

Até agora só falamos sobre

programas isolados, mas o

poder do shell, na verdade, aparece

na hora em que começamos

a combinar diferentes programas, certo?

Então, em vez de rodar cd e rodar ls etc,

vocês poderiam querer encadear

diversos programas, ou

querer interagir com arquivos e

operá-los entre um programa e outro.

A forma de fazer isso é usando a

noção de streams que o shell nos dá.

Todo programa, por default, tem...

vou simplificar um pouco e falar de

dois streams primários, o de entrada

e o de saída. Por default, o stream de

entrada é basicamente seu teclado,

seu terminal, e

o que quer que você digite no terminal vai

acabar parando no seu programa, que tem

um stream de saída padrão, que é

usado sempre que o programa imprime

algo. Ele imprime no stream e, por padrão,

é também seu terminal. É por isso que

quando digito echo hello, isso é impresso

no terminal. Mas o

shell lhes dá uma forma de redirecionar

esses streams para mudar onde é a entrada

e a saída de um programa.

A maneira mais fácil de fazer isso é

usando o < e >. De modo que vocês podem

escrever algo assim ou escrever algo

assim. O > significa que

a entrada pra esse programa deve ser

redirecionada para o conteúdo desse

arquivo e o < significa que

a saída do programa precedente deve ser

redirecionada para este arquivo. Vamos

ver um exemplo de como isso funciona.

Se eu der echo hello, posso dizer que 
quero que

o conteúdo seja salvo em

um arquivo chamado hello.txt. Como eu dei

esse caminho relativo, ele vai criar

um arquivo no diretório atual

chamado hello.text. Ao menos teoricamente

seu conteúdo deveria ser a

palavra hello. Se eu rodar isso, vejam

que nada aparece na minha saída, da

última vez que rodei echo hello

a palavra hello aparecia na tela.

Agora, essa saída foi direcionada para um

arquivo chamado hello.txt. Dá para 
verificar

isso usando um programa chamado cat.

O cat imprime na tela o conteúdo de um
arquivo, então

posso rodar hello.txt e ele mostra

hello. Porém o cat também permite

esse tipo de direcionamento, então posso

dizer cat, que por default imprime sua

entrada na tela, ele apenas duplica 
a entrada

na saída. Posso dizer que quero que

pegue sua entrada do hello.txt, e o

que vai acontecer neste caso é que

o sheel vai abrir o hello.txt,

pegar seu conteúdo e definir isso como

a entrada do cat, e aí o car vai imprimir

isso na sua saída. Como não direcionei a 
saída,

vai aparecer no

meu terminal. Então ele vai simplesmente
imprimir

hello na saída. Posso usar ambos

ao menos tempo, por exemplo,

se quero copiar um arquivo sem usar o

comando cp por algum motivo,

posso fazer assim. Neste caso, não

estou passando nada ao programa cat,

só estou dizendo, funcione normalmente,

o programa cat não sabe

nada sobre esse redirecionamento. Mas

estou dizendo ao shell para usar o 
hello.txt

como entrada para o cat e para escrever

o que quer que seja que o cat vai soltar
no arquivo hello.txt.

De novo, nada aparece no meu terminal,

mas se

eu der cat hello2.txt, vejo a saída como

era esperado, que é uma cópia do arquivo

original. Há, também, o sinal >>

que significa anexar em vez de

escrever por cima. Então você vai notar

que se eu digitar

cat < hello.txt > hello2.txt

de novo e depois cat hello2.txt,

ele ainda contém somente hello, apesar de

já conter um hello antes. Se eu mudar para

>> para anexar

e digitar cat nesse arquivo,

agora hello aparece duas vezes. São

comandos bem simples, geralmente

só para interagir com arquivos, mas

isso fica realmente interessante se 
usarmos

um operador adicional do shell chamado

pipe. O pipe é uma barra vertical

e o que ele faz é pegar

a saída de um programa à esquerda e

torná-la entrada do programa

à direita. Vamos ver como funciona.

Vamos usar o exemplo do ls -l /

Isso imprime um monte de coisas. Digamos

que eu só quero a

última linha dessa saída. Bem, há um

comando chamado tail. O tail imprime

as últimas n linhas da entrada, então

posso digitar -n 1. Essa é a flag chamada

n. Também dá pra usar --lines se quiserem

uma opção mais longa, mas nesse caso

o que isso faz é imprimir a última

linha. Posso escrever tudo junto,

ls -l | tail -n 1.

Vejam aqui que o ls não sabe

nada sobre o tail e o tail não sabe nada

sobre o lr. São programas diferentes e que

nunca foram programados para ser 
compatíveis

um com o outro. Tudo que eles sabem

fazer é ler uma entrada e escrever em uma

saída. É o pipe que os conecta

e, nesse caso particular, estou dizendo

que quero que a saída do ls sirva de

entrada para o tail e quero que a saída

do tail vá para o terminal porque não

a redirecionei.

Eu também poderia definir que

a saída deveria ir para ls.txt e,

nesse caso, se eu der cat ls.txt vou

ver a saída apropriada. Ocorre que

é possível fazer coisas muito elegantes
com isso.

Nós vamos ir mais a fundo na aula

'Duelando com os Dados' daqui

uns quatro dias, sobre as coisas

mais elaboradas que vocês podem fazer

ao construir pipelines mais avançados.

Pra dar um exemplo, podemos digitar

curl --head --silent google.com.

Só para mostrar como isso funciona,

esse comando retorna todos os
cabeçalhos HTTP

para acessar google.com. E eu posso mandar

isso direto para o grep --ignore-case

ou -i se preferir, depois -content-lenght.

Isso vai imprimir o

tamanho do conteúdo do cabeçalho. O grep

é um programa sobre o qual vamos falar 
mais tarde.

Ele nos permite buscar uma palavra-chave

em um stream de entrada. Podemos usar o
pipe para mandar

para o comando cut, que recebe um

delimitador, escolhido como espaço, e eu

quero o segundo campo. Isso imprime

apenas o tamanho do conteúdo. Esse é

um exemplo bobo, só para

extrair o tamanho em bytes

do google.com pela linha de comando.

Não é algo muito útil,

mas serve para mostrar que, encadeando

essas coisas, conseguimos obter

diversos efeitos de manipulação de texto.

E os pipes não servem apenas para

dados de texto, dá para usá-lo com

imagens também. Podemos ter um

programa que manipula uma imagem em

binário como entrada e escreve uma

imagem em binário como saída. E é 
possível encadeá-los

dessa forma (vamos dar mais exemplos

mais pra frente).

É possível usá-lo até com

vídeo se vocês quiserem.

Por exemplo, uma ótima maneira de

ter um chromecast em casa: você pode

stream um arquivo de vídeo ao definir

que o último programa no seu pipe é um

chromecast send. Com isso, dá para enviar

um arquivo de vídeo para o streaming ou

usar http para seu chromecast.

Vamos falar bem mais sobre isso na aula

'Duelando com os Dados'. Uma coisa mais

que gostaria de mostrar é como

usar o terminal de uma forma mais

interessante e talvez mais poderosa

do que vocês estão acostumados.

Essa dica talveu vai ser válida até para

quem já se sente mais

confortável com o terminal.

Primeiro precisamos abordar um tópico

importante no que diz respeito aos 
sistemas Linux

e MacOS em particular, que é a noção

de usuário root. O usuário root é como

o administrador no Windows,

ele tem ID 0.

O usuário root é especial porque ele

pode fazer o que quiser

no seu sistema, ainda que um arquivo não

possa ser lido ou escrito por mais

ninguém, o root ainda pode acessá-lo.

O root é como um super usuário

que faz o que quiser.

Na maiorias das vezes, vocês não vão

operar como o super usuário, vocês não

vão ser o root. Vocês vão ser um usuário
como john

ou qualquer que seja seu nome, Esse vai

ser seu usuário, com o qual vocês agem,

porque se vocês operassem seu computador

como o usuário root o tempo todo,

e rodasse um programa errado, pode ser

que destruiriam o computador. Vocês não

querem fazer isso, certo? Mas de vez em 
quando

vocês podem querer fazer algo que requeira

que vocês sejam root. Para esses casos,

normalmente vocês vão usar um programa
chamado sudo

or 'faça como su" e, nesse caso, su 
significa

super usuário. Essa é uma forma de fazer

algo como super usuário.

Normalmente funciona assim:

escrevemos sudo e depois o comando

como fazemos no terminal. Ele vai

rodar aquele comando como se você

fosse o root em vez do seu usuário normal.

Onde vocês podem precisar de algo assim?

Bem, um há vários arquivos de sistema

especiais no seu computador,

mas, em particular, há um

chamado sysfs. Se você der cd /sys,

vamos para um mundo bem diferente.

Esse arquivo de sistema não é exatamente

um arquivo em seu computador. Na verdade,

são vários parâmetros do kernel. O kernel

é basicamente o cérebro do seu computador.

Essa é uma forma de acessar os diversos

parâmetros do kernel através do que

se parece com um arquivo de sistema. Vejam

que se eu der cd em class, por exemplo,

há diretórios para um monte de tipos

diferentes de dispositivos com os quais

posso interagir, ou muitas filas que 
posso acessar

ou uma variedade de botões internos

esquisitos. Como eles estão mostrados 
como arquivos,

dá para usarmos todas as ferramentas que

já vimos para manipulá-los.

Um exemplo disso é se vocês entrarem

em sys class backlight, esse backlight

permite que configuremos diretamente

a luz do nosso laptop, se ele tiver uma.

Se eu der cd e entrar no intel backlight,

porque esse é um laptop da Intel,

aqui vocês vêem que há um arquivo chamado
brightness

e eu posso cat brightness. Esse é o brilho

atual da minha tela. Mas mais que isso,

posso modificá-lo também para mudar o

brilho da tela. Então

vocês podem pensar que consigo...

deixe-me ver qual é o brilho máximo.

Ok, agora está no máximo.

Vocês podem imaginar que eu

poderia fazer algo como echo,

vamos reduzir,

echo 500 para brightness,

se faço isso ele diz

que a permissão foi negada. Eu não posso

modificar o brilho porque, para fazê-lo,

para modificar coisas no

kernel, é preciso ser o

administrador. Vocês podem pensar

que a forma de resolver isso é digitar

sudo echo 500 mas ainda assim a

permissão é negada. Por que?

Porque, como mencionei, esses

redirecionamentos de entrada e saída não

são algo que os programas saibam quando

usamos o pipe com o ls e o tail, o tail

não sabia do ls e o ls não sabia do tail.

O pipe e o redirecionamento foram 
estabelecidos

pelo shell, então, nesse caso,

o que está ocorrendo é que estou
dizendo ao shell

para rodar o programa sudo com os 
argumentos

echo e 500 e mandar essa saída para o

arquivo chamado brightness, mas é o shell

que está abrindo o arquivo brightness,

não o programa sudo. Nesse caso, é

o shell que está rodando quando eu tento

abrir o arquivo brightness para escrever
nele

e ele não tem permissão para fazer isso.

Portanto, ele dá erro.

Vocês já devem ter visto isso quando

buscam algo e acabam, no Stack Overflow

e dizem para rodar um comando tal

e eles falam, por exemplo,

eles dão uma instrução

como 1 > /sys/class

net ipv4 word, por exemplo.

Isso é algo que vocês podem ter visto se

tiverem tentado configurar um firewall

e esse comando tem de funcionar

porque o simbolozinho de hashtag

indica que deve roda como root.

Isso é raramente explicado,

mas é isso que o # significa.

Vejam no meu prompt um símbolo $

que indica

que não estou rodando como root.

Então a questão é como eu faço pra 
resolver isso?

Bem, eu poderia mudar para outro terminal

como root, e um jeito de fazer isso é

rodar sudo su, que significa 
'rode o seguinte

comando como root' e o su é um comando

complicado que nos abre um shell como

super usuário. Então se faço isso,

entro a senha, vocês podem ver

que o nome de usuário no início

mudou de john para root, e o prompt

mudou de $ para #.

Se eu agora der echo 500 para

o arquivo brightness, minha tela

ficou um pouco mais escura. Vocês

não conseguem ver então terão de acreditar
em mim. Não deu nenhum

erro porque agora o shell está

rodando como root e não mais como

john. O usuário root tem permissão de

abrir esse arquivo. Mas com o que sabemos

sobre o terminal agora, há, na verdade,

uma maneira de fazer isso sem ter

de abrir um shell root. Funciona assim.

Deixe-me voltar para 1060.

Vocês vêem por que está diferente

aqui? Estou dizendo ao shell para

rodar o comando echo 1060,

e estou dizendo para rodar o

comando sudo tee brightness.

Estou dizendo para mandar a saída do

echo para o sudo tee. Para entender isso

vocês precisam saber o que o comando 
tee faz.

O comando tee pega sua entrada e a escreve

tanto em um arquivo quanto na tela.

Então o tee é uma maneira conveniente se

vocês tiverem, por exemplo, um arquivo 
de logs que queiram enviar

para deixar guardado para mais tarde,

mas também querem checar vocês mesmos.

Vocês podem usar o pipe para mandá-lo
para o tee, passar o nome de

um arquivo e ele vai escrever o que quer
que esteja na sua

entrada tanto no arquivo quanto na sua

tela. Aqui estou aproveitando esse

programa, estou dizendo 'rode o tee como

rota e use o tee direto no arquivo
brightness.

Nesse caso, o programa tee,

que é quem está abrindo o arquivo 
brightness,

está rodando como root, então ele

tem permissão de fazer isso.

Se eu rodar de novo, vocês não conseguem

ver, mas o brilho aumentou no laptop,

não deu nenhum erro

e não foi preciso abrir um shell como

root e rodar comandos nele,

o que muitas vezes pode ser perigoso.

Se vocês quiserem explorar esses
arquivos de sistema

um pouco mais, há bastante coisa

interessante aqui. Se vocês

derem uma navegada por aqui,

vão achar bastante coisas divertidas.

Por exemplo, nós notamos que tem um

comando legal para o brilho aqui, que

outros tipos de brilhos eu poderia 
definir?

Eu posso usar o comando find, sobre o

qual também vamos falar numa próxima aula,

Quero olhar qualquer arquivo cujo nome

se parece com brightness no

diretório atual. Não ajudou muito, talvez

não sejam arquivos. Será que soletrei
errado?

Hum, por que não funciona?

Oh, parece que ele não quer buscar por

brightness. Para a sorte de vocês eu já

conheço um legal.

Há um subdiretório chamado leds e

leds também têm brilho. Que tipos de leds

existem? Um monte!

Por exemplo, o led da tecla scroll lock.

A maioria de vocês provavelmente não sabe

o que é o led do scroll lock e muito

menos o que o scroll lock faz. Talvez
vocês já viram uma tecla

no teclado chamada scroll lock.

Basicamente ninguém mais sabe pra que

serve, ninguém usa pra nada.

É quase uma tecla morta e

um led morto. E se vocês quisessem

configurá-lo para que, toda vez que

chegar um e-mail, o led do scroll lock
acender?

Por que não tem nenhuma outra razão para

ele acender. Bem, se entrarmos nesse

diretório que tem um brilho

definido como 0.

Bom, o que acontece se eu escrever 1 nele?

É aconselhável vocês não saírem

escrevendo números aleatórios em qualquer
arquivo

deste diretório porque isso vai afetar

diretamente o kernel. Dêem uma olhada 
antes

no que os arquivos fazem. Nesse caso aqui,

eu fiz uma pesquisa prévia com cuidado.

Vocês não conseguem ver, mas agora

no meu teclado o led da tecla scroll lock

está aceso. Se eu escrevesse um programa

que checa e-mails, eu poderia, no final

do programa, rodar um outro programa que

manda echo 1 para este arquivo, e portanto

teria uma maneira de acender o led do meu

teclado para indicar que chegou um e-mail.

Nessas alturas, vocês já devem saber

mais ou menos se virar

com o terminal, o shell e conhecer o

bastante para realizar essas tarefas

simples, ao menos teoricamente. Vocês não

deveriam mais precisar de

interfaces dependentes do mouse para

encontrar arquivos.

Um truque que faltou mostrar e vocês

podem precisar é o de abrir arquivos.

Até agora só mostrei como encontrar

arquivos, mas algo que vocês precisam

saber nesse curso é usar o

xdg-open. Esse provavelmente só vai

funcionar no Linux. Acho que no MacOS ele

se chama open e no Windows... sei lá.

O xdg-open recebe o nome de um arquivo e

vai abri-lo usando o programa apropriado.

Se vocês derem xdg-open em um arquivo

html, ele vai abrir o navegador

e abrir o arquivo. Uma vez que têm esse

programa, teoricamente vocês não

precisam nunca mais abrir uma janela do

buscador. Talvez precisem por outros

motivos, mas em teoria vocês conseguem

fazer tudo usando as ferramentas

que aprendemos hoje. Talvez pareça tudo

relativamente básico para alguns de vocês,

mas como eu mencionei, hoje tivemos

uma introdução. Agora sabemos como o

shell funciona e muito do que vamos

fazer nas próximas aulas é usar esse

conhecimento para fazer coisas bem

interessantes usando o shell.

Ou seja, hoje vimos como usar a interface

que vamos precisar, então é importante

todos saberem. Na próxima aula,

vamos falar bastante sobre como

automatizar tarefas como essas,

como escrever scripts que rodam um monte

de programas pra nós, usando

condicionais, loops etc no terminal,

ou mesmo coisas como rodar

um programa até ele quebrar, o que pode

ser bem útil em casos que queremos

rodar algo até os testes darem erro,

por exemplo. Então esse será o tópico da

aula na próxima semana. Você tinha
uma pergunta?

Sim, com relação ao que você mostrou no

diretório sys, provavelmente só vai 
funcionar

se você estiver usando o subsistema do
Windows pro Linux...

Boa pergunta, eu não sei se

o subsistema do Windows para Linux vai

deixar aberto esses arquivos de sistema 
no sys. Se deixar,

provavelmente vai mostrar só

umas poucas coisas...

Não sei, dê uma olhada.

Algo que vocês vão ver é que as notas

de aula dessa aula já estão

online, e no final do arquivo

tem diversos exercícios. Alguns

são relativamente fáceis, outros um

pouco mais difíceis. Sugerimos

tentar resolvê-los.

Se vocês já sabem esse conteúdo,

vai ser bem rápido,

e se não sabem vai servir para aprenderem

um monte de coisas que talvez vocês

percebam que não sabiam. No tira-dúvidas,

que vai acontecer logo

após essa aula, ficaremos felizes

em ajudá-los com os exercícios ou

com outros comandos que vocês vão

aprender nesse processo e queiram saber

como usar de forma eficiente. Enão na

próxima aula, já amanhã, vamos assumir

que vocês estão por dentro desse tipo
de coisa

que os exercícios vão ensinar.

Há também um endereço de e-mail

no website, vocês podem mandar questões

que aparecerem depois do tira dúvidas.

Mais alguma pergunta

antes de terminar por hoje? Não?

Tudo bem, estaremos disponíveis no

nono andar do prédio Gates, o 32,

dentro de cinco minutos.

Vejo vocês lá!