Hardware, Redes e Linux para iniciantes

. Introdução
- Como um PC funciona
:. Os componentes básicos
- Processador
- Memória
- Disco rígido
- Placa de vídeo
- Placa-mãe
:. Hardware x Software
- Arquiteturas
:. Um pouco sobre a história do Linux
:. Um pouco sobre redes
- O TCP/IP e a configuração da rede
:. Redes wireless
:. Acesso Remoto
:. O Kernel e as distribuições Linux
- Os live-CDs
- Como baixar, gravar e dar boot
:. Linguagens de programação
Como um PC funciona

Vamos começar com algumas noções básicas sobre como um PC atual funciona, para que você
possa começar a entender melhor a coisa do ponto de vista do sistema operacional.
Existem duas maneiras de representar uma informação: analogicamente ou digitalmente. Uma
música é gravada numa fita K7 de forma analógica, codificada na forma de uma grande onda
de sinais magnéticos, que pode assumir um número ilimitado de freqüências. Um som grave
seria representado por um ponto mais baixo da onda, enquanto um ponto mais alto
representaria um som agudo.
O sistema digital, por sua vez, permite armazenar qualquer informação na forma de uma
seqüência de valores positivos e negativos, ou seja, na forma de uns e zeros. O número 181,
por exemplo, pode ser representado digitalmente como 10110101. Qualquer tipo de
informação, seja um texto, uma imagem, um vídeo, um programa, ou qualquer outra coisa,
será processado e armazenado pelo computador na forma de uma grande seqüência de uns e
zeros.
Os computadores são o exemplo claro do cúmulo da burrice, afinal eles só conhecem dois
valores e precisam adaptar tudo a esta concepção limitada que possuem. Eles também não são
capazes de tomar decisões por mais simples que sejam, pois um e zero não dão margem para
interpretação. Um é um, zero é zero e ponto final.
Sempre existe um ser humano orientando o computador e dizendo a ele o que fazer a cada
passo. Seja você mesmo, teclando e usando o mouse, ou, num nível mais baixo, o
programador que escreveu os programas que você está usando.
Quando o computador trava significa justamente que chegou a uma situação onde ele não
sabe o que fazer. O programador estava com sono e esqueceu de fechar alguma função ou de
verificar alguma variável. Como disse, o computador não sabe lidar com situações
inesperadas: quando não sabe o que fazer, simplesmente empaca.
Sempre que alguém lhe disser que "não entende nada de computadores", explique que é
impossível ser mais burro que eles. Lembre-se de que você é o ser pensante que está no
comando.
Mas, por outro lado, é justamente o uso do sistema binário que torna os computadores
confiáveis, pois a possibilidade de um valor 1 ser alterado para um valor 0, o oposto, é muito
pequena. Lidando com apenas dois valores diferentes, a velocidade de processamento também
torna-se maior, devido à simplicidade dos cálculos.
Imagine que os computadores são os funcionários perfeitos: eles não se importam de ficar
fazendo tarefas repetitivas por longos períodos, não reclamam de ficar trabalhando durante a
madrugada baixando um arquivo ou compactando um vídeo, não tiram férias e ainda por cima
não recebem salário! Tudo bem, eles travam de vez em quando, mas por outro lado fazem
tudo o que você manda no resto do tempo :-P.
Cada um ou zero que é processado ou armazenado é chamado de "bit", contração de "binary
digit" ou "dígito binário". Um conjunto de 8 bits forma um byte, e um conjunto de 1024 bytes
forma um Kilobyte (ou Kbyte).
O número 1024 foi escolhido por ser a potência de 2 mais próxima de 1000. É mais fácil para
os computadores trabalharem com múltiplos de dois do que usar o sistema decimal como nós.
Seja compreensivo com as limitações de nossos pobres serviçais: lembre-se de que você é
mais inteligente do que eles, então como todo ser superior é seu dever fazer algumas
concessões de vez em quando ;).
Um conjunto de 1024 Kbytes forma um Megabyte e um conjunto de 1024 Megabytes forma
um Gigabyte. Os próximos múltiplos são o Terabyte (1024 Gibabytes) e o Petabyte (1024
Terabytes), Exabyte, Zetabyte e o Yotabyte, que equivale a
1,208,925,819,614,629,174,706,176 bytes :).
Não se sabe se algum dia todos estes múltiplos chegarão a realmente ser usados. Para
armazenar um Yottabyte inteiro, usando tecnologia atual, seria necessário construir uma
estrutura colossal de servidores.
Imagine que, para manter os custos baixos, fosse adotada uma estratégia estilo Google,
usando PCs comuns, com HDs IDE. Cada PC seria equipado com 4 HDs de 250 GB, o que
resultaria em aproximadamente 1 Terabyte por PC. Estes PCs são então organizados em
enormes racks, onde cada rack tem espaço para 1024 PCs. Os PCs de cada rack são ligados a
um conjunto de switchs e cada grupo de switchs é ligado a um grande roteador. Uma vez
ligados em rede, os 1024 PCs são configurados para atuar como um enorme cluster,
trabalhando como se fossem um único sistema.
Construímos então um enorme galpão, capaz de comportar 1024 destes racks, construindo
uma malha de switchs e roteadores capaz de ligá-los em rede com um desempenho
minimamente aceitável. Este galpão precisa de um sistema de refrigeração colossal, sem falar
da energia consumida pelo mais de um milhão de PCs dentro dele, por isso construímos uma
usina hidrelétrica para alimentá-lo, represando um rio próximo.
Com tudo isso, conseguimos montar uma estrutura computacional capaz de armazenar 1
Exabyte. Ainda precisaríamos construir mais 1.048.575 mega-datacenters como este para
chegar a 1 Yottabyte. Se toda a humanidade se dividisse em grupos de 6.000 pessoas cada um
e cada grupo fosse capaz de construir um ao longo de sua vida, deixando de lado outras
necessidades existenciais, poderíamos chegar lá :-P.
Voltando à realidade, usamos também os termos Kbit, Megabit e Gigabit, para representar
conjuntos de 1024 bits. Como um byte corresponde a 8 bits, um Megabyte corresponde a 8
Megabits e assim por diante. Quando você compra uma placa de rede de "100 megabits" está
na verdade levando para a casa uma placa que transmite 12.5 megabytes por segundo, pois
cada byte tem 8 bits.
Quando vamos abreviar, também existe diferença. Quando estamos falando de Kbytes ou
Megabytes, abreviamos respectivamente como KB e MB, sempre com o B maiúsculo.
Por outro lado, quando estamos falando de Kbits ou Megabits abreviamos da mesma forma,
porém usando o B minúsculo: Kb, Mb e assim por diante. Parece só um daqueles detalhes sem
importância, mas esta é uma fonte de muitas confusões. Se alguém anuncia no jornal que está
vendendo uma "placa de rede de 1000 MB", está dando a entender que a placa trabalha a
8000 megabits e não a 1000.
Você tem uma boa chance de ficar rico (e ter que fugir pouco tempo depois ;), anunciando
pendrives de 4 Gb (Gigabits), pentes de memória de 8 Gb e HDs de 2000 Tb (Terabits), por
preços pouca coisa maiores que os de 512 MB, 1 GB e 250 GB dos concorrentes :-p.

Os componentes básicos

Qualquer PC é composto pelos mesmos componentes básicos: processador, memória, HD,

placa- mãe e placa de vídeo. A partir daí você pode adicionar placas de rede, modems, placas
de som e outros periféricos. Com o micro montado, o próximo passo é instalar o sistema
operacional e programas, que finalmente vão permitir que ele faça algo de útil. Vamos começar
com um overview da função de cada um destes componentes:

Processador

O processador é o cérebro do sistema, encarregado de processar todas as informações. Ele

também é o componente onde são usadas as tecnologias mais recentes. Existem no mundo
apenas quatro grandes empresas com tecnologia para fabricar processadores competitivos
para micros PC: a Intel (que domina mais de 70% do mercado), a AMD, Via (que comprou a
antiga Cyrix e atualmente fabrica os chips Via C3 e C7) e a IBM, que fabrica processadores
para outras empresas, como a Transmeta.
O processador é o componente mais complexo e freqüentemente o mais caro, mas ele não
pode fazer nada sozinho. Como todo cérebro, ele precisa de um corpo, que é formado pelos
outros componentes do micro, incluindo memória, HD, placa de vídeo e de rede, monitor,
teclado e mouse.
Dentro do mundo PC, tudo começou com o 8088, lançado pela Intel em 1979 e usado no
primeiro PC, lançado pela IBM em 1981. Depois veio o 286, lançado em 1982, e o 386,
lançado em 1985.
O 386 pode ser considerado o primeiro processador moderno, pois foi o primeiro a incluir o
conjunto de instruções básico, usado até os dias de hoje. O 486, que ainda faz parte das
lembranças de muita gente que comprou seu primeiro computador foi lançado em 1989, mas
ainda era comum encontrar micros com ele à venda até por volta de 1997.
Depois entramos na era atual, inaugurada pelo Pentium, que foi lançado em 1993, mas
demorou alguns anos para se popularizar e substituir os 486. Em 1997 foi lançado o Pentium
MMX, que deu um último fôlego à plataforma. Depois, em 1997, veio o Pentium II, que usava
um encaixe diferente e por isso era incompatível com as placas-mãe antigas. A AMD soube
aproveitar a oportunidade, desenvolvendo o K6-2, um chip com uma arquitetura similar ao
Pentium II, mas que era compatível com as placas antigas.
A partir daí as coisas passaram a acontecer mais rápido. Em 1999 foi lançado o Pentium III e
em 2000 o Pentium 4, que trouxe uma arquitetura bem diferente dos chips anteriores,
otimizada para permitir o lançamento de processadores que trabalham a freqüências mais
altas.
O último Pentium III trabalhava a 1.0 GHz, enquanto o Pentium 4 atingiu rapidamente os 2.0
GHz, depois 3 GHz e depois 4.0 GHz. O problema é que o Pentium 4 possui um desempenho
por ciclo de clock inferior a outros processadores, o que faz com que a alta freqüência de
operação sirva simplesmente para equilibrar as coisas. A primeira versão do Pentium 4 operava
a 1.3 GHz e, mesmo assim, perdia para o Pentium III de 1.0 GHz em algumas aplicações.
Quanto mais alta a freqüência do processador, mais ele esquenta e mais energia consome, o
que acaba se tornando um grande problema. Em 2003 a Intel lançou o Pentium M, um chip
derivado da antiga arquitetura do Pentium III, que consome pouca energia, esquenta pouco e
mesmo assim oferece um excelente desempenho. Um Pentium M de 1.4 GHz chega a superar
um Pentium 4 de 2.6 GHz em diversas aplicações.
O Pentium M foi desenvolvido originalmente para ser usado em notebooks, mas se mostrou tão
eficiente que a arquitetura está sendo adotado como base para o desenvolvimento dos futuros
chips Intel, que combinarão dois ou quatro processadores no mesmo chip.

Paralelamente a todos estes processadores, temos o Celeron, uma versão mais barata, mas
com um desempenho um pouco inferior, por ter menos cache. Na verdade, o Celeron não é
uma família separada de chips, mas apenas um nome comercial usado nas versões mais
baratas (com metade ou um quarto do cache) de vários processadores Intel. Existem Celerons
baseados no Pentium II, no Pentium III, no Pentium 4 e agora no Pentium M.
Para efeito de comparação, entre os chips antigos e os atuais, um 486 tinha cerca de 1 milhão
de transistores e chegou a 133 MHz, enquanto o Pentium MMX tinha 4.3 milhões e chegou a
233 MHz. Um Pentium 4 (Prescott) tem 125 milhões e chega a 4.0 GHz. O transistor é a
unidade básica do processador, capaz de processar um bit de cada vez. Mais transistores
permitem que o processador processe mais instruções de cada vez enquanto a freqüência de
operação determina quantos ciclos de processamento são executados por segundo.
A AMD, por sua vez, começou produzindo processadores 386 e 486, muito similares aos da
Intel, porém mais baratos. Quando a Intel lançou o Pentium, que exigia o uso de novas placas-
mãe, a AMD lançou o "5x86", um 486 de 133 MHz, que foi bastante popular, servindo como
uma opção barata de upgrade. Embora o "5x86" e o clock de 133 MHz dessem a entender que
se tratava de um processador com um desempenho similar a um Pentium 133, o desempenho
era muito inferior, mal concorrendo com um Pentium 66. Este foi o primeiro de uma série de
exemplos, tanto do lado da AMD, quanto do lado da Intel, em que existiu uma diferença
gritante entre o desempenho de dois processadores do mesmo clock. Embora seja um item
importante, a freqüência de operação não é um indicador direto do desempenho do
processador.
Uma analogia poderia ser feita em relação aos motores de carro. Os motores de 1.6 do final da
década de 70, usados nas Brasílias e Fuscas, tinham 44 cavalos de potência, enquanto os
motores 1.0 atuais chegam a mais de 70 cavalos. Além da capacidade cúbica, existem muitos
outros fatores, como a eficiência do sistema de injeção de ar e combustível, taxa de
compressão, refrigeração, etc.
Depois do 5x68 a AMD lançou o K5, um processador similar ao Pentium, mas que não fez tanto
sucesso. Ele foi seguido pelo K6 e mais tarde pelo K6-2, que novamente fez bastante sucesso,
como uma opção barata, e ao mesmo tempo como uma opção de upgrade para quem tinha um
Pentium ou Pentium MMX.
Esta era do K6-2 foi uma época negra da informática, não pelo processador em si (que
excluindo o desempenho em jogos, tinha um bom custo-benefício), mas pelas placas-mãe
baratas que inundaram o mercado. Aproveitando o baixo custo do processador, os fabricantes
passaram a desenvolver placas cada vez mais baratas (e de qualidade cada vez pior) para
vender mais oferecendo PCs de baixo custo. A época foi marcada por aberrações. Um certo
fabricante chegou a lançar uma família de placas sem cache L2, que pifavam em média depois
de um ano de uso.
As coisas voltaram aos trilhos com o Athlon, que foi o primeiro grande processador (tanto em
desempenho, quanto em tamanho :) da AMD. A primeira versão usava um formato de cartucho
(slot), similar ao Pentium II, mas incompatível com as placas para ele. Ele foi sucedido pelo
Athlon Thunderbird, que passou a usar o formato de soquete utilizado até os dias de hoje pelo
Sempron.

Competindo com o Celeron, a AMD produziu o Duron, um processador de baixo custo, idêntico
ao Athlon, mas com menos cache. Em 2005 o Athlon foi descontinuado e o cargo herdado pelo
Sempron, uma versão aperfeiçoada do Duron (com mais cache e capaz de atingir freqüências
mais altas), que passou a ser vendido segundo um índice de desempenho (em relação ao
Pentium 4) e não mais segundo o clock real.
Por volta de 2000, surgiram as primeiras notícias do "SledgeHammer", um processador de 64
bits, que foi finalmente lançado em versão doméstica na forma do Athlon 64, que passou a ser
o topo de linha da AMD. Apesar das mudanças internas, o Athlon 64 continua sendo compatível
com os programas de 32 bits, da mesma forma que os processadores atuais são capazes de
rodar softwares da época do 386, muito embora tenham incorporado diversos novos recursos.
Na prática, o fato de ser um processador de 64 bits não torna o Athlon 64 gritantemente mais
rápido, mesmo em aplicativos otimizados (os ganhos de desempenho surgem mais devido ao
controlador de memória integrado e aos novos registradores). A principal vantagem dos
processadores de 64 bits é derrubar uma limitação inerente a todos os processadores de 32
bits, que são capazes de cessar apenas 4 GB de memória RAM, um limite que está se tornando
cada vez mais uma limitação grave em várias áreas.
Os 4 GB de memória podem não parecer um obstáculo imediato, mas lembre-se de que há
duas décadas os PCs eram vendidos com 128 KB de memória, há uma década já vinham com
4 ou 8 MB, e hoje são vendidos com 512 MB ou mais.

Memória

Depois do processador, temos a memória RAM, usada por ele para armazenar os arquivos e
programas que estão sendo executados. Funciona como uma espécie de mesa de trabalho. A
quantidade de memória RAM disponível tem um grande efeito sobre o desempenho.
Os chips de memória são vendidos na forma de pentes de memória. Existem pentes de várias
capacidades e normalmente as placas possuem dois ou três encaixes disponíveis. Você pode
instalar um pente de 512 MB junto com o de 256 MB que veio no micro para ter um total de
768 MB, por exemplo.

Ao contrário do processador, que é extremamente complexo, os chips de memória são

