Evolução dos Sistemas Operacionais – Parte 1

Introdução

Nos dois primeiros episódios vimos que a evolução da internet, apesar de ter sido rápida a partir dos anos 80 foi gradual e lenta para os padrões de hoje. O que ocorre é que a história e a evolução dos sistemas operacionais foi ainda mais lenta, sendo que o primeiro sistema digital é datado do século XIX.

Mesmo depois de um século as coisas ainda eram de certa forma complicadas de executar e aprimorar, mas não para nós. E por isso no episódio desta semana, vamos entender como aconteceu toda essa longa jornada até os dias de hoje. Posso entrar no seu smartphone?

Se você me permite, muitíssimo obrigado, meu nome é Pétrus Davi e este é o Versão Beta sobre a evolução dos sistemas operacionais.

Bem, antes de começar o episódio eu gostaria de dar um recado rápido, bem rápido mesmo e então podemos começar sem mais impedimentos.

O recado é que se você está ouvindo esse episódio através de um agregador de podcast, eu convido você a olhar a descrição dos episódios. A descrição contém alguns textos pequenos e bem curtinhos e que podem te ajudar a entender melhor o áudio, além de imagens que podem servir de referência para o que está sendo abordado. Caso você não saiba o que é podcast, fique tranquilo que explicarei em um episódio mais apropriado. Recados dado, vamos ao episódio.

Charles Babbage com o primeiro computador digital.

Sistemas operacionais têm evoluído ao longo dos anos. Porém os eventos que ocorreram para a evolução não são muito precisos.

Algumas tecnologias mais avançadas não esperaram as anteriores serem desativadas para que pudessem ser postas em prática. Como ocorreu também na história da internet, houve inovações que foram apenas promessas mas nunca atingiram seu potencial seja pela tecnologia em sí ou pela falta de recursos da época. De qualquer caso, tome este episódio como guia e não como uma palavra final.

O primeiro computador digital de fato foi inventado pelo matemático inglês Charles Babbage, um homem que tinha uma inteligência e ideias muito além de seu tempo. No início do século XIX, ele teve a ideia de construir uma máquina para fazer cálculos matemáticos baseado em instruções inscritas em cartões perfurados, um recurso que viria a ser inventado anos depois.

Apesar dele ter tido a ideia, ele nunca pode colocar em prática porque não havia um recurso necessário, que seria um software para executar os cálculos, já que até então eles eram feitos manualmente.

Foi sua amiga e também matemática Ada Lovelance, filha de Lord Byron, que traduziu um artigo em francês sobre a invenção e escreveu, em papel mesmo, instruções de como a maquina poderia executar uma sequência de cálculos aritméticos. E fazendo isso, ela escreveu o primeiro software da história. Na verdade, a linguagem de programação Ada é justamente em homenagem a ela.

Primeira Geração (1945-1955): Mais de 8.000 válvulas

Apesar das tentativas de Babbage, seus desenhos iniciais nunca puderam ser completados e sua ideia foi engavetada. Após isso pouco progresso foi feito no campo do software e ainda sequer existiam sistemas operacionais.

Muitos computadores foram construídos nesse período, o primeiro devidamente funcional sendo no estado de Iowa. Após isso ocorreram iniciativas de construir computadores por alguns países, como alemanha e inglaterra e até alguns nomes conhecidos como Alan Turing, considerado o pai da computação, participaram nesses desenvolvimentos.

Nessa época, um grupo de pessoas, geralmente sendo engenheiros, eram responsáveis pela construção, manutenção, programação e operação das maquinas. Todos os programas e processos eram muito complexos. Eram inseridos circuitos elétricos através de inúmeros cabos e painéis de ligações para controlar as funções da máquina, não existiam linguagens de programação e tampouco sistemas operacionais, nem mesmo projetos ou ideias próximos disso.

Basicamente o processo para fazer essas enormes maquinas funcionarem eram manuais. Um dos engenheiros anotava a mão um período de tempo necessário para o computador executar a operação. Ao final do tempo, ele descia até a sala de maquinas e fazia a troca dos paineis de programação da maquina e esperar pelas próximas horas seguintes, torcendo para que nenhuma das 20.000 válvulas queimassem durante o processo.

Os problemas e cálculos que essas maquinas faziam eram simples, em geral cálculos de tabelas de senos, cossenos e logaritmos, além de cálculos de trajetória. Vale lembrar que era os anos 50, apenas 5 anos após o fim da segunda guerra mundial, então era de se esperar que essas maquinas fossem usadas para fins militares. O procedimento melhorou um pouco com a chegada dos cartões perfurados, que substituíram os painéis de programação, mas o sistema de inserir instruções na maquina era o mesmo.

Segunda geração (1955-1965): Transistores e sistemas em lote

Com a chegada do transistor, a coisa mudou de cenário. O fato dele ser bem mais barato, fácil de produzir e funcional que as válvulas para a transferência de energia, tornaram os computadores mais confiáveis a ponto de serem vendidos para seus clientes com a garantia que funcionariam tempo o suficiente para realizar alguma tarefa.

Outra tecnologia que ajudou foram os cartões perfurados. Foram inicialmente projetado pela IBM e foram os grandes precursores da memória usada em computadores. Os cartões perfurados contém informações digitais representadas pela presença ou falta de furos em posições predefinidas, assemelhando a gravação de um cd. Foram usados no século XVIII e XIX mas foi só em 1950 com a IBM que esse método se expandiu para computadores eletrônicos.

