Posts

Por muito tempo fui adepto de usar os guias de consulta rápida, que eram pequenos livros bem leves e pequenos com um conteúdo resumido e direto sobre algum tópico. Hoje em dia estes livrinhos são apenas história, pois com a internet podemos acessar qualquer manual mais rapidamente e leve (num smartphone, por exemplo). Porém as documentações as vezes são extensas e fica dificil acessar um ponto específico que temos dúvida. Para isso existem os cheat sheets, que são como os guias de consultas rápidas, uma página única, com uma exmplicação concisa e um exemplo sobre o tópico apresentando. ...

Continundo pelas ferramentas que uso no meu dia a dia, agora seguem meus compiladores, interpretadores, IDEs e editores Compiladores e Interpretadores Tenho trabalhado com diversas linguagens de programação e destas linguagens também em diversas versões diferentes, por isso ferramentas que me ajudam a gerênciar as linguagens e suas versões são essênciais: build-essentials: isso aqui não é um software em si, mas um conjunto de diversas ferramentas que ajudam no build de software diversos, principalmente coisas desenvolvidas em C e C++. É algo que não vem por padrão em uma instalação GNU/Linux, mas a partir do momento que você precisa compilar uma aplicação isso será exigido. asdf-vm: O asdf-vm surge como uma ferramenta universal para o gerenciamento de versões de intepretadores, compiladores e outras ferramentas. Sua utilização é bem simples, hoje utilizo ela principalmente para Python, NodeJS e Go. Aqui um artigo em português sobre a instalação dele. rustup: A ferramenta criada para gerênciar versões da suíte da linguagem Rust é uma mão na roda, além de facilitar a instalação e gerênciar versões, também permite controlar os alvos de compilação (seus toolchains, exemplo: Linux, Windows, ARM, etc). OpenJDK: A implementação de referência do Java tem sido a minha preferida nos ambientes de desenvolvimento e execução faz um tempo. Lembro de antigamente ela ter uma performance inferior, porém cada vez mais a comunidade se uniu em torno dela para aprimora-la. IDEs e Editores Visual Studio Code: o editor de texto criado pela Microsoft tem se destacado muito nos últimos anos, principalmente pela facilidade que oferece para a utilização de plugins que o tornam uma ferramenta muito poderosa. Tenho utilizado ele principalmente para o desenvolvimento Python, Rust, NodeJS e Go, com os seguintes plugins: Python: extensão para programar e debugar em Python. rust-analyzer: extensão que faz o linter, autocomplete e análise estática do código Rust. CodeLLDB: extensão que permite debugar códigos gerados pela LLVM, utilizo para debugara projetos Rust, mas funciona para outras ferramentas que utilizam LLVM. crates: extensão para exibir quais dependências estão atualizadas e desatualizadas. Go: extensão para análise e debugger de código Go. PyCharm Community e a suíte da JetBrains: A IDE da Jetbrains dedicada ao Python oferece muitos recursos interessante, desde o linter até o debugger integrado. Por ser um pouco mais pesado eu só utilizado nos projetos grandes com muitos arquivos, pois ele facilita muito a busca e análise no projeto. Uso principalmente o PyCharm, mas também gosto de usar as outras ferramentas disponíveis da JetBrains para projetos maiores, como a IntelliJ e Webstorm. Micro Editor: Esse cara eu descobri recentemente e tem sido muito útil, como o próprio nome indica ele é um editor de terminal maior que o Nano mas bem mais simples que o Vim pois permite utilizar atalhos do dia a dia como Ctrl+S para salvar, Ctrl+C/Ctrl+V para copiar e colar. Utilizo muito para a edição de scripts mais simples em Bash e Python. Micro Editor: um editor simples que roda direto no terminal e faz até análise estática quando junto com o Flake8 (no caso de Python) ...

Gosto muito da praticidade dos cheat sheets, que são pequenas páginas, que podem ser impressas ou não, que contém um resumo sobre algum assunto específico. Desta vez quero compartilhar uma que descobri recentemente sobre a linguagem Rust, que venho aprendendo nos últimos tempos. Clique na imagem para acessar!