formados pela repetição de uma estrutura bem simples, formada por um par de um transistor
e um capacitor. Um transistor solitário e capaz de processar um único bit de cada vez, e o
capacitor permite armazenar a informação por um certo tempo. Esta simplificada faz com que
os pentes de memória sejam muito mais baratos que os processadores, principalmente se
levarmos em conta o número de transistores.
Um pente de 1 GB é geralmente composto com 16 chips, cada um deles com um total de 512
megabits, o que equivale a 512 milhões de transistores. Um Athlon 64 X2, que é um dos
maiores processadores atualmente, tem "apenas" 233 milhões e custa absurdamente mais
caro que um pente de memória.
Existem basicamente dois tipos de memória em uso: SDR e DDR. As SDR são o tipo
tradicional, onde o controlador de memória faz apenas uma leitura por ciclo, enquanto as DDR
são mais rápidas, pois fazem duas leituras por ciclo. O desempenho não chega a dobrar, pois o
acesso inicial continua demorando o mesmo tempo, mas melhora bastante.
Os pentes de memória SDR são usados em micros antigos: Pentium II e Pentium III e os
primeiros Athlons e Durons. Por não serem mais fabricados, eles são atualmente muito mais
raros e caros que os DDR, algo semelhante ao que aconteceu com os antigos pentes de 72
vias, usados na época do Pentium.
É fácil diferenciar os pentes SDR e DDR, pois os SDR possuem dois chanfros e os DDR apenas
um. Essa diferença faz com que também não seja possível trocar as bolas, encaixando por
engano um pente DDR numa placa-mãe que use SDR e vice-versa (a menos que você use um
alicate e um martelo, mas a placa provavelmente não vai funcionar mais depois ;).
Algumas poucas placas possuem os dois tipos de soquete, permitindo usar os dois tipos de
acordo com a conveniência, mas sem misturar os dois.
Apesar de toda a evolução, a memória RAM continua sendo gritantemente mais lenta que o
processador. Para atenuar a diferença, são usados dois níveis de cache, incluídos no próprio
processador: o L1 e o L2.
O cache L1 é extremamente rápido, trabalhando próximo à freqüência nativa do processador.
Na verdade, os dois trabalham na mesma freqüência, mas são necessários alguns ciclos de
clock para que a informação armazenada no L1 chegue até as unidades de processamento. No
caso do Pentium 4, chega-se ao extremo de armazenar instruções já decodificadas no L1. Elas
ocupam mais espaço, mas eliminam este tempo inicial. A grosso modo, quanto mais rápido o
cache, mais espaço ele ocupa e menos é possível incluir no processador. É por isso que o
Pentium 4 inclui apenas um total de 20 KB deste cache L1 ultra-rápido, contra os 128 KB do
cache um pouco mais lento usado no Sempron.
Em seguida vem o cache L2, que é mais lento tanto em termos de tempo de acesso (o tempo
necessário para iniciar a transferência) quanto em largura de banda, mas é bem mais
econômico em termos de transistores, permitindo que seja usado em maior quantidade. Um
Pentium 4 possui (de acordo com o modelo) 512 KB, 1 MB ou 2 MB de cache L2, enquanto o
Sempron tem 256 KB.
A principal característica da memória RAM é que ela é volátil, ou seja, os dados se perdem ao
reiniciar o micro. É por isso que ao ligar é necessário sempre refazer todo o processo de
carregamento, em que o sistema operacional e aplicativos usados são transferidos do HD para
a memória, onde podem ser executados pelo processador.

Disco rígido

No final das contas, a memória RAM funciona como uma mesa de trabalho. Os dados mesmo
são armazenados no disco rígido, também chamado de hard disk (o termo em Inglês), HD ou
até mesmo de "disco duro" pelos nossos primos lusitanos. É nele que ficam guardados
programas e dados enquanto não estão em uso, ou quando o micro é desligado.
O HD armazena os dados em discos magnéticos que mantêm a gravação por vários anos.
Estes discos giram e uma cabeça de leitura móvel faz o trabalho de gravar ou acessar os dados
em qualquer posição nos discos. Junto com o CD-ROM, o HD é um dos poucos componentes
mecânicos ainda usados nos micros atuais e, justamente por isso, é o que normalmente dura
menos tempo (em média dois anos de uso contínuo) e que inspira mais cuidados.

Na verdade, os discos magnéticos dos HDs são selados, pois a superfície magnética onde são
armazenados os dados é extremamente fina e sensível. Qualquer grão de poeira que entrasse
iria começar a riscar os discos por causa da velocidade em que eles giram (7200 ou 10000
RPM nos atuais) o que faria com que em poucas horas quase todos os dados armazenados
fossem destruídos. Fotos em que o HD aparece aberto são apenas ilustrativas, no mundo real
ele é apenas uma caixa fechada sem tanta graça.
Tradicionalmente, o sistema operacional era sempre instalado no HD antes de poder ser usado.
Enquanto está trabalhando, o sistema precisa freqüentemente modificar arquivos e
configurações, o que seria impossível num CD-ROM, já que os dados gravados nele não podem
ser alterados.
Isso mudou com o aparecimento do Demolinux, Knoppix, Kurumin e outras distribuições Linux
que rodam diretamente do CD-ROM. Neste caso, um conjunto de modificações "enganam" o
sistema, fazendo com que ele use a maior parte dos arquivos (os que não precisam ser
alterados) a partir do CD-ROM, e o restante (os que realmente precisam ser alterados) a partir
da memória RAM.
Isto tem algumas limitações: as configurações são perdidas ao desligar (a menos que você as
salve em um disquete ou cartão de memória), pois tudo é armazenado na memória RAM e o
conteúdo dela é sempre perdido ao desligar o micro.
Também é mais complicado (mas não impossível!) instalar novos programas pois é sempre
preciso enganar o sistema fazendo-o gravar tudo na memória RAM. Por outro lado, a facilidade
de uso é imbatível, pois basta inicializar o micro usando o CD do Kurumin e ele roda alegre e
saltitante, sem precisar alterar o que já está instalado no micro.
Mas, voltand o à função do HD, imagine que, como memória RAM é cara, você compra sempre
uma quantidade relativamente pequena, geralmente 512 MB ou 1 GB, de acordo com o seu
bolso. Por outro lado, você dificilmente vai encontrar um HD de menos que 80 ou 120 GB à
venda. Ou seja, temos centenas de vezes mais espaço no HD do que na memória RAM.
Lembre-se de que o computador é burro, quando ele fica sem memória RAM, simplesmente
trava. Não existe negociação com quem só entende uns e zeros.
Bem antigamente, nos anos 80, época dos primeiros PCs, você só podia rodar programas que
coubessem na memória RAM disponível. Naquela época, a memória RAM era muito mais cara
que hoje em dia, então o mais comum era usar 256 ou 512 KB (sim, kbytes, duas mil vezes
menos que usamos hoje, tempos difíceis aqueles, nem existia Linux... :). Os mais abonados
tinham dinheiro para comprar um megabyte inteiro mas parava por aí.
Se você quisesse rodar um programa com mais de 256 KB, tinha que comprar mais memória,
não tinha conversa. Os programadores, coitados, tinham que deixar seus programas o mais
compactos possíveis para que eles rodassem nos micros com menos memória.
Mais tarde, quando a Intel estava desenvolvendo o 386, um dos engenheiros bem pagos da
empresa, num momento de criatividade despertada por iluminação divina, teve a idéia de criar
um recurso chamado de memória virtual.
O processador (através de uma instrução incluída no microcode e ativada pelo sistema
operacional) é instruído a mover alguns arquivos para o HD sempre que a memória RAM
estiver acabando. Isso faz com que a memória nunca "acabe" e ele não trave. Enquanto tiver
espaço no HD, ele vai caminhando.
O Linux sabe como usar memória virtual desde o comecinho, quando um russo pediu
encarecidamente que Linus Torvalds incluísse o recurso para que ele pudesse rodar o Linux no
seu 386 com 2 MB de RAM (não tente fazer isso em casa! :-).
O problema é que o HD é muito mais lento que a memória RAM. Se você for numa loja de
informática qualquer e perguntar sobre os tipos de pente de memória que estão à venda, vai
encontrar pentes de memória DDR de 2100, 2700 ou até 3200 MB/s (a memória conversa com
o processador a até 3200 megabytes por segundo). Na pior das hipóteses, você vai encontrar
um pente antigo de memória PC-100, que transmite a 800 MB/s.
Existe um comando no Linux que serve para mostrar de forma rápida o desempenho do HD, o
hdparm. Quando o rodo no meu micro, que usa um HD IDE relativamente recente, ele diz o
seguinte:
$ hdparm -t /dev/hda
/dev/hda:
Timing buffered disk reads: 158 MB in 3.03 seconds = 52.20 MB/sec
Ou seja, enquanto na memória RAM falamos de 2 ou 3 gigabytes por segundo, no HD falamos
em algumas dezenas de megabytes. Para piorar as coisas, o tempo de acesso do HD (o tempo
necessário para localizar a informação e iniciar a transferência) é absurdamente mais alto, em
torno de 10 milessegundos, enquanto na memória RAM falamos em nanossegundos.
Agora você entende por que o Kurumin roda tão lento naqueles micros velhos com apenas 64
MB. O sistema até consegue trabalhar, com a ajuda da memória virtual, mas como uma grande
parte das coisas acaba indo para o HD, tudo fica leeeeento, independentemente do clock do
processador.
A fórmula é simples: quanto menos memória RAM, mais memória swap (memória virtual) é
usada e mais lento o sistema fica. O processador, coitado, não pode fazer nada além de ficar
esperando a boa vontade do HD em mandar à conta-gotas os dados de que ele precisa para
trabalhar. Ou seja, quando você compra um micro com um processador de 3 GHz e 256 MB de
RAM, você está literalmente jogando dinheiro no lixo, pois o seu processador super ultra rápido
vai ficar boa parte do tempo esperando pelo HD.
Vender micros novos com 256, ou pior, apenas 128 MB de RAM, é uma atrocidade que deveria
ser classificada como crime contra a humanidade ;).
Por outro lado, quando você tem instalado mais memória do que o sistema realmente precisa,
é feito o inverso. Ao invés de copiar arquivos da memória para o HD, arquivos do HD, contendo
os programas, arquivos e bibliotecas que já foram anteriormente abertos é que são copiados
para a memória, fazendo com que o acesso a eles passe a ser instantâneo. Os programas e
arquivos passam a ser abertos de forma gritantemente mais rápida, como se você tivesse um
HD muito mais rápido do que realmente é.
Este recurso é chamado de cache de disco e no Linux é gerenciado de forma automática pelo
sistema, usando a memória disponível. Naturalmente, o cache disco é descartado
imediatamente quando a memória precisa ser usada para outras coisas. Ele é apenas uma
forma de aproveitar o excedente de memória, sem causar nenhum efeito desagradável.
Ironicamente, a forma mais eficiente de melhorar o desempenho do HD, é instalar mais
memória, fazendo com que uma quantidade maior de arquivos possa ser armazenada no cache
de disco. É por isso que servidores de arquivos, proxy e de banco de dados costumam usar
muita memória RAM, em muitos casos 4 GB ou mais.
Uma outra forma de melhorar o desempenho do HD é usar RAID, onde dois ou quatro HDs
passam a ser acessados como se fossem um só, multiplicando a velocidade de leitura e
gravação. Este tipo de RAID, usado para melhorar o desempenho é chamado de RAID 0. Existe
ainda o RAID 1, onde são usados dois HDs, mas o segundo é uma cópia exata do primeiro, que
garante que os dados não sejam perdidos no caso de algum problema mecânico em qualquer
um dos dois.
O RAID tem se tornado um recurso relativamente popular, pois muitas placas-mãe já vêm com
controladoras RAID onboard.

Placa de vídeo

Depois do processador, memória e HD, a placa de vídeo é provavelmente o componente mais

importante do PC. Originalmente, as placas de vídeo eram dispositivos simples, que se
limitavam a mostrar o conteúdo da memória de vídeo no monitor. A memória de vídeo contém
um bitmap da imagem atual, atualizada pelo processador, e o RAMDAC (um conversor digital-
analógico) lê esta imagem periodicamente e a envia ao monitor.
A resolução máxima suportada pela placa de vídeo era limitada pela quantidade de memória
de vídeo. Na época, memória era um artigo caro, de forma que as placas vinham com apenas
1 ou 2 MB. As placas de 1 MB permitiam usar no máximo 800x600 com 16 bits de cor, ou
1024x768 com 256 cores. Estavam limitadas ao que cabia na memória de vídeo.
Em seguida, as placas passaram a suportar recursos de aceleração, que permitem fazer coisas
como mover janelas ou processar arquivos de vídeo de forma a aliviar o processador principal.
Estes recursos melhoram bastante a velocidade de atualização da tela (em 2D), tornando o
sistema bem mais responsívo.
Finalmente, as placas deram o passo final, passando a suportar recursos 3D. Uma placa 3D é
capaz de gerar, processar e renderizar imagens em 3D, que por sua vez são formadas por uma
quantidade gigantesca de polígonos, posicionados no espaço tridimensional e texturas
aplicadas sobre eles, que os transformam em objetos mais semelhantes aos reais.

Junto com as placas 3D, surgiu a febre dos games de primeira pessoa, começando com o
Quake 2 e Quake 3 e depois chegando ao Counter Strike, Doom 3 e companhia. Muitos destes
games (incluindo todos os títulos da ID e a série Unreal Tournament) possuem versões Linux
nativas. Em geral você baixa um instalador na página do desenvolvedor, que instala a partir do
CD com a versão Windows.
Outros podem ser executados no Linux usando o Cedega (chamado de WineX nas versões
anteriores), que simula um ambiente Windows, incluindo o DirectX e outros recursos usados
pelos games. Já existem até casos de LanHouses onde todas ou quase todas as máquinas (os
desktops mesmo, não apenas os servidores) rodam Linux. Você pode ver mais detalhes sobre
o projeto aqui: http://www.guiadohardware.net/artigos/309/.
Para usar todos os recursos da placa de vídeo, do 3D à aceleração de vídeo básica, é
necessário que existam drivers adequados para ela. A maioria das placas possuem bons
drivers para Linux, a maior parte deles incluída no próprio X.org, de forma que venham pré-
instalados no sistema. A lista inclui desde as antigas placas Voodoo (1, 2, 3, 4 e Banshee) até
muitas placas ATI e Via recentes, passando por quase todas as placas onboard da Intel,
encontradas sobretudo em notebooks.
A nVidia desenvolve um driver proprietário de boa qualidade, que é compatível com toda a
linha de placas e pode ser instalado em (praticamente) qualquer distribuição Linux sem muitas
dificuldades. Algumas já até incluem o driver diretamente.
O desempenho é bem similar ao obtido no Windows, variando um pouco para mais ou para
menos de acordo com o game. Alguns chegam a ficar bem mais rápidos no Linux, enquanto
outros (sobretudo os executados através do Cedega) rodam com perdas significativas por
causa da camada de emulação. O driver Linux da nVidia pode ser baixado no:
http://www.nvidia.com/object/unix.html.
A ATI também desenvolve um driver próprio, mas que não possui uma qualidade tão boa. O
desempenho é inferior ao do driver for Windows e o driver não instala em todas as
distribuições. Como o custo das placas não é tão diferente assim, dê preferência às placas da
nVidia ao comprar uma placa 3D para uso no Linux. Lembre-se de que o driver influencia
diretamente o desempenho da placa: uma placa rápida no Windows pode ser muito lenta no
Linux se o driver não tiver qualidade.
Entre as placas onboard, as com melhor suporte são as com chipset Intel, tanto as
encontradas em notebooks, quanto as usadas em placas para desktop. Praticamente todas são
suportadas no Linux e o driver oferece um bom desempenho (dentro das limitações do
hardware, claro). Alguns dos chipsets recentes passaram a ser suportados apenas no Kernel
2.6.12, por isso dê preferência às últimas versões das distribuições.
Temos também as placas com o Via Unicrome, um chipset de vídeo incluído na maior parte das
placas-mãe com chipset Via de fabricação recente. Até pouco tempo, estas placas não tinham
suporte 3D no Linux, mas isso mudou a partir de julho de 2005, quando a Via passou a
patrocinar o desenvolvimento de um driver open source. Como o projeto é recente, muitas
distribuições ainda não incluem o driver, mas no futuro ele tende a se tornar tão bem
suportado quanto os Intel.
Por último, temos as placas SiS (tanto onboard quanto offboard), que são as pior suportadas
no Linux. O fabricante simplesmente não desenvolve nenhum driver, nem abre as
especificações das placas, que permitiriam que outras pessoas o fizessem. Não apenas as
placas de vídeo, mas também as placas-mãe com chipset SiS de uma forma geral
(independente do fabricante da placa-mãe) são as mais problemáticas no Linux, novamente
pela questão da falta de drivers, por isso é recomendável deixá-las em último na lista de
compra. Só considere comprar uma se a diferença de preço for realmente grande e você achar
que a economia compensa a falta de suporte e dor de cabeça.
Embora funcionem no Linux, o driver "sis" do X.org (que dá suporte às placas com chipset SiS)
não oferece desempenho 3D para nenhum dos modelos, limitando bastante seu uso. Um
número relativamente grande de placas não possui sequer aceleração 2D, fazendo com que o
desempenho fique comprometido mesmo em tarefas básicas, como assistir vídeos ou usar o
VMware. Existe um projeto para oferecer suporte 3D a algumas placas (embora sem nenhum
apoio do fabricante), mas que não tem feito muito progresso nos últimos tempos, disponível
no: http://www.winischhofer.at/linuxsisvga.shtml.
A principal diferença entre as placas 3D onboard e as offboard é o barramento de acesso à
memória, que nas placas atuais é o principal limitante de desempenho. Nas placas offboard, a
placa inclui uma quantidade generosa de memória de vídeo, acessada através de um
barramento muito rápido. O GPU (o chipset da placa) é também muito poderoso, de forma que
as duas coisas se combinam para oferecer um desempenho monstruoso. As placas 3D atuais
são praticamente um computador à parte, pois além da qualidade generosa de memória RAM,
acessada através de um barramento muito mais rápido que a do sistema, o chipset de vídeo é
muito mais complexo e absurdamente mais rápido que o processador principal no
processamento de gráficos. O chipset de uma GeForce 7800 GT, por exemplo, é composto por
302 milhões de transistores, enquanto um Pentium III tem "apenas" 28 milhões.
No caso de uma placa onboard, o chipset de vídeo é bem mais simples e incluído diretamente
no chipset da placa-mãe. Para reduzir ainda mais o custo, o vídeo não possui memória
dedicada, simplesmente compartilha a memória principal com o processador.
Mesmo uma placa relativamente barata atualmente, como a GeForce 4 Ti4600 tem 10.4 GB/s
de barramento com a memória de vídeo, enquanto ao usar um pente de memória DDR PC
3200, temos apenas 3.2 GB/s de barramento na memória principal, que ainda por cima precisa
ser compartilhado entre o vídeo e o processador principal. O processador lida bem com isto,
graças aos caches L1 e L2, mas a placa de vídeo realmente não tem para onde correr. É por
isso que os chipsets de vídeo onboard são normalmente bem mais simples: mesmo um chip
caro e complexo não ofereceria um desempenho muito melhor, pois o grande limitante é o
acesso à memória.
O único chipset de vídeo onboard que oferece um desempenho mais próximo do das placas
offboard é o usado nas placas nVidia GeForce, que utilizam um chipset de vídeo separado e o
"twin bank", uma tecnologia que permite que dois pentes de memória sejam acessados
simultaneamente, reduzindo o problema da lentidão do acesso à memória.
Em compensação, as placas com ele são consideravelmente mais caras, e você precisa gastar
um pouco a mais para comprar dois pentes de memória, o que acaba anulando grande parte
da economia em relação a uma placa off-board.
De uma forma geral, as placas de vídeo onboard (pelo menos os modelos que dispõe de
drivers adequados) atuais atendem bem às tarefas do dia-a-dia, com a grande vantagem do
custo. Elas também permitem rodar os games mais antigos com um bom desempenho, apesar
de naturalmente ficarem devendo nos lançamentos recentes.