Mas apesar disso, o processo de uso dos cartões perfurados além de caro, era custoso. Grandes corporações e orgãos do governo construíam salas grandes e climatizadas especialmente para esses computadores, chamados de mainframes. Rodar programas nessas maquinas envolviam várias pessoas e se locomover até uma das salas para inserir os cartões perfurados com as instruções, aguardar o tempo de leitura e ir até a outra sala para buscar o resultado do processo.

Com a finalidade de acelerar esse processo que surgiram os sistemas em lote. Esses sistemas em lote na época funcionavam em fitas magnéticas, que eram lidas por maquinas menores e mais baratas, sendo a mais famosa da época o IBM 1401. Os grandes computadores dessa época eram usados para fazer cálculos científicos e solucionar equações complexas da engenharia e da física.

As coisas já pareciam melhorar para um cenário mais completo e robusto e apesar de até o momento ainda não existirem sistemas operacionais de fato, as sementes e os desenhos iniciais estavam surgindo e a próxima geração provou mudar muitas regras desse jogo.

Terceira Geração (1965-1980): CTSS, MULTICS e o início dos Sistemas Operacionais

Eu sei que até o presente momento não mencionei ainda qualquer sistema operacional de fato e pode estar se perguntando o porque disso. É que realmente, até a terceira geração de computadores não haviam sistemas de fato. O próprio sistema em lotes e a lógica dos cartões perfurados, apesar de já apresentarem alguma funcionalidade, nada mais eram que instruções específicas para serem executadas, não um sistema auto suficiente.

Mas isso iria mudar nos meados da década de 60, os primeiros sistemas operacionais foram desenvolvidos conforme a evolução da tecnologia da época. Só que cada máquina possuía seu próprio sistema operacional específico, o que resultava na incompatibilidade de mainframes diferentes. Um dos maiores representantes de SO da época o CTSS, que seria um Sistema Compatível de Tempo Compartilhado, criado pela MIT e lançado em 1961 para o computador IBM 7090.

O princípio do CTSS se assemelha ao conceito de multiprogramação, onde vários computadores básicos usam seu poder de processamento para executar uma única tarefa. No caso do CTSS, o conceito de compartilhamento de tempo consistia em fazer com que alguns computadores executando a mesma tarefa tivessem mais tempo disponível da CPU, fornecendo uma experiência bem interativa, pelo menos na teoria.

O conceito funcionou após algumas modificações e logo modelos baseados nele surgiram. Um em especial chamado MULTICS, com uma ideia ainda mais ousada que o CTSS. O plano inicial era dar suporte a centenas de usuários conectados em uma máquina não tão robusta. Mas o MULTICS encontrou dificuldades para entrar em operação e após alguma insistência do MIT, ele foi implementado em alguns modelos de computadores.

Outro grande problema do MULTICS é que ele foi desenvolvido em uma linguagem já ultrapassada na época em que ele foi lançado. Como já não havia mais suporte, problemas de incompatibilidade, falhas de execução e desperdício de recursos eram constantes.

Apesar disso, os usuários que compraram maquina com o MULTICS eram leais ao sistema. Empresas como a Ford, a General Motors e a Agência de Segurança Nacional dos Estados Unidos trocaram seus sistemas MULTICS trinta anos depois, ao final da década de 90 após anos de tentavivas de fazer a Honeywell, empresa que dava suporte ao MULTICS, de atualizar o hardware.

Alguns dos desenvolvedores do projeto forneceram gratuitamente vários recursos e arquivos históricos sobre o desenvolvimento do MULTICS, além de seu código fonte, você pode encontrá-los aqui

UNIX – A base de (quase) todos

Visando resolver incompatibilidade de SOs de diferentes maquinas, um desenvolvedor chamado Ken Thompson, um funcionário da AT&T em seu tempo livre, encontrou um minicomputador largado no chão e decidiu criar uma versão do MULTICS mais limpa e para apenas um usuário. Dessa ideia surgiu o Umics que mais tarde viria a ser conhecido como Unix, desenvolvido em 1969, sendo o primeiro sistema operacional moderno da computação. É possível afirmar que mais de 90% dos SOs atuais foram influenciados de alguma maneira pelo Unix.

Durante a década de 70, o Unix foi distribuído gratuitamente (incluindo seu código fonte) para universidades e órgãos governamentais norte-americanos, o que deu a ele uma grande popularidade a este sistema. Sua interface era totalmente em modo texto, você pode ver uma imagem da tela do unix na descrição desse episódio ou no site.

Em 1977 foi lançado o BSD, sistema operacional fortemente baseado no Unix, focado principalmente para a execução em máquinas específicas de alto desempenho. Porém, alguns programadores já estavam com planos de tornar esse sistemas operacionais mais amigáveis e mais próximos de pessoas comuns, uma ideia que para época era impensável. Um desses programadores foi um jovem chamado Steve Jobs.

A visão de Jobs iria mudar drasticamente o cenários. Para ver como as ideias dele mudaram e moldaram grande parte dos sistemas operacionais hoje, fique ligado no episódio da semana que vem, obrigado por escutar e até a próxima!

Este obra está licenciado com uma Licença Creative Commons Atribuição 4.0 Internacional.