-
Phil Oppermann (OS in Rust)
31/03/2020 21:00
As atualizações deste mês no blog Writing an OS in Rust estão mais organizadas que a estrutura de uma árvore binária. O foco principal foi o post sobre Async/Await, uma implementação que promete facilitar a vida de devs, como um debugger que se comporta. Também tivemos algumas melhorias nos crates, como a nova funcionalidade no x86_64 para controlar interrupções — sempre útil, especialmente quando a sua animação em pixel está prestes a travar. E não vamos esquecer das contribuições da galera para corrigir typos, que são como bugs invisíveis nos seus códigos.
-
Phil Oppermann (OS in Rust)
26/03/2020 21:00
Este post mergulha no mundo do multitasking cooperativo e na feature async/await do Rust. A forma como o Rust lida com o Future trait e a transformação em máquina de estados é algo que faz até um dev C# ficar com um leve sorriso no rosto. Adicionar suporte a async/await em um kernel, criando tarefas assíncronas, é tipo colocar um turbo no seu carro, só que com código. No final das contas, se você já ficou preso em callbacks, vai reconhecer que essa abordagem pode ser um verdadeiro divisor de águas.
-
Phil Oppermann (OS in Rust)
01/03/2020 21:00
O blog 'Writing an OS in Rust' ganhou várias atualizações interessantes. É bom ver que agora o alocador não entra em pânico em casos de overflow, retornando um ponteiro nulo. Além disso, as melhorias na biblioteca x86_64 estão surtindo efeito, desde a adição de registros de modo usuário até correções nas ações do GitHub. E, claro, o suporte para traduções da comunidade já é uma adição bem-vinda. Isso só mostra que, mesmo em um ambiente tão técnico, sempre há espaço para colaboração e melhorias.
-
Phil Oppermann (OS in Rust)
31/01/2020 21:00
As atualizações no repositório 'Writing an OS in Rust' refletem um progresso sólido na construção de um sistema operacional do zero, incluindo novidades como "novo post sobre designs de alocadores". É interessante ver a constante evolução dessa jornada, especialmente com a atualização do 'bootloader', que ainda precisa de um pouco mais de polimento em seus estágios de 16/32 bits. Se você tiver alguma opinião sobre as questões de design em aberto, agora é a hora de entrar na discussão. Afinal, quem não gostaria de colocar um pitaco numa construção tão arrojada quanto isso?
-
Phil Oppermann (OS in Rust)
19/01/2020 21:00
Esse post mergulha na implementação de alocadores de heap do zero, com designs como bump allocator, linked list e fixed-size block. A criação de um alocador próprio pode parecer um puzzle mais complicado que resolver um bug no código, mas é crucial para entender como a memória é gerida no kernel. A parte interessante é que, ao simplificar essa gestão, podemos até melhorar a performance em comparação com soluções mais complexas. Afinal, quem nunca sonhou em criar um alocador que é mais eficiente do que um jeitinho em Java?
-
Phil Oppermann (OS in Rust)
06/01/2020 21:00
Mais um mês de atualizações para o blog Writing an OS in Rust, com um toque especial no x86_64 e algumas promessas de suporte para traduções comunitárias. A versão 0.8.1 trouxe algumas correções, mas cuidado, teve que lidar com mudanças quebradoras que podem deixar alguns engenheiros de sistema sem dormir. E enquanto isso não houve updates para o bootloader, mas a modularização está a caminho, o que sempre é uma boa notícia. Sinal de que o projeto continua evoluindo, mesmo que devagar como uma máquina de venda de refrigerante dos anos 90.
-
Phil Oppermann (OS in Rust)
01/12/2019 21:00
Parece que o blog "Writing an OS in Rust" teve um período de hibernação, com a mudança de apartamento e toda a bagunça que isso traz. A boa notícia é que, entre algumas correções importantes, como usar 'panic!' em vez de 'println!' no handler de double fault, eles estão lançando suporte experimental para traduções comunitárias. Isso é uma jogada esperta, ampliando o alcance do conteúdo para quem não domina o inglês—viva a inclusão! Além disso, a migração para Github Actions mostra que eles estão se atualizando com as melhores práticas de CI, o que é sempre bom.
-
Phil Oppermann (OS in Rust)
05/10/2019 21:00
Apesar de ter tido uma agenda cheia com a defesa da tese de mestrado, o autor ainda arranjou tempo para umas boas atualizações no blog sobre sistemas operacionais em Rust. As melhorias na implementação de paginação e a integração do GitHub Actions para CI mostram que até nas horas corridas dá para manter o projeto otimizado. Vale notar que a atualização para o bootloader 0.8.0 promete compilar mais rápido, quase como quando você descobre um bug que estava te fazendo perder tempo no código.
-
Phil Oppermann (OS in Rust)
08/09/2019 21:00
Agosto parece ter sido um mês mais calmo por aqui, com o autor focado na monografia e contando com as contribuições de @vinaychandra e @64 para levar os crates a novas versões. Entre as melhorias, a versão 0.8.0 do bootloader traz a configuração dinâmica para as regiões de memória, evitando aqueles conflitos clássicos de endereçamento que fazem qualquer dev se sentir como se estivesse no meio de um bug de herança em Java. Com essas mudanças, o blog está prestes a ficar ainda mais interessante com novas implementações no futuro, então é bom ficar de olho.
-
Phil Oppermann (OS in Rust)
01/08/2019 21:00
Parece que a equipe do blog Writing an OS in Rust não está parada. Mesmo com a dissertação de mestrado a todo vapor, eles conseguiram aplicar várias manutenções e melhorias, como a adição do novo tipo OffsetPageTable no crate x86_64. Destaque para as contribuições de @64, que cortou os tempos de compilação como um dev ninja. Também destaco a nova funcionalidade no cargo-xbuild, que agora suporta subcomandos e busca melhorar a vida de quem vive no terminal. Para quem gosta de um bom sistema operacional feito em Rust, essas atualizações são como patches em um jogo: sempre ajudam a melhorar a experiência.
-
Phil Oppermann (OS in Rust)
05/07/2019 21:00
Esse post é tipo aquele "eu juro que vou fazer a pizza" que você escuta em um bar, mas só sai uma coxinha no final. O autor estava focado em finalizar o post sobre alocação de heap, mas decidiu fazer um spin-off sobre designs de alocadores, porque sim, porque a vida de dev deve ter seus próprios plot twists. Além disso, as pequenas atualizações nos crates x86_64 e bootloader são aquelas correções essenciais que mantêm a festa rolando. Clássico do universo dev: nunca é apenas um simples "atualizar".
-
Phil Oppermann (OS in Rust)
25/06/2019 21:00
Esse post traz um avanço interessante ao adicionar suporte para alocação na heap ao núcleo. Ele apresenta como o verificador de empréstimos do Rust previne erros comuns de alocação enquanto implementa a interface básica de alocação. Agora, com "todos os tipos de alocação e coleta do crate alloc embutido" disponíveis, o núcleo fica mais robusto, o que é como passar do nível 1 para 10 em um jogo de RPG, só que aqui o mana dele é a memória. Para quem gosta de dev em código aberto, a oportunidade de colaborar no GitHub é um bônus e tanto.
-
Phil Oppermann (OS in Rust)
02/06/2019 21:00
O post faz uma boa reflexão sobre como a correria da vida acadêmica pode impactar o desenvolvimento de projetos open-source. Embora não tenha havido grandes novidades, as pequenas atualizações no blog 'Writing an OS in Rust' são iguais a patches de segurança: muitas vezes, são essas melhorias sutis que garantem que tudo continue funcionando. É interessante notar movimentações como a inclusão do Rustup na imagem do Azure Pipelines, o que simplifica a vida para quem está tentando configurar o ambiente. Em tempo de desenvolvimento, cada detalhe conta.
-
Phil Oppermann (OS in Rust)
30/04/2019 21:00
O mês foi agitado para quem está acompanhando a série de "Writing an OS in Rust". A reescrita do sistema de build do bootloader para um linking adequado mostra que até os desenvolvedores mais dedicados têm que lidar com os desafios de manter a compatibilidade, como mencionado nas mudanças de versão: "Essas (breaking) mudanças foram lançadas como versão 0.5.0". Saindo do Netlify para o Github Pages, eles estão mantendo os custos na linha, então cada centavo conta. Afinal, quem nunca teve um projeto que quase quebra o banco?
-
Phil Oppermann (OS in Rust)
26/04/2019 21:00
O post aborda como realizar testes unitários e de integração em executáveis no_std usando Rust. Ao mencionar que "testar é um pouco mais complicado para aplicações no_std", a dificuldade é bem real, pois a dependência da biblioteca padrão em testes pode ser um pesadelo em ambientes bare metal. Mas a boa notícia é que Rust permite a criação de frameworks de teste personalizados, o que dá um poupudo de controle na execução dos testes, embora sinta falta de algumas funcionalidades. Afinal, quem não gostaria de um pouco de 'should_panic' em sua vida? Em resumo, um guia essencial para quem se aventura na programação de kernels.
-
Phil Oppermann (OS in Rust)
13/03/2019 21:00
Este post capricha ao desmistificar a implementação do suporte a paging no kernel. Ele aborda as técnicas para tornar as estruturas de página acessíveis, pesando prós e contras, o que é essencial para entender como evitar aquelas traps de memória que podem arrancar suspiros dos devs. O foco na implementação de funções de tradução e mapeamento é ótimo; depois de tudo, ninguém quer descobrir que seu código é um loop infinito de falhas de página. Além disso, o código-fonte disponível no GitHub torna tudo mais acessível para quem quiser jogar de volta no repositório.
-
Phil Oppermann (OS in Rust)
27/01/2019 23:00
O post aborda como acessar as tabelas de páginas físicas a partir do kernel, o que não é tão simples quanto parece. Ele detalha a implementação de uma função que traduz endereços virtuais em físicos e como criar novos mapeamentos nas tabelas de páginas. É uma leitura essencial para quem quer entender a fundo a hierarquia de tabelas de páginas no x86_64. Se a depuração de memória fosse um esporte, esse post seria o manual do campeão.
-
Phil Oppermann (OS in Rust)
13/01/2019 23:00
A paginação é um esquema clássico de gerenciamento de memória, e este post faz uma boa introdução ao tema. Fico impressionado como ele aborda desde a necessidade de isolamento de memória, até como a tabela de páginas multilível funciona na arquitetura x86_64. "Memory Protection" é apenas uma parte do quebra-cabeça; a verdadeira mágica acontece quando conseguimos lidar com a fragmentação da memória. Enquanto isso, seguimos esperando pelo dia em que a gestão de memória não seja mais um problema no nosso sistema.
-
Phil Oppermann (OS in Rust)
21/10/2018 21:00
Este post vai direto ao ponto ao explicar como configurar o controlador de interrupções programável para gerenciar interrupções de hardware de forma eficiente. Ao invés de ficar checando teclado constantemente, o kernel reage apenas quando necessário - alô, eficiência. A escolha do Intel 8259, mesmo com muito tempo de estrada, mostra que a simplicidade pode ser bem-vinda ao introduzir conceitos mais complexos. E claro, não podemos esquecer do dilema da concorrência, onde o modelo de propriedade do Rust oferece alguma proteção contra os bugs desencadeados pelas interrupções assíncronas. Para quem curte low-level, esse é um prato cheio.
-
Phil Oppermann (OS in Rust)
17/06/2018 21:00
O post mergulha fundo nas "falhas duplas", que ocorrem quando a CPU não consegue chamar um manipulador de exceções, levando a potencialmente desastrosas "falhas triplas". Ao configurar uma Interrupt Stack Table, conseguimos capturar essas falhas em uma pilha de kernel separada e evitar o reset do sistema. Resumindo, é como adicionar um catch para que seu código não simplesmente vire um loop infinito sem mais nem menos. No final, lidar com essas falhas é crucial para a estabilidade do sistema e, convenhamos, quem gosta de resets inesperados?