Durante a minha jornada venho acumulando algumas ferramentas para ajudar no meu dia a dia no desenvolvimento de software, na maior parte são coisas simples mas que fazem muita diferença na produtividade. Nesta primeira parte irei abordar os sistemas operacionais que uso e os aplicativos de terminal. Sistemas Operacionais Ubuntu GNU/Linux: O Ubuntu tem sido meu sistema operacional há mais de dez anos. Quando desenvolvemos para a web, sistemas tipo Unix são preferênciais devido as ferramentas que eles já oferecem por padrão, além de serem na maioria dos casos os ambientes de deploy das aplicações. Além de toda a “tralha” de desenvolvimento, o GNU/Linux tem cada vez mais ferramentas para o uso comum, como editores e jogos. Eu gosto de usar o Ubuntu pois já sou acostumado com sua interface, mas acredito que a indicação aqui seja principalmente utilizar uma distribuição que você goste e se adapte. Windows 10: O Windows tem sido uma grata surpresa para mim, além de utiliza-lo para as aplicações que só rodam no Windows, junto com o WSL2 tenho conseguido utilizar qualquer ferramenta GNU/Linux nele, inclusive aplicações gráficas graças ao X410. Terminal A primeira coisa que vale citar é o emulador de terminal que utilizo, o Tilix. Ele possui algumas ferramentas bem interessantes como split de janelas, abas e é bem leve. Além disso ele possui o modo Quake, que é um modo onde o terminal aparece no topo da tela (ou onde você configurar) de maneira rápida de mais prática. ...

Sempre estamos aprendendo, pelo menos todo dia podemos tirar uma lição do que aconteceu. Algumas coisas são mais marcantes que outras, inclusive podem e devem ser repassadas para outros, podendo ajudar pessoas que estão iniciando ou até as mais experientes. Para documentar as coisas de maneira mais direta criei uma pequena página onde documento meus aprendizados, principalmente devido a erros que cometi. O link para ler essa página é http://aprendizado.lucaspolo.dev

A história da computação é algo muitas vezes cíclico, onde conceitos com quase 50 anos retornam, às vezes na mesma forma, as vezes em uma nova roupagem. Vamos dar um zoom num dos conceitos mais comuns da programação moderna, a programação orientada a objetos. A primeira coisa que eu gostaria de falar é que programamos orientado a classes mas os sistemas não rodam orientado a objetos. O QUE? ...

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 import asyncio from random import randint import time async def funcao_assincrona_com_possivel_chamada_sincrona(n: int): # A corrotina é uma função educadinha, que quando vai fazer # algo que pode demorar fala assim: # "Cara, isso aqui vai demorar pois é operação de IO, podem ir fazendo outra coisa" # Assin o interpretador é liberado para executar outras instruções. for i in range(10): print(f'Task {n} - {i}') # Neste ponto (await) a corrotina concede o direito de execução # de volta, ai é permitido rodar outras corrotinas # que estiverem aguardando, é aqui que a rotina fala # "Gente, pode continuar ai que vou demorar aqui um pouco" # Aqui poderia ser uma requisição web demorada, # um acesso a bancos de dados e outras coisas, por exemplo. print(f'Liberando task {n} - {i}') await asyncio.sleep(randint(0,3)) print(f'Retomando task {n} - {i}') # Aqui acontece a quebra, existe a chance (1 em 1000) de # ser executado um processo blocante que irá # blocar todos as tarefas que estão rodando concorrentemente # Ela não é tão educada quanto parecia quando entra aqui. sorte = randint(0, 1000) if sorte == 50: print print(f'Task {n} blocou a GIL no passo {i}, que azar') time.sleep(3) # Isso aqui blocante! print(f'Concluindo task {n} - {i}') async def main(): # Irá criar mil tarefinhas que serão disparadas em "paralelo" (na verdade concorrentemente) tasks_assincronas_que_podem_blocar = { asyncio.create_task( funcao_assincrona_com_coisa_assincrona(i) ) for i in range(10000) } # Executa todas elas, aguardando todas serem concluidas await asyncio.wait( tasks_assincronas_que_podem_blocar, return_when=asyncio.ALL_COMPLETED ) if __name__ == "__main__": asyncio.run(main())