Placa-mãe

A placa-mãe é o componente mais importante do micro, pois é ela a responsável pela

comunicação entre todos os componentes. Pela enorme quantidade de chips, trilhas,
capacitores e encaixes, a placa-mãe também é o componente que, de uma forma geral, mais
dá defeitos. É comum que um slot PCI pare de funcionar (embora os outros continuem
normais), que instalar um pente de memória no segundo soquete faça o micro passar a travar,
embora o mesmo pente funcione perfeitamente no primeiro, e assim por diante.
A maior parte dos problemas de instabilidade e travamentos são causados por problemas
diversos na placa-mãe, por isso ela é o componente que deve ser escolhido com mais cuidado.
A qualidade da placa-mãe é de longe mais importante que o desempenho do processador. Você
mal vai perceber uma diferença de 20% no clock do processador, mas com certeza vai
perceber se o seu micro começar a travar ou se a placa de vídeo onboard não tiver um bom
suporte no Linux.
Ao montar um PC de baixo custo, economize primeiro no processador, depois na placa de
vídeo, som e outros periféricos. Deixe a placa-mãe por último no corte de despesas.
Não se baseie apenas na marca da placa na hora de comprar, mas também no fornecedor.
Como muitos componentes entram no país ilegalmente, "via Paraguai", é muito comum que
lotes de placas remanufaturadas, ou defeituosas acabem chegando ao mercado. Muita gente
compra estes lotes, vende por um preço um pouco abaixo do mercado e depois desaparece.
Outras lojas simplesmente vão vendendo placas que sabem ser defeituosas até acharem algum
cliente que não reclame. Muitas vezes os travamentos da placa são confundidos com "paus do
Windows", de forma que sempre aparece algum desavisado que não percebe o problema.
Antigamente existia a polêmica entre as placas com ou sem componentes onboard. Hoje em
dia isso não existe mais, pois todas as placas vem com som e rede onboard. Apenas alguns
modelos não trazem vídeo onboard, atendendo ao público que vai usar uma placa 3D off-board
e prefere uma placa mais barata ou com mais slots PCI do que com o vídeo onboard que, de
qualquer forma, não vai usar.
Quanto aos conectores, temos na placa-mãe dois conectores IDE para conectar o HD e o CD-
ROM, um slot AGP (o marrom) para a placa de vídeo, vários slots PCI (os brancos) para o
modem, placa de som e outras placas, soquetes para conectar a memória, o soquete para o
processador, o conector para a fonte de alimentação e o painel traseiro, que agrupa os
encaixes dos componentes onboard, incluindo o vídeo, som, rede e portas USB.
O soquete (ou slot) para o processador é a principal característica da placa-mãe, pois indica
com quais processadores ela é compatível. Você não pode instalar um Athlon 64 numa placa
soquete A (que é compatível com os Athlons, Durons e Semprons), nem muito menos encaixar
um Sempron numa placa soquete 478, destinada aos Pentium 4. O soquete é na verdade
apenas um indício de diferenças mais "estruturais" na placa, incluindo o chipset usado, o
layout das trilhas de dados, etc. É preciso desenvolver uma placa quase que inteiramente
diferente para suportar um novo processador.
Existem ainda dois tipos de portas para a conexão do HD: as portas IDE tradicionais, de 40
pinos (PATA, de Parallel ATA) e os conectores SATA (Serial ATA), que são muito menores.
Muitas placas recentes incluem um único conector PATA e quatro conectores SATA. Outras
incluem as duas portas IDE tradicionais e dois conectores SATA e, algumas já passam a trazer
apenas conectores SATA, deixando de lado os conectores antigos. Existem ainda algumas
placas "legacy free", que eliminam também os conectores para o drive de disquete, portas
seriais e porta paralela, incluindo apenas as portas USB. Isso permite simplificar o design das
placas, reduzindo o custo de produção.

Tudo isso é montado dentro do gabinete, que contém outro componente importante: a fonte
de alimentação. A função da fonte é transformar a corrente alternada da tomada em corrente
contínua (AC) já nas tensões corretas, usadas pelos componentes. Ela serve também como
uma última linha de defesa contra picos de tensão e instabilidade na corrente, depois do
nobreak ou estabilizador.
Embora quase sempre relegada a último plano, a fonte é outro componente essencial num PC
atual. Com a evolução das placas de vídeo e processadores, os PCs consomem cada vez mais
energia. Na época dos 486, as fontes mais vendidas tinham 200 watts ou menos, enquanto as
atuais têm a partir de 450 watts. Uma fonte subdimensionada não é capaz de fornecer energia
suficiente nos momentos de pico, causando desde erros diversos, provocados por falhas no
fornecimento (o micro trava ao tentar rodar um game pesado, ou trava sempre depois de
algum tempo de uso, por exemplo), ou, em casos mais graves, até mesmo danos aos
componentes. Uma fonte de má qualidade, obrigada a trabalhar além do suportado, pode
literalmente explodir, danificando a placa-mãe, memórias, HDs e outros componentes
sensíveis.

Evite comprar fontes muito baratas e, ao montar um micro mais parrudo, invista numa fonte
de maior capacidade.
Não se esqueça também do fio terra, que é outro componente importante, mas
freqüentemente esquecido. O fio terra funciona como uma rota de fuga para picos de tensão
provenientes da rede elétrica. A eletricidade flui de uma forma similar à água: vai sempre pelo
caminho mais fácil. Sem ter para onde ir, um raio vai torrar o estabilizador, a fonte de
alimentação e, com um pouco mais de azar, a placa-mãe e o resto do micro. O fio terra evita
isso, permitindo que a eletricidade escoe por um caminho mais fácil, deixando todo o
equipamento intacto.
O fio terra é simplesmente uma barra de cobre com dois a três metros de comprimento, que é
cravada no solo, no meio de um buraco de 20 cm de largura, preenchido com sal grosso e
carvão. Naturalmente, instalar o terra é trabalho para o eletricista, até porque cavar o buraco e
cravar a barra não é um trabalho nada fácil :-). Sem o terra, o estabilizador perde grande
parte de sua função, tornando-se mais um componente decorativo, que vai ser torrado junto
com o resto, do que uma proteção real.
Nas grandes cidades, é relativamente raro acontecer dos micros queimarem por causa de rios,
pois os transformadores e disjuntores oferecem uma proteção razoável. Mas, pequenos picos
de tensão são responsáveis por pequenos danos nos pentes de memória e outros componentes
sensíveis, danos que se acumulam, comprometendo a estabilidade e abreviando a vida útil do
equipamento.
A longo prazo, o investimento na instalação do terra e melhorias na instalação elétrica acabam
se pagando com juros, principalmente se você tem mais de um micro.

Hardware x Software

Toda esta parte física, as coisas tangíveis, que você pode tocar é chamada de hardware. A
parte mais importante vem depois, o Software, os programas que permitem que o computador
faça coisas úteis. É aí que entra o sistema operacional e, depois dele, os programas que
usamos no dia-a-dia.
Um bom sistema operacional é invisível. A função dele é detectar e utilizar o hardware da
máquina de forma eficiente, fornecendo uma base estável sobre a qual os programas que
utilizamos no cotidiano possam ser usados. Como diz Linus Torvalds, as pessoas não usam o
sistema operacional, usam os programas instalados. Quando você se lembra que está usando
um sistema operacional, é sinal de que alguma coisa não está funcionando como deveria.
O sistema operacional permite que o programador se concentre em adicionar funções úteis,
sem ficar se preocupando com que tipo de placa de vídeo ou placa de som você tem. O
programa diz que quer mostrar uma janela na tela e ponto; o modelo de placa de vídeo que
está instalado e que comandos são necessários para mo strar a janela são problema do
sistema operacional.
Para acessar a placa de vídeo, ou qualquer outro componente instalado, o sistema operacional
precisa de um driver, que é um pequeno programa que trabalha como um intérprete,
permitindo que o sistema converse com o dispositivo. Cada placa de vídeo ou som possui um
conjunto próprio de recursos e comandos que permitem usá-los. O driver converte estes
diferentes comandos em comandos padrão, que são entendidos pelo sistema operacional.
O driver é como se fosse a chave do carro, sem ela você não entra no carro nem dá a partida e
ele não serve para nada. Comprar uma impressora ou scanner que não possua driver para o
Linux, ou outro sistema operacional que você pretende utilizar, é como comprar um carro sem
a chave. Pesquise antes para não levar gato por lebre.

Arquiteturas

Nos primórdios da informática, nas décadas de 50, 60 e 70, vários fabricantes diferentes
disputavam o mercado. Cada um desenvolvia seus próprios computadores, que eram
incompatíveis entre si. Tanto o hardware quanto os softwares para cada arquitetura não
funcionavam nas outras. Isso causava uma ineficiência generalizada, pois cada fabricante tinha
que desenvolver tudo, da placa-mãe ao sistema operacional.
No começo dos anos 80, os fabricantes começaram a se especializar. Surgiu então o PC que é
uma arquitetura aberta, um conjunto de padrões que permite usar periféricos de vários
fabricantes diferentes e roda vários tipos de sistemas operacionais.
O principal concorrente é a Apple, que produz os Macs. Ao contrário dos PCs, eles possuem
uma arquitetura fechada. A Apple desenvolve tanto os computadores quando o sistema
operacional.
Naturalmente muita coisa é terceirizada e várias empresas desenvolvem programas e
acessórios, mas como a Apple precisa manter o controle de tudo e desenvolver muita coisa por
conta própria, o custo dos Macs acaba sendo bem mais alto que o dos PCs. Isso faz com que
(embora tenham seus atrativos) eles sejam muito menos populares. Atualmente os Macs
possuem menos de 3% do mercado mundial, o que significa uma proporção de mais de 30 PCs
para cada Mac.
No início da década de 80, a concorrência era mais acirrada e muitos achavam que o modelo
da Apple poderia prevalecer, mas não foi o que aconteceu. Dentro da história da informática
temos inúmeras histórias que mostram que os padrões abertos quase sempre prevalecem. Um
ambiente onde existem várias empresas concorrendo entre si favorece o desenvolvimento de
produtos melhores, o que cria uma demanda maior e, graças à economia de escala, permite
preços mais baixos.
Como os micros PC possuem uma arquitetura aberta, ou seja, a possibilidade de vários
fabricantes diferentes desenvolverem seus próprios componentes baseados em padrões já
definidos, temos uma lista enorme de componentes compatíveis entre si. Podemos escolher
entre várias marcas e modelos os componentes que melhor atendam nossas necessidades e
montar nossa própria configuração, de acordo com o uso.
Qualquer novo fabricante, com uma placa-mãe mais barata ou um processador mais rápido,
por exemplo, pode entrar no mercado, é apenas uma questão de criar a demanda necessária.
A concorrência faz com que os fabricantes sejam obrigados a trabalhar com uma margem de
lucro relativamente baixa, ganhando com base no volume de peças vendidas, o que é muito
bom para nós que compramos.

Um pouco sobre a história do Linux

Paralelamente à história da informática que conhecemos, com a IBM lançando seu IBM PC em
1981, o MS-DOS e as várias versões do Windows, existiram várias versões dos sistemas Unix,
como o Solaris e o AIX que reinaram durante muito tempo nos servidores.
Mas, o Windows foi o primeiro sistema operacional amigável e acessível, que o transformou
numa espécie de opção default para micros domésticos. A Apple tinha o Mac OS, outro sistema
amigável e superior ao Windows em muitos aspectos, mas que só rodava nos computadores
produzidos pela própria Apple, muito mais caros que os PCs.
Quem precisava de um sistema robusto e confiável para seus servidores optava por uma das
várias versões do Unix, profissionais da área gráfica usavam Macs e o resto convivia com os
problemas do Windows.
O Linux surgiu de uma forma completamente despretensiosa, como o projeto de um estudante
Finlandês. Muitos sistemas são desenvolvidos como projetos de conclusão de curso ou apenas
por hobby. O que permitiu que o Linux se transformasse no que é foi uma grande combinação
de fatores e alguma dose de sorte.
Tudo começou em 1983, pouco depois que a IBM lançou seu primeiro PC e a Microsoft sua
primeira versão do DOS. Richard Stallman criava a Free Software Fundation, que ao longo da
década produziu a licença GNU e toda a base filosófica relacionada a ela e, mais importante,
um conjunto de ferramentas, como o editor Emacs e o compilador GCC.
O Emacs é um editor de texto que combina uma grande quantidade de recursos e ferramentas
úteis para programadores. O GCC é o compilador que permite transformar o código escrito
nele em arquivos executáveis. A idéia era desenvolver um sistema operacional completo, mas
para isso faltava a peça principal: o Kernel.
Imagine o Kernel como o cérebro e o coração de um sistema operacional. Ele sozinho não
serve para nada, mas sem ele o resto do corpo também não vai muito longe. Em 1991, a Free
Software Fundation ainda estava dando os primeiros passos no desenvolvimento do Hurd (que
ainda hoje está muito longe se ser concluído), enquanto o Linux de Linus Torvalds era utilizável
desde suas primeiras versões. O corpo encontrava o cérebro.
O fato do código fonte estar amplamente disponível e poder ser utilizado de forma muito
liberal permitiu que muitos desenvolvedores passassem a trabalhar no sistema ainda em sua
fase embrionária, adicionando novos recursos num ritmo muito rápido. Mas, durante os
primeiros anos, o Linux ficou restrito a este círculo técnico, muito longe de ser usado em larga
escala.
Isso começou a mudar com o aparecimento da Internet. O Apache foi um dos primeiros
servidores web a ser lançado e tornou-se rapidamente o mais usado numa época em que
existiam poucos concorrentes à altura. O Apache rodava em várias plataformas, mas o Linux
tornou-se a opção mais comum, por ser rápido e estável.
Pouco tempo depois veio o servidor Samba, que permitia compartilhar arquivos numa rede
Windows, de forma mais estável e mais barata que usando um servidor Windows. Novamente,
o Linux tornou-se a opção preferida. Depois, vieram os bancos de dados e muitas outras
aplicações, mas todas tinham algo em comum: sempre falávamos de servidores.
Por volta do final de 1994 foi lançada a primeira versão for Linux do Xfree. Ele é um "servidor
gráfico", uma interface gráfica usada em vários sistemas Unix. Antes do Xfree, o Linux tinha
apenas a velha interface de modo texto, o que explicava o fato de ele ser popular apenas entre
programadores e administradores de sistemas. Em 2004, o Xfree passou a ser gradualmente
substituído pelo X.org.
Uma coisa interessante sobre o X é que ele fornece a fase para o funcionamento da parte
gráfica, incluindo o suporte à placa de vídeo e mouse, mas não inclui a interface em si. Graças
a isso, não existe uma interface gráfica padrão como temos no Windows, por exemplo.
Existem no Linux várias interfaces diferentes, conhecidas como gerenciadores de janelas. No
início existiam muitas interfaces diferentes, mas nenhuma chegava próxima do nível de
funcionalidade e integração que existe no Windows. Isto mudou com o aparecimento do KDE
(que é a interface usada por padrão em diversas distribuições, incluindo o Mandriva, SuSE e o
Kurumin) e mais tarde também com o Gnome.

