Emulador 8086 escrito em C A primeira coisa que é preciso deixar claro é que esse não é um emulador completo, o objetivo é apenas interpretar um hello world. Claro, é possível pegar esse esqueleto e expandir até se tornar um emulador completo.
Eu estava entediado esperando meus amigos aparecerem na Campus Party de 2016, encontrei a mesa que estava separada para a galera de hackerspace e fiquei esperando mas como não tinha nenhuma palestra aquele horário nem nada que eu quisesse participar eu precisava de algo para matar o tempo.
Vamos ver algumas coisas da minha experiência trabalhando em home-office e vou dar algumas dicas de como eu resolvi problemas comuns que todo mundo que quer trabalhar com tecnologia longe do escritório vai enfrentar.
Eu sou um veterano quando o assunto é trabalho remoto. Comecei no fim dos anos 90, na época eu trabalhava em uma empresa com uma administração bastante arrojada e moderna principalmente para o Brasil da época.
Eu de vez em quando brinco com meu semi-morto projeto de um interpretador BASIC, é uma brincadeira divertida mas sem nenhum propósito comercial, é uma daquelas coisas para fazer apenas pela diversão mesmo.
Mas na minha pesquisa sobre o que tem por ai implementado em BASIC encontrei algumas coisas interessantes e é incrível como uma linguagem antiga e com tantos problemas ainda esta por ai e ainda é possível encontrar compiladores comerciais sendo desenvolvidos hoje em dia para ela.
Este é um erro bem difícil de achar, basicamente a ordem dos cases do switch esta errada, o maior escopo esta em primeiro lugar fazendo com que o switch sempre pare nele, para resolver o problema basta mudar a ordem dos cases colocando os casos de menor escopo no início. Mas até ai já foi um tempão debugando código e litros de café :D
package main import "fmt" type comptometer interface { Sum(a, b int) int } type foo struct{} func (_ foo) Sum(a, b int) int { return a + b } type bar struct{} func (_ bar) Sum(a, b int) int { return a + b } // func printType(e comptometer) { /* Este switch esta na ordem errada e vai imprimir sempre "comptometer interface" e nunca via entrar nos outros cases do switch.
Testes unitários são incrivelmente importantes, mesmo para uma linguagem compilada como Golang eles são fundamentais.
Felizmente hoje em dia a maioria das linguagens de programação tem uma bela variedade de ferramentas para teste unitário. Golang vem com algumas ferramentas surpreendentes não apenas para fazer os testes mas também para analisar o código em busca de falhas na cobertura, etc.
E no lugar de simplesmente ler um relatório é muito mais interessante ter uma forma visual e rápida para analisar a cobertura de testes.
Imprimindo seu proprio fonte Quine é um programa que consegue imprimir seu código fonte na saída padrão. O nome é em homenagem ao matemático e filosofo Willard Van Orman Quine.
Existem exemplos de Quine escritos para várias linguagens de programação, é um exercício interessante tentar escrever a sua versão e um belo desafio.
Implementação em Golang package main func main() { aspa := string(96) print(codigo, aspa, codigo, aspa) } const codigo = `package main func main() { aspa := string(96) print(codigo, aspa, codigo, aspa) } const codigo = ` Codigo fonte do exemplo: exemplo no Golang Playground exemplo no grupo de estudos
Criando o certificado Primeiro vamos criar um certificado de testes, claro que quando for usar em produção você deve usar um certificado gerado por uma entidade certificadora reconhecida.
Com o comando abaixo vamos criar dois arquivos server.crt e server.key que vamos usar para configurar o PostgreSQL.
openssl req -new -x509 -days 365 -nodes -text -out server.crt \ -keyout server.key -subj "/CN=example.com" Configurando PostgreSQL Edite o arquivo postgresql.conf para ativar o uso da chave SSL.
Unix domain socket Unix Domain Sockets ou IPC socket é uma forma muito pratica e segura de trocar informações entre processos. Essa forma de IPC usa um arquivo como endereço/name space no lugar de um IP e uma porta como seria em uma comunicação via rede.
Uma coisa importante para ter em mente é que como vamos usar um arquivo o servidor é responsável por ele, se não existir ele sera criado automaticamente mas se não existir você vai receber um erro com algo como “bind: address already in use” que significa que o arquivo já existe e o servidor não tem como reaproveitar um arquivo que já existe, o correto é fazer shutdown elegantemente e fechar e apagar o arquivo antes de derrubar o servidor.
Um JSON lint em Golang Esse é um pequeno utilitário de linha de comando para validar e formatar JSON que também pode ser usado como pacote, a ideia inicial era criar um parser para validar o JSON mas não foi necessário, o próprio Golang traz todas as informações que precisamos no erro inclusive o offset do erro e dai foi simples mostrar os erros de forma mais completa inclusive indicando com uma seta exatamente onde esta o erro.
Trafegando dados entre middleware Já vimos como funciona um middleware HTTP e agora vamos ver como passar informação entre os middlewares. Isso é usado por exemplo para passar as credenciais de um usuário para o próximo middleware e qualquer outra informação que seja coletada em algum dos middlewares e você queria passar para frente.
Antes de mais nada vamos fazer um exemplo para mostrar da forma mais clara possível quando os middlewares são executados, isso é muito importante porque erros no entendimento dessa ordem de execução é uma incrível fonte de bugs.
Usar middleware HTTP são muito úteis para evitar duplicidade de código quando você tem vários endpoints na sua aplicação, por exemplo se você quiser ter certeza que as credenciais do usuário foram verificadas, ou que o conteúdo foi comprimido, e assim por diante.
A coisa mais importante que se deve lembrar é que cada middleware vai ser chamado na ordem que foi registrado, então por exemplo podemos ter um middleware que tem a responsabilidade de preparar o ambiente, como abrir o banco de dados ou preparar o controle de sessão que vem antes do middleware que valida as credenciais do usuário.
goto e label em Go A instrução goto tem uma má fama que vem do tempo do BASIC quando era usada indiscriminadamente e acabava tornando o código impossível de ler. Em linguagens modernas entretanto é uma instrução perfeitamente válida e desde que usada com critério pode ajudar a tornar seu código mais limpo.
Alem de goto as instruções break e continue também aceitam labels, isso é muito útil para quando por exemplo se quer sair de um for aninhado em outro for ou especificar para qual dos fors aninhados se quer fazer continue.
mensageria com NATS Para quem precisa que vários sistemas se comuniquem entre si e precisa de velocidade e simplicidade o NATS é uma grande ajuda. Uma das características mais interessantes é a incrível velocidade e um protocolo simples que pode ser facilmente implementado faz com que o NATS seja usado desde para IoT com bibliotecas cliente escritas até mesmo para Arduino quando para comunicação entre serviços muito maiores.
Este é o primeiro de uma série de tutoriais rápidos onde pretendo cobrir o uso de gRPC e vários aspectos como testes, TLS, boas praticas e muito mais.
Para iniciar com gRPC precisamos ir até a base então vamos primeiro falar de Protocol Buffers.
Protocol Buffers é uma forma simples e agnóstica com relação a linguagem de se definir uma estrutura de dados, como XML só que melhor, mais simples e mais rápido, muito mais rápido.
Acessar servidores via ssh usando um conjunto de chaves publica/privada é mais seguro e pratico principalmente mais seguro, alem de facilitar a automação de várias tarefas.
Criando as chaves Primeiro crie as chaves com o seguinte comando:
mkdir ~/.ssh ssh-keygen Precisa fazer isso apenas uma vez na maquina cliente e um conjunto de chaves será gerado, você pode definir o nome do arquivo que por padrão seria id_rsa para a chave secreta e id_rsa.
Continuando a conversa sobre interfaces e sobre manipulação de JSON tem um recurso muito útil que usamos para ajudar o nosso sistema a falar melhor com o PostgresQL e pREST.
O formato de data padrão do Postgres é incompatível com o formato padrão do Golang e o nosso sistema usa muito JSON para tanto mandar como receber informações do banco de dados.
Ter que lembrar toda hora de fazer o parser da data para o formato correto simplesmente não é pratico, é muito melhor ensinar o Golang como lidar com data e hora no bom e velho formato ISO 8601.
Falamos desse mesmo tema na nossa lista de exemplos do grupo de estudos sobre interfaces mas vamos isso foi la no longínquo ano de 2016 então vamos tentar fazer um novo exemplo para mostrar como usar uma interface como um contrato que permite você passar tipos diferentes para uma função ou aceitar tipos diferentes em uma interface desde que ele aceite implemente o contrato que em outras palavras significa implementar as funções descritas na interface.
Como qualquer ferramenta, usar uma VPN só vai ser efetivo se você souber exatamente qual problema quer resolver com ela. Existem pessoas que querem manter seu trafego pela internet anônimo, outras querem proteger seus dados, e por ai vai. O meu uso é bem especifico, alguns provedores de acesso a internet estão bloqueando portas importantes que eu uso para acessar serviços, por exemplo um famoso provedor daqui de São Paulo esta bloqueando a porta TCP 22 que usamos para acessar o ssh, note que não é o caso do provedor bloquear conexões de entrada que já era comum mas de saída, ou seja usar qualquer serviço que dependa de ssh como o GitHub por exemplo ou acessar uma maquina hospedada na Computer Engine do Google Cloud Platform fica impossível.
Interface vazia é um tipo que aceita qualquer coisa, você pode passar o que quiser como parâmetros de função ou variáveis do tipo interface{}.
Parece muito pratico a primeira vista mas quando usamos interface{} estamos jogando pela janela a validação de tipos feita em tempo de compilação e perdemos uma das grandes vantagens de uma linguagem compilada de tipagem forte e estática.
E como a checagem de tipo não vai acontecer em tempo de compilação é sua responsabilidade checar se esta recebendo o tipo certo em tempo de execução.