Fazer um jogo de JoKemPo em Python é simples, mas para complementar fiz alguns tratamentos diferentes, como a captura de KeyboardException para tratar a saída do programa. 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 from random import choice # Esta função serve para escolher aleatoriamente um elemento da lista! # Dicionário de movimentos, na chave a opção e no valor quem ela ganha! MOVES = { 'rock': 'scissors', 'paper': 'rock', 'scissors': 'paper', } # Lista de opções OPTIONS = list(MOVES.keys()) def _get_user_choice(): """ Recupera e valida a opção do usuário """ while True: user_choice = input('Choose one option [rock/paper/scissors] - ctrl+c to exit: ') if user_choice not in OPTIONS: print('Choose a valid option!') continue return user_choice def _jokenpo(user_choice, computer_choice): """ Valida a regra do jogo, comparando a escolha do usuário com a do computador! """ if MOVES[user_choice] == computer_choice: print('You win!') elif MOVES[computer_choice] == user_choice: print('I win!') else: print('Meh!') if __name__ == "__main__": while True: # Roda infinitamente try: user_choice = _get_user_choice() except KeyboardInterrupt: print('\nBye!') # Caso o usuário aperte ctrl+c sairá do loop infinito break computer_choice = choice(OPTIONS) # Escolhe a opção do computador _jokenpo( user_choice=user_choice, computer_choice=computer_choice, )

Disclaimer: Nunca faça isso na real! Python tem uma natureza funcional muito boa (não tão boa quanto linguagens funcionais, é claro), o que de certo modo faz ele similar com Javascript, utilizando closures e afins. Inclusive permite construções similares a esta abaixo: 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 def Pessoa(nome: str, sobrenome:str, idade:int): def getNome(): return nome def getSobrenome(): return sobrenome def getNomeCompleto(): return f'{nome} {sobrenome}' def getIdade(): return idade return { 'getNome': getNome, 'getSobrenome': getSobrenome, 'getNomeCompleto': getNomeCompleto, 'getIdade': getIdade, } p = Pessoa('Jar Jar', 'Binks', 38) print(p['getNomeCompleto'](), p['getIdade']()) Python não define um meio de criar objetos dinâmicos como Javascript, devido a sua forte tipagem, por isso usei a estrutura de dicionário. O que acontece na verdade é que devolvemos uma coleção de funções que acessam os atributos do “construtor” através de closures. ...

O processo é bem simples, porém é necessário antes configurar algumas coisas no Google Cloud e gerar as credenciais necessárias, para este processo pode seguir este tutorial. Lembre-se também de criar uma variável de ambiente com o nome GOOGLE_APPLICATION_CREDENTIALS apontando para o caminho do json, no Linux basta fazer: export GOOGLE_APPLICATION_CREDENTIALS=/caminho/para/arquivo.json Depois disso é possível executar o código abaixo (é claro, o bucket e o arquivo indicado deve existir): 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 from datetime import timezone, datetime from typing import BinaryIO from google.cloud import storage def upload_file( data: BinaryIO, bucket: str, file_path: str, link_lifetime: int = 3600 ) -> str: """ Função que realiza o upload do arquivo """ storage_client = storage.Client() bucket = storage_client.bucket(bucket) blob = bucket.blob(file_path) blob.upload_from_file(data) # Faz o upload do arquivo binário e cria um objeto associado ao arquivo lifetime = int( datetime.now(tz=timezone.utc).timestamp() ) + link_lifetime # Gera um link para o arquivo com tempo de expiração url = blob.generate_signed_url(lifetime) return def main(): bucket = 'meu-pequeno-bucket' # Bucket name in GCS file_name = 'arquivo_legal.pdf' # Filename with open(file_name, 'rb') as f: url = upload_file( data=f, bucket=bucket, file_path=file_name, ) print(f'URL for file: {url}') if __name__ == "__main__": main()