Ainda por volta de 1994 começaram a surgir as primeiras distribuições Linux, que eram um
jeito mais "fácil" de instalar o sistema. Ao invés de ficar compilando tudo, começando pelo
Kernel e passando por todos os aplicativos da Free Software Fundation, Xfree e o que mais
você pretendesse rodar, você simplesmente passava alguns dias editando arquivos de
configuração com a ajuda de alguns manuais mal escritos. Para você ter uma idéia do tamanho
da encrenca, uma das distribuições consideradas mais "amigáveis" na época era o Slackware,
ainda em suas primeiras versões.
Se você é algum saudosista desta época em que "homens eram homens e compilavam seus
sistemas do zero", sinta-se livre para pesquisar no Google sobre o "Linux from Scratch", um
passo a passo (com muitos passos...) que ensina como fazer isso. Pobres mortais como eu,
possuem coisas mais urgentes e menos chatas a fazer... ;-).
Uma distribuição é um conjunto com o Kernel e vários programas, empacotado de forma que
seja fácil de instalar e manter atualizado. Uma das primeiras versões com foco na facilidade de
uso foi o Red Hat, que serviu de base para um grande número de distribuições, como o
Mandrake, SuSE e Conectiva.
O Red Hat trouxe uma idéia nova, que foi rapidamente adotada em todas as outras
distribuições: um sistema de gerenciamento de pacotes. Cada programa incluído era
transformado num pacote compactado, que podia ser instalado através de um único comando.
O sistema guardava as informações dos pacotes instalados permitindo que você pudesse
removê-los depois. Não era tão amigável quanto clicar num executável e ter um instalador
gráfico e, existiam problemas com dependências (um pacote precisa do outro, que precisa do
outro, que precisa do outro...), mas já era muito melhor que sair compilando as coisas na
unha.
Por volta de 1997 já existiam um conjunto de distribuições relativamente fáceis de usar, com
sistemas de instalação relativamente simples, do tipo que um técnico médio consegue seguir
sozinho com a ajuda do manual.
Nesta época algumas empresas passaram a portar seus sistemas e utilizar o Linux como uma
forma de reduzir seus custos com licenciamento e manutenção (imunidade a vírus, menos
travamentos, menos reinstalações do sistema; quem já usou o Windows 3.11 ou o 95 sabe do
que estou falando...). O Linux dava seus primeiros passos no desktop, mas ainda existiam
poucos aplicativos que rivalizassem em recursos e facilidade de uso com os do Windows.
Nos anos seguintes houve um crescimento espantoso. Aquele sistema feio, difícil de usar,
famoso apenas por ser estável e bom para servidores ganhou o KDE e o Gnome, finalmente
duas interfaces bonitas e fáceis de usar, ferramentas de configuração automática e um grande
número de aplicativos, incluindo compatibilidade com alguns programas e jogos do Windows
através do Wine, o que levou a um número cada vez maior de desenvolvedores e usuários.
Ao contrário de um sistema comercial, com todo o planejamento e estruturas envolvidas, o
Linux é desenvolvido de forma descentralizada. Qualquer um pode pegar o código de algum
programa, adaptá-lo, acrescentar novos recursos e transformá-lo em algo diferente do original,
com aplicações que o autor original não seria capaz de sequer sonhar.
Isto cresce em escala geométrica, como uma bola de neve que vai crescendo e passando por
cima de quem se atrever a oferecer resistência.
A licença GPL, pode ser resumida em 4 direitos básicos e uma obrigação:
1- Você tem o direito de usar o programa para qualquer fim. Não existe discriminação. Um
exemplo é que ninguém pode impedir que um programa GPL seja usado numa clínica de
aborto ou numa instalação militar, por exemplo.
2- Você tem o direito de tirar cópias do programa, distribuí-las ou até mesmo vendê-las a
quem tiver interesse. Existe a possibilidade de ganhar algum dinheiro vendendo CDs gravados,
por exemplo, mas como todo mundo pode fazer a mesma coisa, é preciso vender por um preço
relativamente baixo, cobrando pelo trabalho de gravação e não pelo software em si, que está
largamente disponível. A forma mais eficiente de ganhar dinheiro com software livre é vender
suporte e serviços de personalização sobre os programas e distribuições que você domina.
Para o cliente acaba sendo vantajoso, pois o custo de implantação será o gasto com a
consultoria e treinamentos, enquanto ao implantar um software comercial qualquer ele
gastaria também com as licenças de uso.
3- Direito de ter acesso ao código fonte do programa, fazer alterações e redistribuí-las. Para
um programador este é o principal atrativo, pois você pode criar novos projetos usando como
base o código fonte de programas já existentes ao invés de ter sempre que começar do zero,
sem falar na grande oportunidade de aprendizado que examinar o código fonte dos programas
disponíveis propicia.
4- Direito (e ao mesmo tempo a obrigação) de redistribuir as modificações feitas. Este é o
ponto onde existem mais mal-entendidos. Se você desenvolve um software por hobby, ou por
usá-lo internamente na sua empresa, e não possui interesse em explorá-lo comercialmente,
você pode simplesmente divulgar o código fonte para todo mundo, o que é o caminho mais
lógico se você pretende atrair outros interessados em ajudá-lo no desenvolvimento. Mas, caso
você pretenda receber pelo seu trabalho de desenvolvimento, existem duas opções:
a) Você pode distribuir o software livremente para aumentar a base de usuários e ganhar
vendendo suporte, treinamentos e personalizações ou:
b) Você só é obrigado a distribuir o código fonte a quem obtém o software, de forma que você
pode trabalhar batendo de porta a porta, vendendo o software para alguns clientes específicos
e fornecendo o código fonte apenas para eles. Não existe nada de errado com este modelo,
mas você perde a possibilidade de ter contribuições de outros desenvolvedores, o que pode ser
ruim a longo prazo.
5- Os softwares distribuídos sob a GPL não "contaminam" softwares comerciais ou de outras
licenças no caso de distribuição conjunta. Por exemplo, uma revista pode distribuir alguns
softwares GPL no meio de um monte de aplicativos fechados na mesma edição. Os softwares
GPL continuam sendo GPL, com todas regras que vimos acima, enquanto os softwares
comerciais continuam sendo fechados. A revista deve incluir o código fonte dos aplicativos GPL
(ou pelo menos a informação de como obtê-los via internet), mas naturalmente não precisa
fazer o mesmo com os outros aplicativos incluídos no CD.
Você pode também usar algum software GPL em conjunto com o seu aplicativo comercial,
desenvolvendo um aplicativo qualquer que utiliza o Postgree SQL (um servidor de banco de
dados), por exemplo. O Postgree SQL continua sendo GPL e o seu aplicativo continua sendo
fechado; qualquer um pode usar e tirar cópias do Postgree SQL, mas você controla a
distribuição do seu aplicativo. Uma coisa não interfere com a outra.

Um exemplo: desenvolvi o Kurumin usando como base dois projetos já existentes, o Knoppix e
o Debian. O Knoppix entrou com sistema de detecção de hardware e configuração automática
e o Debian com toda a base do sistema, como os pacotes e ferramentas de administração
como o apt-get. Ao invés de ter que ficar compilando tudo, posso usar os pacotes do Debian
que já estão prontos; e, ao invés de ficar desenvolvendo mais um ferramenta de detecção,
posso usar o sistema do Knoppix que funciona extremamente bem.
Como a parte funcional do sistema já está pronta, posso trabalhar personalizando o sistema,
desenvolvendo scripts de instalação, ferramentas de configuração, adicionando novos recursos
e corrigindo problemas. Começo do ponto aonde os outros já chegaram, aproveitando todo o
esforço anterior.
Quando alguém desenvolve um projeto derivado, uma outra distribuição Linux usando o
Kurumin como base, como o Kalango ou o Dizinha, ganho novamente, pois posso utilizar as
correções e novos recursos adicionados neles.
Muitas pessoas que utilizam o Kurumin acabam contribuindo com soluções para problemas e
melhorias diversas. Para eles é interessante fazer isso, pois os problemas são resolvidos nas
novas versões, evitando que eles precisem ficar corrigindo manualmente os novos problemas
indefinidamente.

Um pouco sobre redes

Montar uma rede já foi complicado e caro. Hoje em dia, as redes são algo onipresente, uma
forma barata de trocar arquivos, compartilhar a conexão com a internet, compartilhar
impressoras, CD-ROM e outros periféricos e assim por diante.
O uso mais corriqueiro é compartilhar a conexão com a internet. Você tem apenas uma linha
ADSL ou apenas uma assinatura do serviço de acesso via cabo e pode acessar, ao mesmo
tempo, a partir de todos os micros que tiver em sua casa ou empresa. Neste caso um dos
micros atua como um ponto de encontro, enviando os pedidos de todos para a internet e
devolvendo as respostas. Além de compartilhar a conexão, este servidor pode compartilhar
arquivos, servir como firewall (protegendo a rede de acessos externos), rodar um proxy (que
permite criar um cache de arquivos e páginas acessados, melhorando a velocidade da
conexão), além de outros serviços.
Outra necessidade comum é compartilhar arquivos. Antigamente (naquela época em que os
micros tinham 512 KB de memória e os homens eram homens e escreviam seus próprios
sistemas operacionais) era usado o protocolo DPL/DPC (disquete pra lá, disquete pra cá), mas
ele não era muito eficiente, principalmente quando o amigo que estava esperando os arquivos
estava em outra cidade...
Os componentes básicos da rede são uma placa de rede para cada micro, os cabos e o hub ou
switch que serve como um ponto de encontro, permitindo que todos os micros se enxerguem e
conversem entre si.
As placas de rede já foram componentes caros, mas como elas são dispositivos relativamente
simples e o funcionamento é baseado em padrões abertos, qualquer um pode abrir uma
fábrica de placas de rede, o que faz com que exista uma concorrência acirrada que obriga os
fabricantes a produzirem placas cada vez mais baratas e trabalhem com margens de lucro
cada vez mais estreitas. As placas de rede mais baratas chegam a ser vendidas no atacado por
menos de três dólares. O preço final é um pouco mais alto naturalmente, mas não é difícil
achar placas por 20 reais ou até menos.
Temos três padrões de redes Ethernet: de 10 megabits, 100 megabits e 1 gigabit. As placas
são intercompatíveis, mas, ao usar placas de velocidades diferentes, as duas vão conversar na
velocidade da placa mais lenta.
As redes 10 megabits já são obsoletas, mas ainda é possível encontrar muitas instalações
antigas por aí. Caso a rede já use cabos de categoria 5 (o número vem decalcado no cabo), é
possível fazer um upgrade direto para 100 megabits, trocando apenas o hub e placas.
Lembre-se de que a velocidade das placas é calculada em bits e não em bytes. Uma rede de
100 megabits permite uma taxa de transmissão (teórica) de 12.5 MB/s. Como além dos dados
são transmitidas outras informações (a estrutura dos pacotes, retransmissões, códigos de
correção de erros, etc.), a velocidade na prática fica sempre um pouco abaixo disso.
Normalmente é possível transferir arquivos a no máximo 10.5 MB/s, com a taxa máxima
variando sutilmente de acordo com a placa e o sistema operacional usado.
A opção para quem precisa de mais velocidade são as redes Gigabit Ethernet, que transmitem
a até 1000 megabits (125 megabytes) por segundo. As placas Gigabit atuais são compatíveis
com os mesmos cabos de par trançado categoria 5, usados pelas placas de 100 megabits, por
isso a diferença de custo fica por conta apenas das placas e do switch. Elas ainda são muito
mais caras, mas pouco a pouco o preço vai caindo.
Os cabos de rede também são um artigo relativamente barato. Os cabos de categoria 5 que
usamos em redes de 100 ou 1000 megabits geralmente custam em torno de 80 centavos o
metro, com mais alguns centavos por conector.
Você pode comprar quantos metros de cabo quiser, junto com os conectores e fazer crimpar os
cabos você mesmo, ou pode comprá-los já prontos. É no caso dos cabos já crimpados que o
preço começa a variar. Algumas lojas chegam a crimpar os cabos na hora cobrando apenas o
valor do material, enquanto outras vendem os cabos por preços exorbitantes.

Os cabos devem ter um mínimo de 30 centímetros e um máximo de 100 metros, a distância

máxima que o sinal elétrico percorre antes que comece a haver uma degradação que
comprometa a comunicação. Na verdade, estes valores não são exatos, principalmente com
relação ao comprimento máximo do cabo.
Não é incomum ver gente usando cabos fora do padrão, com 120, 150 ou, em alguns casos
até 200 metros. Dependendo da qualidade das placas de redes, cabos, conectores, crimpagem
e do nível de interferências do ambiente, o sinal pode se propagar por distâncias bem acima
dos 100 metros, mas neste caos sem garantia nenhuma de estabilidade. Até 100 metros você
pode ter certeza de que a rede funcionará, acima disso começa a depender da sorte.
Existem dois tipos de cabos de rede: os cabos retos (straight), que são os cabos "normais",
usados para ligar os vários micros ao hub ou switch, e os cabos cross-over, que utilizam um
padrão diferente, que permite ligar diretamente dois micros, sem precisar de um hub.
Todas as placas são ligadas ao hub ou switch, que serve como uma central, de onde os sinais
de um micro são retransmitidos para os demais. Todas as placas de rede são ligadas ao hub ou
switch e é possível ligar vários hubs ou switchs entre si (até um máximo de 7) caso necessário,
formando redes maiores.

A diferença entre um hub é um switch é que o hub apenas retransmite tudo o que recebe para
todos os micros conectados a ele, é um tagarela. Isso faz com que apenas um micro consiga
transmitir dados de cada vez e que todas as placas precisem operar na mesma velocidade
(sempre nivelada por baixo, caso você coloque um micro com uma placa de 10 megabits na
rede, a rede toda passará a trabalhar a 10 megabits).
Os switchs, por sua vez, são aparelhos mais inteligentes. Eles fecham canais exclusivos de
comunicação entre o micro que está enviando dados e o que está recebendo, permitindo que
vários pares de micros troquem dados entre si ao mesmo tempo. Isso melhora bastante a
velocidade em redes congestionadas, com muitos micros.
Antigamente, existia uma grande diferença de preço entre os hubs burros e os switchs, mas os
componentes caíram tanto de preço que a partir de um certo ponto a diferença se tornou
insignificante e os fabricantes passaram a fabricar apenas switchs, que por sua vez dividem-se
em duas categorias: os switchs "de verdade", aparelhos caros, capazes de gerenciar o tráfego
de uma quantidade maior de micros e que possuem várias ferramentas de gerenciamento e os
"hub-switchs", os modelos mais simples e baratos, que usamos no dia-a-dia.

O TCP/IP e a configuração da rede

Tudo o que vimos até agora, sobre placas e cabos representa a parte física da rede, os
componentes necessários para fazer os uns e zeros enviados por um computador chegarem ao
outro. O TCP/IP é o protocolo de rede, o conjunto de regras e padrões que permite que eles
realmente falem a mesma língua.
Pense nas placas, hubs e cabos como o sistema telefônico e no TCP/IP como a língua falada
que você usa para realmente se comunicar. Não adianta nada ligar para alguém na China que
não saiba falar Português. Sua voz vai chegar até lá, mas ela não vai entender nada. Além da
língua em si, existe um conjunto de padrões, como por exemplo dizer "alô" ao atender o
telefone, dizer quem é, se despedir antes de desligar, etc.
Ligar os cabos e ver se os leds do hub e das placas estão acesos é o primeiro passo. O
segundo é configurar os endereços da rede para que os micros possam conversar entre si, e o
terceiro é finalmente compartilhar a internet, arquivos, impressoras e o que mais você quer
que os outros micros da rede tenham acesso.
Graças ao TCP/IP, tanto o Linux quanto o Windows e outros sistemas operacionais em uso são
intercompatíveis dentro da rede. Não existe problema para as máquinas com o Windows
acessarem a internet através da conexão compartilhada no Linux, por exemplo.
Independente do sistema operacional usado, as informações básicas para que ele possa
acessar a internet através da rede são:

