IT Life

Visto de fora, o movimento do software livre muitas vezes é diretamente ligado a pirataria. Isso não é verdade. Se você está lendo esse blog, não deve ser nenhuma novidade. O que eu quero discutir aqui é como a pirataria influencia o desenvolvimento do software livre.

Vamos começar com um exemplo. Há pouco tempo o hacker geohot encontrou meios de ter controle total sobre o playstation 3, como pudemos acompanhar no seu blog. Jogos atualmente são programas extremamente complexos, envolvendo várias áreas de conhecimento, como arte, programação e física, só para citar algumas. Temos algum esforço de desenvolvedores produzindo jogos livres, porém é indiscutível que, quando o assunto é jogos, o mercado privado é muito superior. Essa superioridade se deve aos jogos piratas.

Programadores só tem interesse em desenvolver software livre que serão usados. Não há sentido em escrever código que nunca vai ser rodado ou lido. O público, por sua vez, sempre tenta rodar os melhores jogos possíveis, porém, grande parte deles não tem interesse em pagar para isso. Nesse ponto, existem duas alternativas: Jogos piratas ou jogos grátis. Eles acabam escolhendo pela qualidade; Jogos piratas desenvolvidos por grandes empresas são muito superiores em vários aspectos aos grátis (o que inclui os livres). Desse modo, poucos optam por utilizar os jogos livres, e como há poucos usuários, há pouco interesse no desenvolvimento desses jogos. Isso fecha o nosso ciclo de dependências do exemplo.

Como consequência direta disso, temos poucos esforços para desenvolver jogos livres. Um meio de quebrar esse ciclo seria impedindo a pirataria de software; Assim, teríamos menos opções para os usuários não dispostos a investir em jogos, então mais usuários utilizariam jogos livres, e consequentemente, mais desenvolvimento seria direcionado para eles. Seguindo essa lógica, um novo ciclo seria formado: O aumento do numero de usuários de jogos livres geraria um crescimento no número de desenvolvedores, que por vez elevaria a qualidade dos jogos, e que novamente aumentaria o número de jogadores. Após algum tempo, jogos livres estariam sendo escritos com tanta qualidade (se não mais) do que os jogos das grandes empresas de software. Essas empresas, por sua vez, precisariam de bastante criatividade e esforços para manter o seu público, o que conseguiriam, pois trata-se de uma indústria altamente criativa e inovadora.

Esse exemplo dos jogos pode ser generalizado para muitos outros softwares. É só uma questão de explorar o software livre para que ele seja cada vez mais útil.

Nesse tutorial, vou explicar (o mais brevemente possível) como transformar o vim em um poderoso editor de código, ensinando a configurar e usar algumas features do próprio vim. Introduzirei assunto por assunto, e então mostrarei onde eles podem ser aprofundados. Essa é apenas a pontinha do iceberg. Digo isso pois eu não domino o vim completamente, sou apenas um usuário mediano. Tenha medo dos usuários avançados :)

Antes de ler esse tutorial, recomendo fortemente aprender a usar o básico do vim. Não tem porque configurar o vim como editor de código se não sabe usar ele como editor de texto! Motivação não falta. Para começar, sugiro a lógica da bicicleta; você só aprende usando. Felizmente existe um tutorial do vim que utiliza ele mesmo para ver/editar. Para aprender a usar o básico do vim, sugiro usar o comando:

vimtutor

Somente depois de entender o básico você conseguirá utilizar (produtivamente) o vim como ferramenta de edição de código.

Arquivos de configuração

O vim, assim como todo bom programa de linux, funciona carregando configurações de dois diferentes lugares: Se disponível, carregará do seu usuário, se não, carregará do próprio sistema. Os arquivos de configuração do sistema podem ser encontrados no caminho “/usr/share/vim”. Os do usuário, podem ser encontrados em sua home, no caminho “~/.vim” e o arquivo “~/.vimrc”. Possivelmente o arquivo e pasta não existem no home do seu usuário, mas você pode cria-los normalmente. No caso do .vimrc, uma boa opção é copiar o padrão da sua distribuição na sua home, renomear o arquivo para .vimrc e começar a editá-lo, assim mantendo as configurações que estavam sendo usadas até o momento com o seu usuário.