- Endereço IP:
Os endereços IP identificam cada micro na rede. A regra básica é que cada micro deve ter um
endereço IP diferente e todos devem usar endereços dentro da mesma faixa.
O endereço IP é dividido em duas partes. A primeira identifica a rede à qual o computador está
conectado (necessário, pois numa rede TCP/IP podemos ter várias redes conectadas entre si,
veja o caso da internet) e a segunda identifica o computador (chamado de host) dentro da
rede. É como se o mesmo endereço contivesse o número do CEP (que indica a cidade e a rua)
e o número da casa.
A parte inicial do endereço identifica a rede e os últimos identificam o computador dentro da
rede. Quando temos um endereço "192.168.0.1", por exemplo, temos o micro "1" dentro da
rede "192.168.0". Quando alguém diz "uso a faixa 192.168.0.x na minha rede", está querendo
dizer justamente que apenas o último número muda de um micro para outro.
Na verdade, os endereços IP são números binários, de 32 bits. Para facilitar a configuração e
memorização dos endereços, eles são quebrados em 4 números de 8 bits cada um. Os 8 bits
permitem 256 combinações diferentes, por isso usamos 4 números de 0 a 255 para
representá-los.
Todos os endereços IP válidos na internet possuem dono. Seja alguma empresa ou alguma
entidade certificadora que os fornece junto com novos links. Por isso não podemos utilizar
nenhum deles a esmo.
Quando você se conecta na internet você recebe um (e apenas um) endereço IP válido,
emprestado pelo provedor de acesso, algo como por exemplo "200.220.231.34". É através
deste número que outros computadores na Internet podem enviar informações e arquivos para
o seu.
Quando quiser configurar uma rede local, você deve usar um dos endereços reservados,
endereços que não existem na internet e que por isso podemos utilizar à vontade em nossas
redes particulares. Algumas das faixas reservadas de endereços são: 10.x.x.x, 172.16.x.x
até 172.31.x.x e 192.168.0.x até 192.168.255.x
Você pode usar qualquer uma dessas faixas de endereços na sua rede. Uma faixa de
endereços das mais usadas é a 192.168.0.x, onde o "192.168.0." vai ser igual em todos os
micros da rede e muda apenas o último número, que pode ser de 1 até 254 (o 0 e o 255 são
reservados para o endereço da rede e o sinal de broadcast). Se você tiver 4 micros na rede, os
endereços deles podem ser, por exemplo, 192.168.0.1, 192.168.0.2, 192.168.0.3 e
192.168.0.4.

- Máscara de sub-rede
A máscara é um componente importante do endereço IP. É ela que explica para o sistema
operacional como é feita a divisão do endereço, ou seja, quais dos 4 octetos compõem o
endereço da rede e quais contém o endereço do host, ou seja, o endereço de cada micro
dentro da rede.
Ao contrário do endereço IP, que é formado por valores entre 0 e 255, a máscara de sub-rede
é formada por apenas dois valores: 0 e 255, como em 255.255.0.0 ou 255.0.0.0, onde um
valor 255 indica a parte endereço IP referente à rede, e um valor 0 indica a parte endereço IP
referente ao host.
Se você está usando a faixa 192.168.0.x, por exemplo, que é um endereço de classe C, então
a máscara de sub-rede vai ser 255.255.255.0 para todos os micros. Você poderia usar uma
máscara diferente: 255.255.0.0 ou mesmo 255.0.0.0, desde que a máscara seja a mesma em
todos os micros.
Se você tiver dois micros, 192.168.0.1 e 192.168.0.2, mas um configurado com a máscara
"255.255.255.0" e o outro com "255.255.0.0", você terá na verdade duas redes diferentes.
Um dos micros será o "1" conectado na rede "192.168.0" e o outro será o "0.2", conectado na
rede "192.168".

- Default Gateway (gateway padrão)

Lembra que disse que quando você se conecta à internet através de um provedor de acesso
qualquer, você recebe apenas um endereço IP válido? Quando você compartilha a conexão
entre vários micros, apenas o servidor que está compartilhando a conexão possui um endereço
IP válido, só ele "existe" na internet. Todos os demais acessam através dele.
O default gateway ou gateway padrão é justamente o micro da rede que tem a conexão, que
os outros consultarão quando precisarem acessar qualquer coisa na internet.
Por exemplo, se você montar uma rede doméstica com 4 PCs, usando os endereços IP
192.168.0.1, 192.168.0.2, 192.168.0.3 e 192.168.0.4, e o PC 192.168.0.1 estiver
compartilhando o acesso à internet, as outras três estações deverão ser configuradas para
utilizar o endereço 192.168.0.1 como gateway padrão.

- Servidor DNS
Memorizar os 4 números de um endereço IP é muito mais simples do que memorizar o
endereço binário. Mas, mesmo assim, fora os endereços usados na sua rede interna, é
complicado sair decorando um monte de endereços diferentes.
O DNS (domain name system) permite usar nomes amigáveis ao invés de endereços IP para
acessar servidores, um recurso básico que existe praticamente desde os primórdios da
internet. Quando você se conecta à internet e acessa o endereço
http://www.guiadohardware.net, é um servidor DNS que converte o "nome fantasia" no
endereço IP real do servidor, permitindo que seu micro possa acessar o site.
Para tanto, o servidor DNS mantém uma tabela com todos os nomes fantasia, relacionados
com os respectivos endereços IP. A maior dificuldade em manter um servidor DNS é
justamente manter esta tabela atualizada, pois o serviço tem que ser feito manualmente.
Dentro da internet, temos várias instituições que cuidam desta tarefa. No Brasil, por exemplo,
temos a FAPESP. Para registrar um domínio é preciso fornecer à FAPESP o endereço IP real do
servidor onde a página ficará hospedada. A FAPESP cobra uma taxa de manutenção anual de
R$ 30 por este serviço.
Servidores DNS também são muito usados em intranets, para tornar os endereços mais
amigáveis e fáceis de guardar.
Faz parte da configuração da rede informar os endereços DNS do provedor (ou qualquer outro
servidor que você tenha acesso), que é para quem seu micro irá perguntar sempre que você
tentar acessar qualquer coisa usando um nome de domínio e não um endereço IP. O jeito mais
fácil de conseguir os endereço do provedor é simplesmente ligar para o suporte e perguntar.
O ideal é informar dois endereços, assim se o primeiro estiver fora do ar, você continua
acessando através do segundo. Também funciona com um endereço só, mas você perde a
redundância. Exemplos de endereços de servidores DNS são: 200.204.0.10 e 200.204.0.138.
No Kurumin você encontra a opção de configurar a rede dentro do Painel de Controle, em
"Conectar na internet ou configurar a rede > Configurar conexão via rede local". O assistente
vai perguntando as configurações da rede que vimos.

Um exemplo de configuração de rede completa para um dos micros da rede, que vai acessar a
internet através do micro que está compartilhando a conexão seria:
IP: 192.168.0.2
Máscara: 255.255.255.0
Gateway: 192.168.0.1 (o endereço do micro compartilhando a conexão)
DNS: 200.204.0.10 200.204.0.138
O micro que está compartilhando a conexão por sua vez vai ter duas placas de rede, uma para
a internet e outra para a rede local, por isso vai ter uma configuração separada para cada
uma. A configuração da internet é feita da forma normal, de acordo com o tipo de conexão que
você usa, e a configuração da rede interna segue o padrão que vimos até aqui.
É possível usar também um servidor DHCP para fornecer as configurações da rede para os
micros, de forma que você não precise ficar configurando os endereços manualmente em cada
um. O configurador do Kurumin pergunta sobre isso logo na primeira opção: "Configurar a rede
via DHCP"?
Respondendo "Sim", o micro simplesmente "pede socorro" na rede e é ajudado pelo servidor
DHCP, que fornece para ele toda a configuração da rede, de forma automática. Você gasta um
pouco mais de tempo configurando o servidor DHCP, mas em compensação economiza na
configuração dos micros.

Redes wireless

Apesar de inicialmente muito mais caras, as redes wireless estão gradualmente caindo de
preço e se popularizando rapidamente. Além da questão da praticidade, em muitos casos
simplesmente não é viável usar cabos. Imagine que você precise ligar dois escritórios situados
em dois prédios distantes, ou que a sua mãe/esposa/marido não deixa você nem pensar em
espalhar cabos pela casa.
O que você precisa prestar atenção na hora de comprar é se o modelo escolhido é bem
suportado no Linux. Caso a placa tenha um driver disponível, a configuração será simples,
quase como a de uma placa de rede normal, mas sem o driver você fica trancado do lado de
fora do carro. Lembre-se, o driver é a chave e você nunca deve comprar um carro sem a chave
:-).
Numa rede wireless, o hub é substituído pelo ponto de acesso (access-point em inglês). Ele
tem basicamente a mesma função: retransmitir os pacotes de dados, de forma que todos os
micros da rede os recebam. Em geral os pontos de acesso possuem uma saída para serem
conectados num hub tradicional, permitindo que você "junte" os micros da rede com fios com
os que estão acessando através da rede wireless, formando uma única rede.
Ao contrário dos hubs, os pontos de acesso são dispositivos inteligentes, que podem ser
configurados através de uma interface de administração via web. Você se conecta num
endereço específico usando o navegador (que muda de aparelho para aparelho, mas pode ser
encontrado facilmente no manual), loga-se usando uma senha padrão e altera as
configurações (e senhas!) de acordo com as necessidades da sua rede.
Ao contrário de uma rede cabeada, com um switch, em qualquer rede wireless a banda da
rede é compartilhada entre os micros que estiverem transmitindo dados simultaneamente. Isso
acontece pois não existem cabos independentes ligando o ponto de acesso a cada micro, mas
um único meio de transmissão (o ar), o que faz com que a rede opere como se todos os micros
estivessem ligados ao mesmo cabo. Enquanto um transmite, os outros esperam. Conforme
aumenta o número de micros e aumenta o tráfego da rede, mais cai o desempenho.
Outra questão é que a potência do sinal decai conforme aumenta a distância, enquanto a
qualidade decai pela combinação do aumento da distância e dos obstáculos pelo caminho. É
por isso que num campo aberto o alcance será muito maior do que dentro de um prédio, por
exemplo.
Conforme a potência e qualidade do sinal se degrada, o ponto de acesso pode diminuir a
velocidade de transmissão a fim de melhorar a confiabilidade da transmissão. A velocidade
pode cair para 5.5 megabits, 2 megabits ou chegar a apenas 1 megabit por segundo antes que
o sinal se perca completamente.
Existem três padrões diferentes de rede wireless em uso. O primeiro (e mais comum) é o
802.11b, onde a rede opera a uma taxa teórica de 11 megabits.
O seguinte é o 802.11a, que ao contrário do que o nome dá a entender, é mais recente que o
802.11b. As redes 802.11a são mais rápidas (54 megabits) e são mais resistentes a
interferências, pois operam na faixa de freqüência dos 5 GHz, ao invés dos 2.4 GHz usados no
802.11b. A desvantagem é que, pelo mesmo motivo (a freqüência mais alta), o alcance das
redes 802.11a é menor, cerca de metade que numa rede 802.11b. As placas 802.11a são
relativamente raras e, como a maioria é capaz de operar nos dois padrões, muitas delas
acabam operando a 11 megabits, juntando-se a redes 802.11b já existentes.
Finalmente, temos o 802.11g, o padrão atual. Ele junta o melhor dos dois mundos, operando
a 54 megabits, como no 802.11a e trabalhando na mesma faixa de freqüência do 802.11b (2.4
GHz), o que mantém o alcance inicial. Para que a rede funcione a 54 megabits, é necessário
que tanto o ponto de acesso, quanto todas as placas sejam 802.11g, caso contrário a rede
inteira passa a operar a 11 megabits, a fim de manter compatibilidade com as placas antigas.
Muitos pontos de acesso permitem desativar este recurso, fazendo com que as placas de 11
megabits simplesmente fiquem fora da rede, sem prejudicar o desempenho das demais.
Existem ainda as placas dual band, que são capazes de transmitir simultaneamente usando
dois canais diferentes, dobrando a taxa de transmissão. Uma placa de "108 megabits" é na
verdade uma 802.11g dual-band.
As redes wireless também são redes Ethernet e também usam o TCP/IP. Mas, além da
configuração dos endereços IP, máscara, gateway, etc., feita da mesma forma que numa rede
cabeada, temos um conjunto de parâmetros adicional.
A configuração da rede wireless é feita em duas etapas. Primeiro você precisa configurar o
ESSID, canal e (caso usada encriptação) a chave WEP ou WPA que dá acesso à rede.
O ESSID é uma espécie de nome de rede. Dois pontos de acesso, instalados na mesma área,
mas configurados com dois ESSIDs diferentes formam duas redes separadas, permitindo que a
sua rede não interfira com a do vizinho, por exemplo. Mesmo que existam várias redes na
mesma sala, indicar o ESSID permite que você se conecte à rede correta.
Em seguida temos o canal que, novamente permite que vários pontos de acesso dentro da
mesma área trabalhem sem interferir entre si. Temos um total de 16 canais (numerados de 1 a
16), mas a legislação de cada país permite o uso de apenas alguns deles. Nos EUA, por
exemplo, é permitido usar apenas do 1 ao 11 e na França apenas do 10 ao 13. Esta
configuração de país é definida na configuração do ponto de acesso.
O ESSID sozinho provê uma segurança muito fraca, pois qualquer um que soubesse o nome da
rede poderia se conectar a ele ou mesmo começar a escutar todas as conexões. Embora o
alcance normal de uma rede wireless, usando as antenas padrão das placas e pontos de
acesso normalmente não passe de 30 ou 50 metros (em ambientes fechados) usando antenas
maiores, de alto ganho e conseguindo uma rota sem obstáculos, é possível captar o sinal de
muito longe, chegando a 2 ou até mesmo 5 KM, de acordo com a potência do seu ponto de
acesso.
Como é praticamente impossível impedir que outras pessoas captem o sinal da sua rede, a
melhor solução é encriptar as informações, de forma que ela não tenha utilidade fora o círculo
autorizado a acessar a rede.
Existem atualmente três padrões de encriptação, o WEP de 64 bits, WEP de 128 bits e o WPA,
o padrão mais recente e considerado mais seguro.
Embora nenhum dos três seja livre de falhas, elas são uma camada essencial de proteção, que
evita que sua rede seja um alvo fácil. É como as portas de uma casa. Nenhuma porta é
impossível de arrombar, mas você não gostaria de morar numa casa sem portas.
Ao usar WEP, você define numa chave de 10 (WEP de 64 bits) ou 26 (WEP de 128 bits)
caracteres em hexa, onde podem ser usados números de 0 a 9 e as letras A, B, C, D, E e F.
Também é possível usar caracteres ASCII (incluindo acentuação e todo tipo de caracteres
especiais); neste caso as chaves terão respectivamente 5 e 13 caracteres.
A regra básica é que os micros precisam possuir a chave correta para se associarem ao ponto
de acesso e acessarem a rede. Em geral os pontos de acesso permitem que você especifique
várias chaves diferentes, de forma que cada micro pode usar uma diferente.

Acesso Remoto

Muitos dispositivos, como por exemplo modems ADSL, pequenos servidores de impressão,
roteadores, etc. possuem várias opções de configuração; muitas vezes rodam o Linux ou outro
sistema operacional completo, mas não possuem nem teclado nem monitor.
Nestes casos toda a configuração é feita remotamente, através de algum utilitário de
configuração. O mais comum é o uso de alguma interface http, que você acessa de qualquer
micro da rede local usando o navegador, ou então o uso do ssh ou telnet.
Eu, por exemplo, uso um modem ADSL Parks 600, que pode ser configurado como roteador ou
bridge, através de uma interface de administração simples, que acesso via telnet, a partir de
qualquer micro da rede.
O telnet é um protocolo primitivo que permite rodar comandos remotamente através de uma
interface de modo texto. Existem clientes telnet para vários sistemas operacionais. Tanto no
Linux quanto no Windows, você acessa uma máquina remotamente via telnet usando o
comando "telnet" seguido do endereço IP destino, como em:
$ telnet 192.168.0.1

O grande problema é que o telnet não oferece nenhum tipo de segurança. Todas as
informações, incluindo as senhas são transmitidas em texto puro, de forma legível pela rede e
são fáceis de interceptar. É como se você fizesse suas transações bancárias gritando pela
janela.
O ssh já é mais evoluído. Ele utiliza um sistema de criptografia bastante seguro para proteger
os dados. Alguém pode interceptar as informações, afinal a internet é uma rede pública, mas
os dados capturados não terão utilidade nenhuma. O ssh é a opção mais usada para
administrar servidores remotamente.
Hoje em dia poucas empresas hospedam seus websites "in house" ou seja, em servidores
instalados dentro da própria empresa. Quase sempre os servidores ficam hospedados em data
centers, complexos que oferecem toda a estrutura necessária para que os servidores fiquem
no ar de forma confiável, incluindo links redundantes (se o link principal cai, existe um
segundo de reserva), nobreaks de grande porte, geradores, refrigeração (a temperatura
ambiente mais baixa ajuda os componentes a trabalhar de forma mais estável) e assim por
diante.
Isto significa que, apesar do servidor ser "seu", você não tem nenhum tipo de acesso físico a
ele. Não pode usar o teclado ou mouse por exemplo, tudo precisa ser feito a distância.
No Linux, toda a configuração do sistema, instalação de novos programas, etc. pode ser feita a
partir do modo texto, o que permite configurar o servidor e mantê-lo atualizado remotamente,
via ssh. Outro ponto interessante é que apesar de ser nativo do Unix, existem clientes ssh
também para Windows e outras plataformas, permitindo que o responsável administre o
servidor a partir de uma estação Windows, por exemplo.
Outra possibilidade interessante para o ssh é suporte a distância. Você pode se conectar no
micro de um amigo para corrigir algum problema, por exemplo.
Para acessar uma máquina remotamente via ssh, você deve informar o login que você usará
para se conectar, seguido do IP da máquina, que pode estar tanto na rede local quanto na
internet. Se o seu amigo criou o login "suporte" para que você acesse o micro dele
remotamente e o IP é 200.221.34.32, o comando seria:
$ ssh suporte@200.221.34.32
O ssh pede a senha (tudo feito através da conexão segura) e depois você já vê o prompt da
outra máquina:

Embora o uso mais comum seja rodar comandos de modo texto, o ssh também permite rodar
aplicativos gráficos. Se você estiver se conectando a partir do Linux, geralmente não precisará
fazer nada além de chamar o programa pelo nome, como em:
$ konqueror
O programa roda no servidor, mas a imagem é exibida no seu monitor:

Este recurso de rodar aplicativos gráficos remotamente é mais útil dentro de uma rede local,
pois consome muita banda, deixando as respostas lentas se você acessa via modem, por
exemplo.
Outro programa interessante para acessar outros micros remotamente é o VNC . Ele permite
ver uma extensão do desktop da outra máquina, incluindo o KDE ou outra interface gráfica. O
VNC é dividido em dois módulos, um cliente e um servidor. O servidor VNC é instalado na
máquina que será acessada remotamente, enquanto as que vão acessar precisam apenas do
cliente, um programa pequeno que já vem pré-instalado na maioria das distribuições. Os dois
estão disponíveis tanto para Linux quanto para Windows, de forma que você pode acessar um
micro com o Windows a partir do Kurumin ou vice-versa.
Finalmente, temos as interfaces de administração via web. Como disse, elas são usadas por
muitos modems ADSL (são mais fáceis de usar que a interface de modo texto do meu Parks) e
também por programas de configuração destinados a servidores Linux, como o Swat e o
Webmin.
O Swat permite configurar o Samba, usado para compartilhar arquivos com máquinas
Windows, enquanto o Webmin é uma ferramenta completa, que permite configurar vários
servidores diferentes. Caso instalados no servidor, ambos podem ser acessados a partir de
outro micro da rede local, ou até mesmo via internet, usando o navegador:
O Kernel e as distribuições Linux

Nas reportagens sobre o Linux você lerá muito sobre Linus Torvalds, o criador do Kernel do
Linux. Ele (o Kernel) é a peça fundamental do sistema, responsável por prover a infra-
estrutura básica para os programas funcionarem. O Kernel é algo comum em todas as
diferentes distribuições; muda a versão, mas o Kernel do Linus está sempre ali.
O Kernel é o responsável por dar suporte aos mais diferentes periféricos: placas de rede, som,
e o que mais você tiver espetado no micro. Uma nova versão sempre traz suporte a muita
coisa nova, o que faz diferença principalmente para quem pretende trocar de PC em breve ou
está de olho em algum handheld ou mp3player exótico. É por isso que o lançamento de uma
atualização importante, como o Kernel 2.6, é sempre tão comemorado.
Mas, apesar de toda a sua importância, o grande objetivo dos desenvolvedores é que o Kernel
seja invisível. Ele deve simplesmente fazer seu trabalho sem que você precise se preocupar
com ele. Você só se dá conta que o Kernel existe quando algo não funciona, de forma que
quanto menos você notá-lo melhor, sinal de que as coisas estão funcionando bem... :-).
Uma distribuição Linux é como uma receita, ao invés de ficar compilando o Kernel e os
programas como faziam os pioneiros, você simplesmente instala um conjunto que uma equipe
desenvolveu e disponibilizou. O bom dos softwares é que uma vez criados eles podem ser
distribuídos quase sem custo. Ao contrário de um objeto material, que se quebra ao ser
dividido, quanto mais pessoas copiarem e usarem sua distribuição melhor: seu trabalho terá
mais reconhecimento e apoio.
Alguns exemplos de distribuições são o Debian, Mandriva, Fedora, SuSE, Slackware e Gentoo.
Qualquer pessoa ou empresa com tempo e conhecimentos suficientes pode desenvolver uma
distribuição. O mais comum é usar uma distribuição já existente como ponto de partida e ir
incluindo novos recursos a partir daí. No mundo open-source não é preciso reinventar a roda,
os trabalhos anteriores são respeitados e reutilizados, aumentando radicalmente a velocidade
de desenvolvimento de novos projetos.
A distribuição mais antiga, ainda ativa é o Slackware, que em julho de 2006 completou 13
anos. O Slackware é uma das distribuições mais espartanas, que tem como objetivo preservar
a tradição dos sistemas Unix, provendo um sistema estável, organizado, mas com poucas
ferramentas automatizadas, que te obriga a estudar e ir mais a fundo na estrutura do sistema
para conseguir usar. Muita gente usa o Slackware como ferramenta de aprendizado, encarando
os problemas e deficiências como um estímulo para aprender.
Pouco depois, em novembro de 1994, foi lançado o Red Hat, que foi desenvolvido com o
objetivo de facilitar a configuração e automatização do sistema, incluindo várias ferramentas
de configuração. Apesar de sua alma comercial, todas as ferramentas desenvolvidas pela
equipe do Red Hat tinham seu código aberto, o que possibilitou o surgimento de muitas outras
distribuições derivadas dele, incluindo o Mandrake (França) e o Conectiva (Brasil). Devido à
sua origem comum, estas distribuições preservam muitas semelhanças até hoje, sobretudo na
estrutura do sistema e localização dos arquivos de configuração.
A partir de 2003, a Red Hat mudou seu foco, concentrando seus esforços no público
empresarial, desenvolvendo o Red Hat Enterprise e vendendo pacotes com o sistema, suporte
e atualizações.
O Red Hat Desktop foi descontinuado em 2004, pouco depois do lançamento o Red Hat 9. A
partir daí, passou a ser desenvolvido o Fedora combinando os esforços de parte da equipe da
Red Hat e vários voluntários que, com a maior abertura, passaram a contribuir com melhorias,
documentações e suporte comunitário nos fóruns. O Fedora herdou a maior parte dos usuários
do Red Hat Desktop e é atualmente uma das distribuições mais usadas.
O Mandrake começou de uma forma modesta, como uma versão modificada do Red Hat,
lançada em julho de 1998, cuja principal modificação foi a inclusão do KDE (ainda na versão
1.0). O Mandrake conquistou rapidamente um número relativamente grande de usuários e
passou a ser desenvolvido de forma independente, com foco na facilidade de uso. Em 2005
aconteceu a fusão entre o Mandrake e o Conectiva, que deu origem ao atual Mandriva, que
passou a ser desenvolvido combinando os esforços dos desenvolvedores das duas
distribuições.
A história do SuSE é um pouco mais complicada. As primeiras versões foram baseadas no SLS,
uma das primeiras distribuições Linux que se têm notícia. Em 1995 os scripts e ferramentas
foram migrados para o Jurix, que por sua vez era baseado no Slackware. A partir a versão 5.0,
lançada em 1998, o SuSE passou a utilizar pacotes RPM, o formato do Red Hat e passou a
incorporar características e ferramentas derivadas dele. Todas estas ferramentas foram
integradas no Yast, um painel de controle central que facilita bastante a administração do
sistema.
Devido a todas estas mudanças, o SuSE é difícil de catalogar, mas atualmente o sistema possui
muito mais semelhanças com o Fedora e o Mandriva do que com o Slackware, por isso é mais
acertado colocá-lo dentro da família Red Hat.
Em 2003, a SuSE foi adquirida pela Novell, dando origem ao Novell Desktop (uma solução
comercial) e ao OpenSuSE, um projeto comunitário, que usa uma estrutura organizacional
inspirada no exemplo do Fedora.
Finalmente, temos o Debian, cuja primeira versão oficial (chamada Buzz) foi lançada em
1996. O Debian deu origem a uma grande linhagem de distribuições, que incluem de produtos
comerciais, como o Linspire e o Xandros a projetos comunitários, como o Ubuntu, Knoppix,
Mephis e o próprio Kurumin.
As principais características do Debian são a grande quantidade de pacotes disponíveis
(atualmente, quase 25 mil, se incluídas as fontes não oficiais) e o apt-get, um gerenciador de
pacotes que permite baixar, instalar, atualizar e remover os pacotes de forma automática.
O Debian utiliza um sistema de desenvolvimento contínuo, onde são desenvolvidas
simultaneamente 3 versões, chamadas de Stable (estável), Testing (teste) e Unstable
(instável). A versão estável é o release oficial, que tem suporte e atualizações de segurança
freqüentes. A versão estável atual é o Sarge (3.1), lançado em junho de 2005; antes dele veio
o Woody (3.0), lançado em julho de 2002 e o Potato (2.2), lançado em agosto de 2000. O
lançamento da próxima versão estável (batizada de Etch), está planejada para o final de 2006.
Apesar do longo intervalo entre os lançamentos das versões estáveis, os pacotes ficam
congelados, recebendo apenas correções de segurança. Isso faz com que os pacotes do Stable
fiquem rapidamente defasados em relação a outras distribuições. Para solucionar este
problema, existe a opção de usar o Testing, composto de pacotes recentes porém menos
testados e, como última opção, existe o Unstable, que é a porta de entrada para as últimas
versões e por isso sujeito a mais problemas. Em algumas épocas, o uso do Unstable é
impraticável, pois muitas alterações são feitas simultaneamente, fazendo com que muitos
pacotes fiquem quebrados e apareçam problemas diversos.
Tipicamente, os pacotes começam no Unstable, onde recebem uma primeira rodada de testes.
Depois de algumas semanas, são movidos para o Testing. Periodicamente, os pacotes no
Testing são congelados, dando origem a uma nova versão estável. Além destes, existe o
Experimental, usado como um laboratório para a inclusão de novos pacotes.
O Debian em si é bastante espartano em termos de ferramentas de configuração e por isso
reservado a usuários mais avançados. Porém, muitas distribuições derivadas dele, como
Ubuntu, o Mepis e o Kurumin, são desenvolvidas com foco na facilidade de uso e incluem
muitas ferramentas e assistentes de configuração.
Você pode ver uma tabela mais completa com as origens de cada distribuição neste link do
Distrowatch:
http://distrowatch.com/dwres.php?resource=independence
Veja que dentre as distribuições cadastradas no site, a grande maioria é baseada no Debian
(129) ou no Knoppix (50). Naturalmente, as distribuições baseadas no Knoppix também são
indiretamente derivadas do Debian e, de fato, muitas distribuições são incluídas dentro das
duas categorias.
Em seguida temos as distribuições derivadas do Fedora (63), do Slackware (28) e do Mandriva
(14). Até o Kurumin já entrou na lista, com 5 filhos.

Os live-CDs

Tradicionalmente, qualquer sistema operacional precisa ser instalado no HD antes de ser

usado. Você dá boot usando o CD ou DVD de instalação e é aberto um sistema compacto, que
roda o instalador e se encarrega de instalar e configurar o sistema principal. Depois de algum
tempo respondendo perguntas e vendo a barra de progresso da cópia dos arquivos, você
reinicia o micro e pode finalmente começar a usar o sistema. Isso é válido tanto para o
Windows quanto para a maior parte das distribuições Linux.
Os live-CDs são distribuições Linux que rodam diretamente a partir do CD-ROM, sem
necessidade de instalar. Um dos pioneiros nesta área é o Knoppix (derivado do Debian), que
até hoje é um dos live-CDs de maior sucesso. O Kurumin é um descendente direto dele,
desenvolvido com base no Knoppix 3.1 (a versão mais recente no início de 2003) e
desenvolvido de forma mais ou menos autônoma a partir daí, utilizando como base os pacotes
do Debian, combinados com atualizações provenientes do Knoppix e várias outras
distribuições, além de um conjunto de scripts e ferramentas de configuração próprias,
centralizadas na forma do Clica-aki.
Para quem já se acostumou com a idéia, pode parecer natural rodar o sistema a partir do CD e
até mesmo instalar novos programas, sem precisar modificar as informações salvas no HD,
mas o aparecimento do Knoppix foi um verdadeiro marco dentro do mundo Linux.
A base de tudo é um módulo de Kernel chamado cloop, um hack que permite que o sistema
rode a partir de um sistema de arquivos compactado, gravado no CD-ROM. Os dados são
descompactados "on-the-fly", conforme são necessários. É algo que funciona de forma similar
às partições compactadas pelo smartdrive no Windows 95/98 (ainda lembrado pelos
saudosistas :), mas com um desempenho melhor e otimizado para CD-ROMs.
Graças à compressão, uma distribuição como o Kurumin pode incluir cerca de 1.2 GB de
programas, em uma imagem com pouco mais de 400 MB. Além de reduzir o tamanho do
sistema, comprimir os arquivos melhora também a taxa de transferência do CD-ROM,
diminuindo a perda de desempenho causado pela baixa taxa de leitura.
A idéia é que um CD-ROM de 40X é capaz de ler a em média 4 MB/s, pois como o CD gira
sempre na mesma velocidade, as informações gravadas nas trilhas da parte externa do CD
(mais longas), são lidas a mais ou menos o dobro da velocidade das do centro (que são mais
curtas). Um CD-ROM de 40x lê a 6 MB/s nas trilhas externas mas a apenas 3 MB/s nas
internas. Como o CD-ROM é gravado a partir do centro, na maior parte do tempo ele lê os
dados a 3, 4 ou 5 MB/s.
Mas, ao ler 4 MB/s de dados compactados a uma razão de 3x, ele estará lendo na prática a
quase 12 MB/s, quase a mesma taxa de transferência de um HD de meia década atrás.
Naturalmente ainda existem outros problemas, como o tempo de busca, que é muito mais alto
num CD-ROM, mas o problema principal é bastante amenizado.
Se não fosse o sistema de compressão, os live-CDs descendentes do Knoppix seriam três
vezes maiores e três vezes mais lentos ao rodar do CD, o que os tornariam sistemas muito
menos atrativos.
Em contrapartida, o trabalho do processador passa a ser maior, pois, além de processar os
dados referentes aos programas, ele tem que ao mesmo tempo descompactar os dados lidos
pelo CD-ROM. Por isso, mais do que em outras distribuições, o desempenho (ao rodar do CD)
aumenta de acordo com o poder de processamento da máquina. Numa máquina lenta, um
Pentium II 300, por exemplo, o desempenho é cerca de 50% menor do que seria ao rodar uma
distribuição instalada no HD, enquanto num Athlon XP ou Pentium 4 a diferença já é muito
menor.
A primeira etapa do boot é a tela de boas-vindas e uma linha onde você pode fornecer
parâmetros para o boot. Logo depois é carregado o Kernel, que por sua vez inicializa o
hardware, cria um ramdisk usando uma parte (pequena) da memória RAM onde são
armazenados arquivos de configuração e outros dados que precisam ser alterados durante o
uso. Depois disso entra em ação o hwsetup, o programa de detecção que se encarrega de
detectar a placa de vídeo, som, rede, modem e outros periféricos suportados, desenvolvido por
Klaus Knopper com base no Kudzu do Red Hat.

Este trabalho de detecção é justamente o grande trunfo. Em poucos segundos o sistema é