Com dois possíveis caminhos a seguir, você vai acabar se perguntando qual dos dois configurar. Sugiro que você configure os arquivos de sua home, por vários motivos, como a portabilidade para qualquer computador (casa, trabalho e amigos), e a padronização da sua distribuição para novos usuários em computadores compartilhados, caso se aplique. Além disso, é mais provável que você tenha uma partição separada para o “/home” do que para o “/usr”. (dica fora de hora: caso não tenha, não seria uma má prática para futuras instalações, pois assim pode-se manter seus arquivos e configurações mesmo trocando o sistema :D).

O arquivo ~/.vimrc é praticamente um script carregado quando o vim é aberto. Nele, escreve-se qualquer comando que você poderia utilizar normalmente de dentro do vim, por exemplo “:set number”. Vou dar algumas sugestões para preencher esse arquivo na próxima sessão deste tutorial.

A pasta ~/.vim contém, entre outros, plugins e documentação dos plugins. Ensinarei como utilizar plugins em outro post, em um futuro breve.

Configurações básicas do .vimrc

A maior parte das configurações do .vimrc consiste em setar variáveis ou atribuir algum valor a elas. Para comentar o seu .vimrc, isso é, escrever trechos que não serão interpretados como comandos de inicialização, deve ser utilizado aspas duplas. A partir da primeira ocorrência das aspas duplas até o final da linha será considerado comentário.

Segue então algumas configurações básicas retiradas do meu arquivo .vimrc. Os comentários explicam brevemente o que significa cada linha. Essas variáveis configuram muitas características do vim, por exemplo, encoding, compatibilidade, tamanho das tabs, verificação ortográfica, highlight de buscas, mouse, entre outros.

" Sem categoria
set termencoding=utf8 "encoding do terminal
set nocompatible "Aumenta a independencia do vim com o vi
set history=50 "Numero de comandos mantidos no histórico do vim
set nospell "Desliga verificação ortográfica; você depois pode associar ela com .txt.
"set spell "liga a verificação ortográfica; eu não utilizo, somente em arquivos .txt

set title "mostra o nome do arquivo na barra de título do terminal
set showcmd "mostra os comandos digitados no rodapé
set showmode "mostra o modo do vim (comando/inserção/...) no rodapé
set ruler "mostra a linha e coluna do cursor no rodapé
set number "numera as linhas

set mouse=a "habilita o uso do mouse
filetype plugin on "habilita a carga de plugins especificos de certos tipos de arquivos, quando reconhecidos

"search
set ignorecase "ignora maiusculas/minusculas na busca
set smartcase "quando alguma letra da busca for maiúscula, não ignora maiúsculas/minúsculas
set incsearch "pesquisa enquanto a palavra está sendo digitada
set hlsearch "coloca highlight nas palavras encontradas

""" cores
syntax on "habilita highlight de sintaxe
set bg=dark "modifica as cores padrões; escolha dark para fundo preto, light para fundo branco (fundo do terminal)

"""" Tabulações
set shiftwidth=4 "numero de espaços para o autoindent, entre outros
set softtabstop=4 "numero de espaços quando precionado tab ou backspace
set tabstop=4 "numero de espaços de um tab
set autoindent "identação automática
set lcs=tab:»· "marca os tabs

Mais informações sobre uma variável específica pode ser conferida utilizando a ajuda online do vim, com o comando

:help VARIÁVEL

Tabs

O Vim tem suporte nativo a tabs. Os comandos básicos para esse suporte são os seguintes: Para abrir uma tab, use “:tabnew”. Para ir para a próxima tab ou voltar, use “:tabnext” e “:tabprev”, respectivamente.

Aconselho adicionar essas linhas no seu .vimrc:

"""" Tabs
set list "Lista as tabs de arquivos abertas
set showtabline=1 "Mostra a linha de tabs apenas se tiver 2 ou mais tabs abertas.
set tabpagemax=10 "Limita o numero máximo de tabs que podem ser abertos ao mesmo tempo

Para saber mais sobre tabs, use o comando “:help tabs”

Maps

Uma característica avançada do vim é a capacidade de mapear teclas para funções específicas. Essa habilidade é conhecida também como “key binding”, porém no vim ela é referida tradicionalmente como “map”. Os maps são definidos diretamente no .vimrc, assim como as variáveis. Como exemplo, temos o seguinte map:

map <C-c> :wq<CR>

O map definido acima mapeia a combinação de teclas Ctrl+c para a sequencia de teclas “:wq.”, seguido de um enter. Assim, se você estiver no modo de comando, o vim irá salvar o texto e sair. Caso esteja no modo de inserção, ele Digitará o texto :wq e quebrará a linha. Como você pode notar, ele funciona simplesmente como se as teclas acabassem de ser digitadas, e o que acontece depende do modo que você está. Para isso, o comando map pode ser precedido por i, n ou v, para que o mapeamento funcione em apenas um modo (Insert, Normal e Visual, respectivamente). Ainda existem oturas restrições semelhantes, que podem ser conferidos na ajuda online do vim; esses são os básicos. Assim, para ter um resultado mais interessante, podemos fazer o seguinte mapeamento:

nmap <C-c> :wq<CR>
imap <C-c> Nunca gostei de milho verde sem manteiga.

Com um teste rápido, podemos ver que agora as mesmas teclas tem ações diferentes, dependendo do modo que você está.

Ainda existe uma opção muito útil relativa ao map, que é a “nore”. Normalmente, se forem definidos dois mapeamentos com as mesmas teclas de ativação, funcionando no mesmo modo, o segundo map “sobrecarrega” o primeiro. A opção “nore” serve para que uma vez que um map tenha sido definido, ele não seja remapeado. Por exemplo, podemos definir os mesmos maps acima do seguinte jeito:

nnoremap <C-c> :wq<CR>
inoremap <C-c> Nunca gostei de milho verde sem manteiga

É interessante definir seus maps como noremap.

Os mapeamentos das teclas especiais são bastante estranhos únicos. Um <C-x> Significa Ctrl+x, que é diferente de <C-X>. Ainda existem mapeamentos no estilo <F5>, <UP>, <CR> (carrige return, ou enter), <ESC>, <Tab>, entre outros. Essas teclas estão documentadas no “:help key-notation”

Mais informações sobre maps podem ser obtidas na ajuda online do vim, com o comando “:help map”

Folding

Folding é a capacidade de esconder partes de código que não interessam em um determinado momento, tornando o código mais visível. Muitos programadores não gostam, mas na minha opinião, essa opção é muito útil, pois permite ter uma visão geral do código em menos linhas.

O primeiro problema é definir quando deve haver um novo fold. Existem 6 métodos diferentes, e desses vou citar apenas 3: manual, indent e syntax. Na manual, você mesmo tem que definir onde criar os folds, o que é trabalhoso e pouco usado. As outras duas opções são syntax, onde os folds são criados automaticamente de acordo com a sintaxe da linguagem usada, ou o indent, onde os foldings são criados automaticamente na identação. Teste os dois (ou outros que não citei) e use o que preferir.

Vamos então acrescentar mais algumas linhas no arquivo .vimrc para testar essa feature do vim (ou então usar elas como comando de dentro do vim):

set foldmethod=syntax "seleciona o método de folding
set foldcolumn=2 "Mostra uma coluna auxiliar

Para abrir ou fechar um fold, você pode usar os comandos “:zo” e “:zc” , respectivamente. Colocando em maiúsculo as letras “o” e “c” nos comandos anteriores, você abre/fecha um fold recursivamente. o comando “:za” altera o estado da fold atual, isso é, se estiver fechada abre, e se estiver aberta, fecha. Você pode usar esse comando recursivamente colocando a letra “a” em maiúscula. Ainda pode-se usar os comandos “:zR” e “:zM”, para abrir ou fechar todos os folds do arquivo, respectivamente.

O melhor jeito de se aprofundar em foldings é lendo a ajuda online do vim, utilizando o comando “:help folding”.

Function/method Completions: completefunc e omnifunc

Os completions só estão disponíveis no vim como padrão a partir da versão 7. Eles são os responsáveis pelo auto-completar, isso é, completar os métodos que uma determinada classe tem, por exemplo. Para vê-lo em ação, você pode fazer o seguinte teste: Primeiramente abra um arquivo com uma extensão de programação válida, por exemplo:

vi teste.py

Dentro do arquivo, digite o seguinte texto:

a="teste"
a.

Em Python, a primeira linha estancia uma string e a segunda linha está incompleta. O operador “.” é utilizado para acessar os métodos da classe string. Vamos testar o completion com essa string; em modo de inserção de texto, com o cursor logo após o “.”, aperte Ctrl+x, Ctrl+o. Deve aparecer uma janela com os métodos da string. Usando as setas para escolher, irá dividir a janela em 2, mostrando uma descrição do método na janela de cima. Ela não fecha automaticamente após sair.
Não entre em pânico. Apesar do auto-completar parecer extremamente arcaico, você pode deixar ele muito mais usável do que imagina, utilizando maps e alguns comandos mais avançados. Um exemplo, você pode fechar automaticamente a janela com a descrição da função e mapear o auto-complete para Ctrl+C com as seguintes duas linhas no .vimrc:

au CursorMovedI,InsertLeave * if pumvisible() == 0|silent! pclose|endif
inoremap

Ficou bem melhor, certo? Mas na minha opinião não ficou bom o suficiente. Ainda falta muita coisa nesse auto-completar. Infelizmente essa parte vai ficar para o post sobre plugins, pois vamos precisar de ajuda externa! Para aprender mais sobre o auto-completar, sugiro a leitura do manual online do vim (se leu até agora, aposto que você já imaginava isso), com o comando “:help complete-functions”.

Considerações finais

Esse tutorial foi escrito com fortes influências do google, enquanto eu aprendia. Gostaria de citar as fontes, porém faz muito que procurei essas informações, e algumas linhas de configuração, apesar de entender agora o que elas fazem, não fui eu quem escreveu, por exemplo a linha de fechar a janela de descrição do auto-complete automaticamente.

Caso tenha alguma sugestão ou dica, entre em contato!

Hoje pela manhã, durante a aula de Técnicas de construções de programas, pensei em uma “motivation” e não deu outra; coloquei meu lado artístico (que mostra muito bem porque resolvi estudar computação) no GIMP e aí está o resultado.

Existem muitos editores de código por aí. Muitos mesmo. Vim, no entanto, é um editor diferente. Muitas pessoas acham loucura usar vim para programar, assim como eu mesmo, no passado. Quem raios quer fazer as coisas diferentes do jeito que já se está acostumado a fazer? Outra pergunta: Será que vale a pena aprender coisas muito diferentes do que já se está acostumado? Essa segunda pergunta é decorrente da primeira, e talvez (provavelmente) você tenha se contradito ao responde-las mentalmente.

O fato é que vim é muito diferente dos editores de um editor de código padrão. E essa diferença faz com que muito do que tu saibas sobre outros editores de código não possa ser aproveitado. Porém, com o passar do tempo, você vai começar a achar Vim muito mais produtivo. Se você passou pela transição Windows-Linux, você sabe exatamente onde eu quero chegar. Caso não acredite nisso, peço que pense na seguinte pergunta: Porque tanta gente usa o vim para programar?

O primeiro contato com o vim já é traumatizante para muitos: Um editor que nem abre em uma janela, sendo chamado do terminal. Bom, como muita gente sabe, existe uma versão gráfica do vim, o gvim. Ele conta com todas as vantagens do vim, e utilizá-lo com ou sem essa interface gráfica não importa muito no fundo. Assim como também existe uma versão do vim estilo “bloco de notas”, do Windows, o evim (easy vim). Porém, utilizando essa última, você vai estar jogando fora um dos melhores programas que existem para editar código.

Se o primeiro contato já é um tanto quanto inusitado, o segundo é mais ainda: Ao tentar digitar algo, o texto não aparece na tela, e ainda pode ser ouvido alguns barulhos, como se o computador estivesse brigando com você. É exatamente essa característica que faz o vim ser tão poderoso: Você não escreve texto, você dá comandos. Como programador, você sabe que a maior parte do tempo não é dedicado a escrita propriamente do programa, e sim a edição do código já escrito. É exatamente nesse ponto que o vim facilita: Lidar com o que já existe. A produtividade alcançada utilizando o vim se dá por essa característica, juntamente com todas as vantagens que um editor de código padrão dá ao escrever um código novo.

Entre as características padrão do vim voltados a programação, temos principalmente:

coloração do código para facilitar o desenvolvimento em mais de 200 linguagens (e se não for o suficiente, você pode facilmente criar suas próprias) assim como de alguns erros coumuns como falta de parênteses.

folding, que é a capacidade de esconder trechos de código para poder visualizar o programa como um todo mais facilmente, por exemplo, transformar um “if” em apenas uma linha, e expandir esse if quando achar necessário.

tabs, que são utilizadas para ler mais de um arquivo com o mesmo vim aberto, exibindo os arquivos abertos em abas

framebuffers, que são espécies de tabs primitivas, onde basicamente você não consegue ver os arquivos que estão abertos, apenas circular entre eles.

identação automática, que é a capacidade do editor de identar automaticamente a próxima linha

Omnicomplete, que é um auto-completar extremamente versátil onde você pode montar sua lista de funções a serem completadas. Esse talvez seja o mais complexo de se explicar, mas com ajuda do programa ctags e alguns comandos, você terá as funções que quiser na lista para auto-completar, não importando se são do OpenGL, Qt, GTK, ou aquele projeto que ninguém nunca ouviu falar. Além disso, ele completa atributos e métodos de classes padrões ou das que você mesmo implementou, para a maioria das linguagens.

Só isso? Não! Vim pode ser facilmente expandido através de plugins. Como você imagina, existem milhares deles. Alguns muito poderosos, por exemplo, os snippets do textMate são imitados pelo plugin snippetsEMU. Como é tradição dos softwares livres, ele é altamente customizável, desde coisas macro como uma coluna do lado direito com a contagem de linhas e correção gramatical, até como a procura deve se comportar ou combinações de teclas para fazer ações específicas.

Em suma, além de ter características únicas que auxiliam na programação, vim ainda conta com muitas características (se não todas) dos editores de códigos mais utilizados. Como se não bastasse, é altamente customizável e cross-plataform. Só para deixar a vontade no ar: Digitando d, você ativa o comando delete. Se for digitado, por exemplo, dw, o comando utilizado é delete word, deletando a palavra onde o cursor se encontra. Se você quiser deletar as próximas 3 palavras, pode utilizar o comando d3w, delete 3 words. Características do modo de comando como esses comandos acima são muito difíceis de explicar em um texto que não seja diretamente um tutorial, e são exatamente deles que vem o poder do vim.

Se você ficou interessado em aprender a usar o vim e não sabe por onde começar, abra um terminal e digite

vimtutor

Um tutorial de vim irá abrir no próprio vim, e você vai aprender a usá-lo utilizando ele mesmo. É uma idéia bastante interessante, e costuma ter ótimos resultados. Eu aprendi a usá-lo assim.

Fica a promessa: Vou fazer um post no blog sobre os plugins do vim que utilizo.

C é uma linguagem de programação de baixo nível. Por essa natureza, ela te dá muito mais liberdade ao codificar, e não lhe dá tantos recursos padrões como outras linguagens, remetendo muitas vezes a pensamentos na linha “uma linguagem para programadores iniciantes”, “uma linguagem que não permite a construção de um bom projeto” ou ainda “uma linguagem que não possui recursos”. Ela já foi até mesmo considerada uma linguagem de programação amadora no nosso passado, onde no topo das linguagens de programação estava o glorioso FORTRAN. Esses pensamentos são os mais errados que se pode ter sobre C.

Por ser uma linguagem que te dá mais liberdade para codificar, ela não serve para programadores iniciantes; A liberdade que C provém ao programador deve ser usada com o maior cuidado possível. Escrever um código legível em Java é o básico, agora escrever um código legível em C muitas vezes é uma arte. É exatamente essa arte que um programador precisa dominar em C para ter um código de qualidade, e esse talento só se dá programando. E não programando somente em C, mas programando em muitas linguagens. Quanto mais diferentes essas linguagens, melhor. Ninguém quer ler um código escrito em C por um programador amador; ele é horrível e obscuro. Logicamente, quando se tem um projeto para ser escrito nessa linguagem, se procura os melhores programadores disponíveis.

Nessa parte, geralmente surge as brilhantes perguntas “Mas outras linguagens não requerem tanto dos programadores. Por que programar em C?”. A resposta a essa pergunta é um tanto óbvia. Pense na linguagem que você acha que seria melhor de ser usada do que C, e reponda a segunte pergunta: “Em que linguagem foi implementado o interpretador/compilador da linguagem que pensei?”. Obviamente, para várias tarefas, uma linguagem de maior nível de abstração é preferida, mas nem para todas as tarefas podemos nos dar ao luxo de programar em linguagens de alto nível; e é para essas tarefas, menos numerosas na vida real, que mais precisamos nos preocupar com a qualidade do código – e consequentemente, a qualidade do programador.

O mais intrigante na minha opinião é a afirmação que C não permite desenvolver bons projetos, modulados e concisos. Pois, C é uma linguagem de baixo nível. Tudo o que tu pode fazer nas outras, tu também pode fazer em C (ou emular o comportamento delas). O fato é que a produtividade de realizar um projeto em C é realmente muito menor do que realizar em outra linguagem, pois várias vezes tu tem que implementar coisas que já existem de uma forma ou de outra. Porém, com isso tu ganha performance, o que pode ser crucial dependendo da aplicação. Se desenvolver um código legível em C já é uma arte, para fazer um projeto modulado e bonito, então, nem se fala. É exatamente essa arte que faz brilhar os olhos de muito programador bom. Você ainda pode pensar “Programa bem modulado em C não existe”. Pense de novo.

O mais facilmente refutável é exatamente o pensamento “C não tem muitos recursos”. Por ser uma linguagem antiga, considerada padrão para baixos níveis, em projetos que envolvam baixo nível você pode (e vai) encontrar *muita* coisa pronta em C. Algumas com a possibilidade de fechar o código (projetos que usam licença BSD e MIT, por exemplo), e muitas outras licenciadas para open source.

Alguns livros indicados para quem gostaria de aprender/se aprofundar em linguagem C podem ser encontrados aqui. Tirei esse link do canal de irc #C, no servidor freenode, que por sinal, é muito bom :)

Hoje acabei ajudando duas pessoas a configurar sua internet via linha de comando no IRC, então resolvi fazer um tutorial ensinando como fazer isso de maneira simples e genérica, para qualquer distribuição.

Esse tutorial estamos assumindo que você tem um modem router, utilizando DHCP para atribuir os IPs. Você vai precisar rodar todos os comandos como root.

Verificando se sua interface de rede foi reconhecida

A primeira coisa que você deve fazer é ver se alguma interface de rede foi detectada durante o processo de boot. É muito provável que elas estejam ali, até hoje nunca vi nenhuma placa de rede que não fosse detectada e que não estivesse estragada (exceto wireless). Para fazer isso, você deve rodar o comando

ifconfig -a

Cada interface vai gerar um bloco de texto, como por exemplo esse:

Na esquerda podemos ver os nomes das interfaces, e na direita algumas informações sobre elas. A interface lo é uma interface especial, chamada de loopback, e deve ser ignorada nesse processo. Provavelmente terá alguma outra interface de rede, que deve ser identificada como eth0 para rede com fio, ou ath0/wlan0 para wireless. Você vai querer que ela esteja ativa para poder configurá-la, então utilize o comando a seguir, substituindo o eth0 pela interface que você quer configurar.

ifconfig eth0 up

Tendo certificado que a sua interface de rede foi conhecida e está ativa, o próximo passo é configurá-la.

Rede com fios e IP Dinâmico (DHCP)

Caso você esteja usando DHCP, utilize os comandos abaixo, substituindo eth0 pela sua interface de rede

dhcpcd eth0

a internet deve estar funcionando agora.

Rede com fios e IP estático

Para utilizar IP fixo, você vai precisar de um IP, de uma máscara de subrede e de ao menos um IP de um resolvedor de nomes. Nesse caso, rode os seguintes comandos:

ifconfig eth0 address 192.168.1.10 netmask 255.255.255.0
echo -e “nameserver 200.175.5.139 \nnameserver 200.175.182.139″ > /etc/resolv.conf

Note que nesse exemplo, estamos tentando configurar a interface eth0 utilizando o ip 192.168.1.10, com máscara de subrede 255.255.255.0 e dois servidores de nome, com ips 200.175.5.139 e 200.175.182.139. Você deve substituir esses campos com suas configurações. Se você não sabe quais são suas configurações, você não deveria estar usando esse método :)

Rede Wireless

Para se conectar em uma rede wireless, você precisa primeiramente procurar as redes que estão disponíveis para você entrar. Você pode conferir isso com o comando

iwlist wlan0 scan | more

Saída do comando iwlist

A saída desse comando será composta de vários blocos de informação sobre as redes disponíveis. Um exemplo de bloco pode ser visualizado abaixo:

Nesse exemplo, podemos ver uma rede wireless. São muitas informações sobre a rede, mas básicamente precisamos do nome dela, que é o campo ESSID (no exemplo, “Middle Earth”) e o tipo de encriptação (no exemplo, WPA2).

Depois de escolher a rede, devemos informar a placa de rede wireless qual rede ela deve tentar se conectar. Fazemos isso através do comando a seguir. Note que estou usando o exemplo anterior; você deve substituir middle earth pelo nome da rede que você escolheu.

iwconfig wlan0 essid “Middle Earth”

Após esse passo, devemos fazer um dos a seguir, de acordo com a encriptação da rede.

Rede wireless sem encriptação

Essa é a mais fácil. Caso a rede não tenha encriptação, basta pegar um IP exatamente como fazíamos com a placa de rede com fios. O comando abaixo deve deixar tudo arrumado. Lembre-se de substituir wlan0 pela sua interface de rede.

dhcpcd wlan0

Rede wireless com encriptação WEP

Para se conectar na rede WEP, devemos fornecer uma senha. Podemos fornecer essa senha de dois modos: Utilizando o valor hexa-decimal dela, ou então uma string (isso é, uma “frase”). Para fornecer a senha em hexa-decimais, utiliza-se o seguinte comando:

iwconfig wlan0 key 0123-4567-89

Para utilizarmos uma string, utiliza-se o comando

iwconfig wlan0 key s:minhasenhasecreta

Independentemente do método utilizado para colocar a senha, deve-se fechar a conexão. Para isso, use o comando

dhcpcd wlan0

Rede wireless utilizando WPA/WPA2

Existem algumas variações em como se conectar nesse tipo de rede; vou ensinar o método mais coumum. A primeira parte consiste em informar a senha da rede e algumas configurações, através do comando

wpa_passphrase “Middle Earth” minhasenhasecreta > /etc/wpa.conf

Logo em seguida, utilize o comando

wpa_supplicant -Dwext -B -i wlan0 -c /etc/wpa.conf

Após isso, você terá que fechar a conexão com o comando

dhcpcd wlan0

Note que todas esses comandos devem ser executados como super usuário. Para tornar-se superusuário, basta digitar “su” seguido da senha de super usuário, ou então, caso seu usuário seja um sudoer, “sudo -i” e sua própria senha.
Essa parte do tutorial ficou um pouco vaga pois esse tipo de conexão é mais complexa. Se não funcionar exatamente desse jeito, recomendo a leitura das páginas do manual dos dois comandos wpa, utilizando o comando man, e tentar entender o que significa cada parâmetro, e o que pode estar dando errado com a sua rede.

Para simplificar a utilização da rede wireless, recomendo o programa wicd, que além de ter uma versão gráfica, também utiliza uma versão em linha de comando com menus, baseada em ncurses. para utilizar ele em modo texto, use o comando wicd-curses.