capaz de detectar, configurar e ativar todos os periféricos suportados na máquina, baseado nos
códigos de identificação dos dispositivos, sem nenhuma intervenção do usuário.
Claro, sempre existem casos de problemas. Algumas placas-mãe travam durante a detecção
do ACPI, alguns notebooks travam durante a etapa inicial, onde o sistema procura por placas
SCSI e assim por diante. Mas na grande maioria dos casos estes problemas podem ser
resolvidos desativando as partes da detecção que causam problemas, usando opções de boot.
Durante o boot ele tenta sempre configurar automaticamente a rede, obtendo o IP e outros
dados a partir de um servidor DHCP disponível na rede. Se a máquina acessar a internet
através de uma conexão compartilhada dentro da rede local ou através de um modem ADSL
configurado como roteador, ele já será capaz de acessar a web logo após o boot, caso contrário
você pode configurar a rede manualmente.
Uma questão importante ao usar qualquer live-CD é a questão da memória RAM. Como o
sistema por padrão não utiliza as partições do HD, tudo é feito usando a memória RAM,
incluindo a instalação de novos programas. O ramdisk que é criado durante o boot vai
crescendo conforme são feitas modificações. Em micros com pouca RAM você verá uma
mensagem de "disco cheio" (quando na verdade o que acabou foi o espaço no ramdisk), ou até
mesmo efeitos diversos por falta de memória RAM disponível.
A instalação de novos programas é possibilitada pelo UnionFS, mais um hack que monitora
tentativas de alterações nos arquivos do CD (originalmente impossíveis, já que o CD é
somente-leitura) e engana os programas, fazendo-as no ramdisk, permitindo que você altere
arquivos e instale novos programas, mesmo ao rodar o sistema a partir do CD. Este recurso
está disponível a partir do Knoppix 3.8 e do Kurumin 5.0.
A configuração mínima para rodar o Kurumin é um Pentium II com 128 MB de RAM. Para o
Knoppix ou outras distribuições, os requisitos variam de 128 a 256 MB. Para usar o apt-get e
instalar novos programas (UnionFS), você precisa ter 512 MB de RAM.
Para poder abrir vários programas simultaneamente e para melhorar o desempenho geral do
sistema, é recomendável ter disponível uma partição swap, que pode ser criada usando o
gparted, cfdisk, ou outro programa de particionamento. Muitas distribuições criam uma
partição swap automaticamente ao serem instaladas.
A memória swap (ou memória virtual) é um recurso usado por todos os sistemas
operacionais atuais quando não existe memória RAM suficiente. Ele passa a armazenar os
dados que não "cabem" na memória num arquivo ou partição swap criada no HD. É o uso da
memória swap que permite que o sistema continue funcionando, mesmo quando não existe
memória RAM suficiente.
Como não é possível fazer memória swap no CD-ROM, o sistema é capaz de detectar e montar
automaticamente partições de memória swap de outras distribuições Linux. Caso você tenha
apenas o Windows instalado, ele tentará em último caso criar um arquivo de swap dentro da
partição do Windows, mas isto só é possível se o HD estiver formatado em FAT32 (o sistema
de arquivos usado pelo Windows 98). Por enquanto ainda não é possível fazer isso em
partições NTFS do Windows XP.
Ou seja, para rodar o Kurumin em micros com pouca memória RAM, você deve
preferencialmente usar um programa de particionamento qualquer para criar uma partição
Linux swap ou pelo menos certificar-se de que o HD está formatado em FAT32 e não em NTFS,
caso contrário ele não terá para onde correr quando a memória RAM acabar ;-).
Além do Knoppix e do Kurumin, existem muitos outros live-CDs, tanto baseados no Debian
quanto baseados em outras distribuições, como o Slax (baseado no Slackware) e o PcLinuxOS
(baseado no Mandriva).

Como baixar, gravar e dar boot

A forma mais popular de disponibilizar novas versões das distribuições é através de arquivos
ISO, cópias binárias do conteúdo dos CDs ou DVD de instalação, que você pode gravar usando
o Nero, K3B ou outro programa de gravação, obtendo um CD idêntico ao original.
Gravar um arquivo ISO é diferente de gravar um arquivo qualquer no CD. Um arquivo ISO é
uma imagem binária que deve ser copiada bit a bit no CD-ROM, e não simplesmente
adicionado dentro de uma nova seção. Todos os bons programas de gravação suportam a
gravação de arquivos ISO, veja como gravar o arquivo usando alguns programas populares.
Ao usar o Easy CD Creator, abra o Easy CD Creator e clique em "File > Menu > Record CD
from CD Image". Aponte o arquivo que será gravado. Marque a opção "ISO Image Files
(*.iso)" na janela de navegação e clique em "Start Recording" para gravar o CD.
No Nero Burning Rom, clique em File > Burn Image, aponte o arquivo que será gravado e
clique em "Write" para gravar o CD.
Ao usar o K3B (no Linux), clique em Ferramentas > Gravar Imagem ISO (ou Queimar imagem
de CD), aponte o arquivo, escolha a velocidade de gravação e clique em "Gravar".
Depois de gravado o CD, o próximo passo é configurar o setup da placa-mãe para dar boot
através do CD-ROM. A maioria dos micros vem configurados para dar boot preferencialmente
através do CD-ROM. Neste caso basta deixar o CD na bandeja e você já cai na tela de boas
vindas do sistema. Se não for o seu caso, pressione a tecla DEL durante o teste de memória
para entrar no Setup.
Procure pela seção "Boot " e coloque o CD-ROM como dispositivo primário. Tudo pronto, agora
é só salvar a configuração acessando o menu exit, escolhendo a opção "Save & Exit setup".

Ao reiniciar o micro sem o CD no drive, ele volta a carregar o Windows ou outro sistema que
estiver instalado no HD. Esta alteração apenas faz com que ele passe a procurar primeiro no
CD-ROM.
Um hábito saudável é verificar a integridade do arquivo .ISO antes de gravar o CD. Sempre é
possível que o arquivo esteja incompleto, ou venha corrompido, seja por problemas com a
conexão ou no gerenciador de download usado. Você pode detectar este tipo de problema (e
evitar gastar mídias à toa), verificando o MD5SUM do arquivo, um teste que soma todos os
bits do arquivo e devolve uma "assinatura", um código de 32 dígitos que permite detectar
qualquer mudança no arquivo.
Os códigos de assinatura dos arquivos estão quase sempre disponíveis na página de download,
como em:
11479ced7eea505506b5a3314d33ee70 kurumin-5.0.iso
Você precisa apenas rodar o MD5SUM no arquivo baixado e ver se o resultado é igual ao
número da página. No Linux (qualquer distribuição), acesse a pasta onde o arquivo foi baixado
e digite:
$ md5sum kurumin-5.0.iso
Se o número retornado for igual, você pode gravar a imagem sem medo, o arquivo está ok.
Caso o número seja diferente, então o arquivo chegou corrompido ou incompleto. Uma dica
nesta caso é que é possível corrigir arquivos corrompidos usando o bittorrent (se o arquivo
estiver disponível para download através dele). Para isso, baixe o arquivo .torrent para a
mesma pasta do arquivo corrompido e inicie o download. O bittorrent usa um algoritmo próprio
para verificar cada pedaço do arquivo, descartando os pedaços corrompidos. Isso permite que
ele baixe novamente apenas os pedaços corrompidos, sem precisar baixar novamente todo o
arquivo.
No Windows baixe o programa disponível no http://www.md5summer.org/download.html. Ele é
gráfico, até mais fácil de usar que a versão Linux.
Uma última dica é com relação aos famosos "Cloop Errors", erros de leitura que aparecem ao
tentar rodar qualquer live-CD (que usa o módulo cloop para compactar os dados) a partir de
uma mídia ruim. O cloop possui um sistema próprio para verificar as integridade dos dados no
CD, detectando e avisando sobre os erros de leitura.
Nestes casos você verá vários "CLOOP READ erros" durante o boot, que indicam justamente
que o sistema não está conseguindo ler os dados corretamente. Veja um exemplo:
CLOOP READ ERROR:AT POS 5233960 IN FILE/CDROM/KNOPPIX/KNOPPIX
CLOOP:ERROR-3 UNCOMPRESSING BLOCK 46065536/0/23207/05233960-
I/O ERROR DEV OB:00, SECTOR 17212 LINUXRC CANNOT CREAT/VAN/RUN/VTMP.DIRECTORY NOEXISTENT

Os cloop erros podem ser causados por três fatores:

a) O arquivo baixado está incompleto ou corrompido.
b) O CD ou CD-RW está riscado/danificado e o sistema não está conseguindo ler os dados
corretamente (o mais comum). Os CD-RW dão esse tipo de problema mais freqüentemente,
pois o índice de refração luminosa da mídia é mais baixa e a superfície de gravação mais frágil,
facilitando o aparecimento de problemas de leitura.
c) O próprio leitor CD-ROM ou o cabo IDE podem estar com problemas e por isso os dados não
estão sendo lidos corretamente, embora a mídia esteja em bom estado.
Os CLOOP ERRORS são sempre causados direta ou indiretamente por um destes três fatores;
problemas com o CD ou com o hardware do seu micro e não por problemas do software. O
sistema pode apresentar outros tipos de problemas na sua máquina, como travar durante a
detecção de algum componente, mas este erro específico é justamente um aviso de problemas
com a leitura dos dados.
Em muitos casos, o sistema roda normalmente a partir do CD, mas apresenta problemas
estranhos ao ser instalado (o modo gráfico não abre, alguns aplicativos não funcionam,
mensagens de erro diversas reclamando da falta de aplicativos ou bibliotecas, etc.), causados
por problemas de leitura durante a instalação.
Prefira usar mídias CDR normais e depois doar suas cópias antigas para amigos que ainda não
conheçam o sistema, assim você estará evitando dor de cabeça e ainda fazendo uma boa ação
:).
Linguagens de programação

Os computadores são funcionários quase perfeitos. Fazem tudo o que mandamos, não
reclamam, não se importam de trabalhar até tarde da noite, não cobram hora extra nem tiram
férias. Mas, em compensação, também não pensam. Para que façam qualquer coisa é preciso
explicar tudo com os mínimos detalhes e na língua deles.
Considerando que tudo o que os computadores conseguem entender são seqüências
intermináveis de números binários, fornecer estas "instruções" pode ser muito penoso para um
ser humano. Você consegue se imaginar lendo um manual de 5.000 páginas e decorando um a
um centenas de códigos binários que representam as instruções do processador?
Se os programadores precisassem programar diretamente em binários, decorando seqüências
como 10111011101101101110110011001010 para cada instrução do processador e para cada
endereço de memória a ser acessado, provavelmente não teríamos mais programadores; já
estariam todos loucos.
Para facilitar as coisas, começaram a ser desenvolvidas as linguagens de programação, que
diferem na sintaxe e recursos, mas têm um ponto em comum, que é a existência de um
compilador. Seja programando em C, ou seja em Kylix, você usará um editor para escrever
seu programa, respeitando as regras da linguagem escolhida e em seguida rodará o
compilador, que interpretará os comandos que formam o seu programa e os transformará em
um arquivo binário, que contém as instruções binárias que são entendidas pelo processador.
No Windows não temos muito contato com código fonte, pois os programas são quase sempre
distribuídos apenas em formato binário, que você não tem como alterar. Mas, no caso do
Linux, temos a possibilidade de baixar o código fonte de praticamente todos os programas que
usamos no dia-a-dia. Muita gente aprende a programar fuçando no código fonte de algum
programa que conhece bem, começando com pequenas traduções e mudanças, e acaba
entendendo bem a sintaxe da linguagem e vários dos truques usados. Depois de cada rodada
de alterações, é possível compilar todo o código, abrir o programa e verificar de que forma elas
alteraram o programa final.
A vantagem de usar linguagens de programação é que o desenvolvedor passa a trabalhar com
instruções como "if", "else", etc. além de todas as facilidades oferecidas pela linguagem ao
invés de gigantescos endereços binários. Sem dúvida muito mais simples.
Existem diversas linguagens de programação. Meu objetivo aqui é dar algumas noções básicas
sobre as peculiaridades e utilidade de algumas delas
Para começar, existe uma linguagem "básica" para quem quer aprender a programar, ensinada
nos cursos de lógica da programação, o pseudocódigo. Ele não é uma linguagem "de verdade",
mas sim uma maneira mais simples para aprender os fundamentos usados em todas as
linguagens de programação.
Podemos começar com um exemplo simples. Vamos fazer um programa capaz de tomar uma
decisão fácil. Ele pergunta a nota do aluno e diz se ele passou ou não. Para um ser humano
isso seria um problema muito elementar, mas para o computador as coisas não são assim tão
simples. Lembre-se de que ele é burro e precisa ser orientado passo a passo. Nosso
programinha em pseudocódigo poderia ficar assim:
escreva: "Qual é a nota do aluno?"
leia nota
se nota maior ou igual a sete
então:
escreva "Ele passou"
senão:
escreva: "Ele foi reprovado"
fim do se
fim do programa
Este programinha perguntaria a nota e, com base no número que for digitado, avisaria se o
aluno passou ou não.
Ele poderia ser escrito em qualquer linguagem, mas a lógica seria a mesma. De acordo com os
recursos oferecidos pela linguagem escolhida, ele poderia ter uma interface simples em modo
texto, uma interface gráfica mais trabalhada, aparecer no meio de uma pagina web e assim
por diante. O mesmo programinha escrito em shell script, a linguagem mais elementar que
temos no Linux, onde utilizamos comandos de terminal, poderia ficar assim:
echo "Qual é a nota do aluno"
read nota
if [ "$nota" -ge "7" ]
then
echo "Ele passou"
else
echo "Ele foi reprovado"
fi
As linguagens de programação são conjuntos de padrões e comandos que você pode usar para
dar ordens para nossos amigos burros.
Assim como nas línguas faladas, existem diferenças de sintaxe, gramática e existem
linguagens mais simples ou mais complicadas de aprender e linguagens mais adequadas para
cada tipo de tarefa a realizar. Veja alguns exemplos de linguagens de programação:

- Assembly: O Assembly foi provavelmente a primeira linguagem de programação da história,

surgida na década de 50, época em que os computadores ainda usavam válvulas. A idéia do
Assembly é usar um comando em substituição a cada instrução de máquina.
No Assembly, cada uma destas instruções equivale a uma instrução do processador. Ao invés
de usar instruções como 10101011, você pode usar outras bem mais fáceis de entender e de
memorizar, como add, div, mul, and, or, not, etc. Você também pode criar variáveis, que são
pequenos espaços na memória RAM reservados para guardar algum tipo de informação, que o
programa precisará mais tarde. Você pode usar aquelas instruções que citei para lidar com
elas. Por exemplo, a instrução "add" faz com que o processador some duas variáveis; "add x,
y" por exemplo, soma os valores de x e y.
Apesar de ser exaustivamente trabalhoso, você pode perfeitamente desenvolver pequenos
programas em Assembly. Para isso só vai precisar de um compilador e bastante paciência para
aprender. O compilador transforma o código escrito em Assembly em linguagem de máquina,
que finalmente poderá ser entendida pelo processador.
Existem também os decompiladores, que fazem o trabalho inverso, de transformar um
programa já compilado em código Assembly. Este recurso é chamado de engenharia reversa. É
assim que conseguem crackear programas, quebrar códigos de proteção (como o do DVD),
etc. Claro que para isso, é preciso alguém que conheça muito de Assembly e que tenha
disposição para ficar estudando o código até encontrar o que procura.
Por causa desta característica de permitir trabalhar diretamente com as instruções do
processador, o Assembly é uma linguagem de baixo nível. Existem também linguagens de alto
nível, como C++ ou Pascal, onde é possível usar várias funções já prontas ou mesmo
ferramentas visuais, como o Kdeveloper ou o Kylix, que são ainda mais fáceis.
Em se tratando de programação, o fato de uma linguagem ser "de baixo nível", não significa
que ela é ruim, mas apenas que ela manipula diretamente as instruções e endereços de
memória e, por isso, é mais trabalhosa e voltada para o desenvolvimento de aplicativos
otimizados.

- Fortran: O Fortran foi uma das primeiras linguagens de alto nível da história. Enquanto o
Assembly é chamado de linguagem de baixo nível, por nele utilizarmos diretamente as
instruções e endereços do processador e memória, numa linguagem de alto nível temos várias
funções prontas, o que facilita muito a programação, mas em compensação torna em muitos
casos o programa maior e mais pesado, já que o compilador jamais conseguirá gerar um
código tão otimizado quanto um programador experiente conseguiria.
Fortran é a contração de "Formula Translator". A primeira versão do Fortran foi criada no final
da década de 50, mas a linguagem começou a ser usada em larga escala a partir da metade
da década de 60, quando surgiram várias versões diferentes. Atualmente o Fortran é pouco
usado, mas é ainda ensinado em várias universidades, como uma forma mais prática de
ensinar lógica da programação.

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

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

- C: O C foi desenvolvido durante a década de 70, mas ainda é largamente utilizado. A grande
vantagem do C é permitir escrever tanto programas extremamente otimizados para a
máquina, como seria possível apenas em Assembly, e ao mesmo tempo vir com várias funções
prontas, como uma linguagem de alto nível, que podem ser utilizadas quando não for
necessário gerar um código tão otimizado.
A maior parte dos programas Linux e quase todo o Kernel foram escritos em C, o que explica o
porquê do sistema ser tão rápido em algumas tarefas.

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

- Python: O Python é uma linguagem de programação com uma sintaxe muito simples e
intuitiva e ao mesmo tempo bastante poderosa, que pode ser usada por toda classe de
usuários. É uma boa opção de linguagem para quem está começando a programar. No
Kurumin, você pode abrir o interpretador do Python em Iniciar > Sistema > Desenvolvimento.
A maior parte das distribuições instalam o Python por default. Basta abrir um terminal e
chamar o comando "python". Existe também uma versão for Windows que pode ser baixada
no: http://www.python.org/download/. Ao abrir um programa, você verá um prompt como
este:

Este é o interpretador do Python, um prompt onde você pode digitar um comando de cada vez
e já ir vendo os resultados. Bom para ir testando os comandos enquanto você não quiser
realmente desenvolver nenhum programa completo.
Vamos começar com uma coisa simples. Que tal ouvir um bom dia? Para isso podemos usar o
"print" que é o comando para escrever coisas na tela. Este comando é simples de usar, basta
escrever a frase entre aspas: print "Bom Dia!".
E você terá um:

Podemos personalizar um pouco isto, fazendo com que ele primeiro pergunte o seu nome e
depois dê bom dia. Para isso, podemos usar o comando "raw_input", que lê texto digitado no
teclado. Este texto precisa ser guardado em algum lugar, para armazená-lo usamos uma
variável, que é um pequeno espaço de memória reservado e que pode ser usado mais tarde.
Experimente usar a linha abaixo:
nome = raw_input("Olá, qual é o seu nome? ")
Isso faz com que ele pergunte o seu nome e fique esperando você digitar alguma coisa e dar
Enter. Em seguida ele armazena o texto digitado na variável "nome" e volta para o prompt. O
texto entre aspas pode ser substituído por outra coisa se quiser.
Como disse, a variável armazena dados que podem ser usados mais tarde. Como agora já
temos o seu nome armazenado na variável "nome", podemos completar nosso bom dia,
fazendo com que ele escreva junto o seu nome (ou o que for que você tenha digitado no passo
anterior :-):
print "Bom dia", nome
Ele escreve a frase "Bom Dia" que está entre aspas e em seguida completa com o texto
armazenado na variável "nome". Não se esqueça da vírgula, ela indica que além de escrever o
texto armazenado na variável, o interpretador deve adicionar a palavra "nome" em seguida.

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

Este arquivo pode ser executado usando o interpretador do Python. Para isso, abra um
terminal e chame o comando:
$ python programa.py
O programa vai fazer o mesmo que no prompt do Python, a diferença é que agora ele executa
os comandos escritos no arquivo de texto ao invés de ir perguntando.
Podemos agora fazer algo usando uma instrução de tomada de decisão. Que tal perguntar a
idade e com base nela decidir qual será a próxima frase do diálogo? Se o interlocutor
responder que menos de 18 anos, ele pode receber um "Beleza, tem aula hoje?" e se tiver 18
ou mais recebe um "Ei, você não vai trabalhar hoje?".
Para isso precisamos começar perguntando a idade. De volta ao nosso editor de textos
acrescentamos ao que já tínhamos feito:
idade = input("Quantos anos você tem? ")
Veja que mudamos o "raw_input" para apenas "input". A diferença entre os dois é que o
raw_input pode ser qualquer tipo de dados (letras, números, binários), enquanto o "input"
serve para armazenar números.
Agora chegamos à parte mais importante, que é fazer o programa descobrir se o número
digitado é maior ou menor que 18 e depois decidir qual frase deve escrever. Para isso, vamos
usar a instrução "if" (se) que tem sua companheira inseparável, a "elif" (então se). Funciona
assim:
if idade < 18:
print "Beleza, tem aula hoje?"
elif idade >= 18:
print "Ei, você não vai trabalhar hoje?"
Parece complicado à primeira vista, mas não é. O primeiro if verifica se o número é menor (<)
que 18. Caso seja, ele escreve o "Beleza, tem aula hoje?" e o programa acaba.
Caso o número seja maior que 18, então o primeiro if não faz nada e ele passa para o elif que
vai verificar se o número é maior ou igual (>=) a 18. Caso seja, ele imprime a frase "Ei, você
não vai trabalhar hoje?". Veja que eu aproveitei pra colocar mais quebras de linha, que servem
para deixar a saída de texto do programa mais legível.

Como vimos, o Python pode trabalhar com expressões aritméticas, usando números e os
operadores:
+ (mais)
- (menos)
* (multiplicação)
/ (divisão)
== (igual a)
!= (diferente de)
> (maior que)
>= (maior ou igual a)
< (menor que)
<= (menor ou igual a)
** (exponenciação, elevado à)
Podemos usá-los para resolver aquele problema clássico de tirar a média das notas do aluno e
dizer se ele passou de ano. Digamos que sejam 4 provas e a média para passar seja 7.
Precisaríamos perguntar as notas das quatro provas, tirar a média e depois usar o if e o elif
para descobrir se a média é maior ou menor que 7.
O programa poderia ficar assim:
aluno = raw_input("\n Qual o nome do aluno? ")
prova1 = input("\n Nota da primeira prova: ")
prova2 = input("\n Nota da segunda prova: ")
prova3 = input("\n Nota da terceira prova: ")
prova4 = input("\n Nota da quarta prova: ")
media = (prova1 + prova2 + prova3 + prova4) / 4
if media < 7:
print "\n Média", media,". Que vergonha", aluno,". Levou bomba!"
elif media >=7:
print "\n Média", media,".", aluno, "passou. Parabéns!"
Imagine agora que você não queria saber apenas a média de um aluno, mas da sala inteira.
Você precisaria que o programa ficasse perguntando as notas de todos os alunos, um por vez e
depois desse a média geral.
Para isso precisamos usar a instrução "while" (enquanto), que repete uma seqüência de
instruções até que uma condição seja atingida. Podemos começar o programa perguntando o
número de alunos na sala e criar uma variável "contagem" com o valor zero. Cada vez que são
dadas as notas de um aluno, a variável "contagem" aumenta em 1. Quando ela chegar ao
número de alunos da sala, sabemos que todos foram contados. O programa ficaria assim:
alunos = input("\n Quantos alunos esta sala tem?")
 contagem = 0
total = 0
while contagem < alunos:
contagem = contagem + 1
print "\n Notas do aluno ", contagem
prova1 = input(" Nota da primeira prova: ")
prova2 = input(" Nota da segunda prova: ")
prova3 = input(" Nota da terceira prova: ")
prova4 = input(" Nota da quarta prova: ")
total = total + prova1 + prova2 + prova3 + prova4
media = total / alunos / 4
print "\n\n A média geral da sala é", media, "\n\n"
Este já ficou um pouco mais complexo que o anterior. Temos três novas variáveis. A variável
"alunos" armazena o número de alunos da sala. A variável "contagem" começa com zero mais
vai aumentando em 1 a cada vez que o programa roda. O while vai perguntando as notas e vai
somando tudo na variável total. Quando finalmente o número de alunos é atingido, vamos para
a parte final do programa, onde a média é calculada e escrita na tela.
Ao ser executado, o programa primeiro pergunta o número de alunos da sala e depois vai
perguntando as notas de cada prova até chegar ao resultado.

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

- Java: O Java é uma linguagem de programação multiplataforma, com uma sintaxe até certo
ponto parecida com o C++, porém com bibliotecas diferentes. Os programas em Java podem
ser executados em qualquer sistema operacional, desde que o interpretador esteja instalado.
A JVM é um programa que converte o código Java em comandos que o sistema operacional
possa executar. Existem máquinas virtuais para vários sistemas operacionais: o problema é
que, devido ao processamento executado pela máquina virtual, o programa torna-se mais
pesado do que seria caso escrito diretamente para a plataforma.
Um exemplo de programa desenvolvido desta forma é o Mercury (um cliente MSN com versões
para Linux e Windows, um dos primeiros a oferecer suporte a webcam e por isso bastante
famoso). Embora o código fonte do programa seja relativamente simples e bem escrito, ele é
bem mais pesado que outros programas similares, por causa da máquina virtual.
Explicando de forma mais elaborada, linguagens de programação "tradicionais", como o C e o
C++, utilizam um compilador diferente para cada plataforma ou sistema operacional em que o
programa irá rodar. O código fonte em si pode ser escrito de forma a ser facilmente portável,
ou seja, rodar em diferentes versões do Unix ou em várias famílias de processadores
diferentes sem muitas alterações, mas ainda assim será necessário recompilar o código fonte,
gerando um binário diferente para cada caso.
Embora o trabalho inicial seja maior, a vantagem desta abordagem é que o desempenho é o
melhor possível, já que sempre teremos um programa binário otimizado para a plataforma.
O Java utiliza um conceito diferente. Ao invés de gerar um binário diferente para cada
plataforma, é gerado um binário que pode ser executado em qualquer plataforma, dentro de
uma máquina virtual. Este binário "universal" é chamado de bytecode.
A idéia é criar aplicativos que possam ser escritos uma vez e a partir daí serem executados em
qualquer plataforma, reduzindo os custos de desenvolvimento. Apenas o software da máquina
virtual é que precisa ser reescrito para cada plataforma, mas isso é problema dos
desenvolvedores da linguagem, não do programador.
Existe ainda a opção de abrir mão da flexibilidade do bytecode em troca de um maior
desempenho, passando a compilar os programas com otimizações para uma determinada
plataforma. Isso é muito útil quando o programa será executado apenas dentro de
computadores de uma certa plataforma, como PCs rodando Linux, por exemplo.
No caso do Java, a máquina virtual que executa os programas é chamada de Java Virtual
Machine. Muitas páginas web utilizam applets Java, por isso a maioria das pessoas acaba
instalando o suporte a Java. Hoje em dia, além do Java da Sun, temos versões alternativas,
como o Blackdown e o Kofee, que possuem conjuntos de recursos variados, mas são a
princípio compatíveis com o código gerado para o Java da Sun.
Embora tenha ganhado relevância com o Java, este conceito não é exatamente novo.
Linguagens mais antigas como o LISP e o Prolog já utilizam bytecode e máquinas virtuais.

- Shell Script: Qualquer distribuição Linux inclui um número absurdo de comandos e

pequenos utilitários de modo texto, que são o terror dos iniciantes, mas a alegria dos usuários
mais avançados. O motivo de utilitários como o "tar", "dump", "dd", "rsync" e muitos outros
terem sobrevivido durante tantas décadas sem muitas modificações, não é apenas resultado
do saudosismo de alguns, mas resultado do fato de que, ao contrário da maioria dos utilitários
gráficos, eles podem ser combinados com outros comandos e entre si, formando scripts
poderosos de backup, automatização de tarefas diversas e muitas outras coisas.
O shell script é uma espécie de linguagem universal no Linux, pois combina comandos de
terminal com estruturas lógicas, similares às encontradas em outras linguagens para criar
programas de poucas linhas, capazes de executar tarefas complexas. Via shell script é possível
desenvolver em minutos ferramentas que demandariam horas de trabalho em outras
linguagens.
Muitos dos utilitários de configuração usados nas distribuições (embora muitas vezes não
pareçam) são na verdade shell scripts elaborados, que aparentam ser muito mais complexos
do que realmente são.
Um exemplo de uso de shell scripts são os ícones mágicos, painéis e outras ferramentas que
desenvolvi para uso no Kurumin. Uma outra vantagem é que estes programas não precisam
ser compilados. Você simplesmente escreve os comandos num arquivo de texto e executa
diretamente. Quando precisa fazer alguma alteração você altera o arquivo e pronto, o
problema está resolvido.
Um exemplo de shell script, que serve só para mostrar uma janelinha dando olá na tela seria
simplesmente: kdialog --msgbox "Olá, tudo bem?"

Não escrevi errado, ele só tem uma linha mesmo. Na verdade, quando você escreve um shell
script, você simplesmente usa funções de outros programas que estão instalados, por isso ele
é tão simples se comparado às linguagens de programação "de verdade" que vimos acima.
Você pode encontrar os scripts usados no Kurumin dentro da pasta "/usr/local/bin/". Para
estudá-los, você pode abrí-los em qualquer editor de texto e começar fazendo pequenas
modificações, para ir aprendendo como eles funcionam.
Os painéis gráficos são desenvolvidos com a ajuda do Kommander, que permite criar scripts
gráficos, usando as funções do KDE. Os arquivos vão na pasta "/etc/Painel/" e podem ser
abertos usando o "kmdr-editor", no "Iniciar > Sistema > Desenvolvimento".
Um shell script nada mais é do que um arquivo de texto comum, contendo os comandos que
serão executados, em ordem. Basicamente, se você sabe como fazer alguma tarefa via linha
de comando, você não tem problemas em fazer o mesmo via shell script. Este é um exemplo
de script simples, que serve para fazer backup dos arquivos de uma pasta num segundo HD,
usando o rsync:
 #!/bin/sh
rsync -av /mnt/hda6/ARQUIVOS/ /mnt/hdb6/ARQUIVOS
Todo shell script deve começar com a linha "#!/bin/sh" (ou "#!/bin/bash", que tem
exatamente a mesma função), que indica quem irá executar os comandos a seguir, neste caso
o próprio bash, o interpretador de comandos do Linux. Na verdade, estas linhas não são
realmente necessárias, pois o bash é o padrão de qualquer forma, mas não custa nada fazer
as coisas de forma elegante ;-).
O rsync é eficiente para este tipo de tarefa, pois ele sincroniza o conteúdo das duas pastas
transferindo apenas as modificações e não os arquivos completos, como aconteceria se você
fizesse uma cópia simples. Para que este arquivo de texto vire um script, é necessário que ele
tenha permissão para ser executado, o que é feito usando o comando "chmod +x", como em
"chmod +x script".
Este é um exemplo de script bem mais complexo, que faz parte do ícone mágico para instalar
o VMware Player no Kurumin. Ele faz download do arquivo, verifica se foi baixado corretamente
e, se necessário, remove o arquivo e começa de novo, até ter certeza de que ele está ok.
Depois, são executados os passos necessários para instalar o programa via linha de comando.
No final, ele verifica se o programa foi mesmo instalado e exibe a mensagem apropriada. Este
exemplo é mais complexo que os anteriores, pois minha idéia é dar um exemplo de script que
é usado na prática:
#!/bin/sh
cd /packages
md5sum=`md5sum vmware-player-distrib.tar.bz2`
while [ "$md5sum" != \
"9e41fed4b2d15d3f44522e5861b4bf5a vmware-player-distrib.tar.bz2" ]
do
cd /packages
rm -f vmware-player-distrib.tar.bz2
wget -c http://downloads-guiadohardware.net/vmware-player-distrib.tar.bz2
md5sum=`md5sum vmware-player-distrib.tar.bz2`
done
tar -jxvf vmware-player-distrib.tar.bz2
cd vmware-player-distrib/
sudo ./vmware-install.pl
rm -rf vmware-player-distrib/
if [ -e /usr/bin/vmplayer ]; then
kdialog --msgbox "O VMware Player foi instalado com sucesso. Você pode criar novas
máquinas virtuais e alterar suas configurações usando o Kurumin-EMU, encontrado no
Iniciar > Escritório e Utilitários."
else
kdialog --msgbox "Aparentemente houve algum problema durante a instalação.
Verifique se está conectado à Internet. Se o servidor do arquivo estiver fora do
ar, espere alguns minutos e tente novamente."
fi

À primeira vista, o script não parece tão simples assim, mas sem dúvida é bem mais simples
que programas escritos em outras linguagens. Dentro do código, podemos notar algumas
funções lógicas, como o while (enquanto), o "if" (então) e o "else" (senão).
O script começa acessando a pasta onde será feito o download e verificando se o arquivo já
não foi baixado. Isso evita que ele baixe de novo se ele já foi instalado anteriormente. Em
seguida temos um while, que faz com que ele execute um trecho de código repetidamente, até
que uma determinada condição seja satisfeita. No caso, a condição é que o md5sum do
arquivo precisa estar correto. Se necessário, ele deleta o arquivo e começa de novo.
Depois de baixar o arquivo e verificar o md5sum, ele parte para a instalação, descompactando
o arquivo, acessando a pasta que é criada e executando o programa de instalação. No final ele
verifica (if [ -e ) se o executável "/usr/bin/vmware" existe, um indício de que o programa foi
realmente instalado. Se algo de errado aconteceu e o executável não existe, ele exibe uma
mensagem avisando do problema.
Hoje em dia, muitos programas gráficos podem ser controlados via linha de comando. Graças a
isso, um script pode fazer coisas como abrir e fechar programas, criar novas janelas, minimizá-
las ou maximizá-las, alterar seu conteúdo e assim por diante. Via script também é possível
acessar bancos de dados, modificar arquivos de configuração de outros programas ou alterar a
configuração do sistema e assim por diante. Você pode ler mais sobre o desenvolvimento de
shell scripts no meu livro Linux, Ferramentas Técnicas.