(dev) Lucas Polo

Criando ciclos - A maneira abrangente

Wed, 23 Sep 2026 00:10:23 -0300

Como usar seno e cosseno para criar ciclos suaves, controlando amplitude, período, linha central e fase, com gráficos e um exemplo em Python.

Sobre

Fri, 06 Mar 2026 11:44:08 -0300

Olá! Meu nome é Lucas, eu sou residente aqui do Brasil, radioamador, nerd e engenheiro de software. Gosto de ocasionalmente compartilhar o que estou aprendendo, principalmente para ajudar a consolidar os meus aprendizados.

Para acompanhar o blog, assine o RSS ou navegue pelo arquivo com todos os posts. Meus projetos ficam no GitHub.

Se precisar entrar em contato, mande um e-mail para contato [at] lucaspolo.dev

Coisas grátis para estudantes

Wed, 14 Jun 2023 23:52:00 +0000

Descontos e licenças gratuitas de software e serviços para estudantes, e como comprovar o vínculo com a instituição de ensino.

Feliz 2022!

Mon, 03 Jan 2022 12:00:00 +0000

Um recomeço para o blog em 2022 e materiais sobre covariância, contravariância e invariância em Python, C# e Scala.

Usando o operador de módulo para criar ciclos

Mon, 06 Dec 2021 14:20:00 +0000

Como o operador de módulo cria ciclos numéricos que voltam ao início, como contar de 0 a 5 e recomeçar, com exemplos em código.

Fazendo queries em JSON com jq

Mon, 22 Nov 2021 11:30:00 +0000

Como usar o jq para formatar, filtrar e transformar arquivos JSON na linha de comando, com exemplos de consultas, condições e interpolação.

Criando um bot no Telegram

Mon, 15 Nov 2021 11:30:00 +0000

Como criar um bot no Telegram com Python: registrar o bot no BotFather, responder comandos e consultar CEPs na API do ViaCEP.

Enviando SMS via Amazon Web Services SNS com Python

Mon, 08 Nov 2021 11:30:00 +0000

Como enviar SMS com o Amazon SNS em Python usando a biblioteca boto3, do usuário com permissão ao script de envio.

Gerando código que gera código

Mon, 01 Nov 2021 11:30:00 +0000

A ideia de geração de código do Programador Pragmático aplicada a um gerador de classes a partir de uma descrição simples.

Criando tarefas periódicas com o Celery Beat

Mon, 25 Oct 2021 11:30:00 +0000

Como agendar tarefas periódicas com o Celery Beat, executando tasks do Celery em intervalos ou horários definidos.

Utilizando conjuntos no Redis

Mon, 18 Oct 2021 11:30:00 +0000

Como usar os conjuntos (sets) do Redis para guardar valores únicos com SADD, SCARD, SISMEMBER, SPOP e SMEMBERS.

Manual básico do JUnit

Thu, 14 Oct 2021 11:30:00 +0000

Alguns anos atrás comecei a estudar TDD e como desenvolvia principalmente em Java na época comecei a aprender um pouco mais sobre o JUnit, o principal framework de testes de unidade do Java e um dos primeiros de todas as linguagens. Para me ajudar eu criei um pequeno manual prático sobre ele:

class SimpleSnipetJUnitTest {
 private Calculator calculator;
 /**
 * Este método é invocado antes de cada teste, a annotation
 * facilita isso
 */
 @Before
 public void setUp() {
 //Tudo aqui será executado antes, servindo por exemplo para inicializar.
 calculator = new Calculator();
 }

 /**
 * Este método é invocado após os testes, servindo, como exemplo, para liberar recursos.
 */
 @After
 public void finalize() {

 }

 /**
 * Teste comum, o método assertEquals realiza a operação de teste de igualdade.
 */
 @Test
 public void testeSimples() {
 int result;
 result = calculator.sum(1, 2);
 assertEquals(3, result);
 }

 /**
 * Teste para números de ponto flutuante.
 * Destaque para o terceiro parâmetro, o delta, que define
 * qual a diferença decimal entre cada parâmetro.
 */
 @Test
 public void testeDePontoFlutuante() {
 float result;
 result = calculator.divide(5, 2);
 //O terceiro parâmetro é a diferença máxima entre os floats
 assertEquals(2.5, result, 0.1)
 }

 /**
 * Teste para exceções
 * Se não disparar a exceção, o método falha.
 */
 @Test (expected= CalculatorException.class)
 public void testeDeExcecao() {
 int result;
 result = calculator.divide(5, 0);
 }
}

Fazendo upload de arquivos para o Google Cloud Storage com Python

Mon, 11 Oct 2021 11:30:00 +0000

Algum tempo atrás precisei aprender a fazer upload de arquivos para o Google Cloud Storage. Uma das coisas que eu gosto de fazer para me ajudar aprender a fazer algo é criar um scriptzinho com o conceito do que quero, sem aplicar em grandes projetos, evitando assim grandes complexidades.

Assim na época eu criei este script simples que faz o upload do arquivo em um bucket do GCS. A primeira coisa que você precisa fazer é ter instalada a biblioteca, para isso temos o bom e velho pip:

Medindo o tempo de aplicações de linha de comando

Thu, 07 Oct 2021 11:30:00 +0000

Vira e mexe precisamos testar o tempo de algo que roda em linha de comando, seja uma requisição através de cURL ou algum scripts/aplicação que construímos.

O jeito mais simples e onipresente nas interfaces de linha de comando do Linux é o time. Ele executa o comando passado para ele através de parâmetro e diz qual foi o tempo de execução:

Resultado da execução do time

O time pode ajudar muito, principalmente quando queremos comparar escalas de tempo muito diferentes, por exemplo uma mudança de código que mudou o tempo de execução de 1s para 100ms. Porém como a medida pode variar muito de execução devido a diversos fatores (cache, resolução de DNS, etc) testar apenas uma única vez pode não trazer resultados muito acurados, pois não temos tempo médio nem a variância do tempo. Para isso encontrei uma outra aplicação chamada hyperfine.

Casamento de padrões (Pattern Matching)

Mon, 04 Oct 2021 11:00:00 +0000

Há alguma tempo atrás eu aprendi um pouco de Scala, uma linguagem muito interessante que roda sobre a JVM. Apesar de ser muito similar ao Java a primeira vista logo depois de um pouco mais de aprendizado lidamos com recursos muito diferentes do que temos na linguagem mais velha. Um recurso que me surpreendeu foi o casamento de padrões, ou pattern matching em inglês e vou usa-la de exemplo aqui pois até onde conheço o pattern matching do Scala é um dos mais completos. Diversas outras linguagens implementam também o recurso de maneira similar e as vezes com um pouco menos de poder, por isso vale conferir a documentação antes de prosseguir.

O novo (mas nem tanto) switch/case do Java

Mon, 27 Sep 2021 11:30:00 +0000

Recentemente voltei a mexer mais com Java devido ao trabalho e também alguns conteúdos que eu estava acompanhando que utilizam a linguagem. Como estou utilizando o IntelliJ como IDE ela sugeriu algo muito interessante e que passei adotar sempre que posso, o nova sintaxe do switch/case.

A instrução switch case comum do Java segue algo muito similar a já implementada no C, um exemplo simples:

package com.company;

public class Main {

 public static void main(String[] args) {
 var nome = "Cebolinha";

 switch(nome) {
 case "Lucas":
 System.out.println("Bem vindo programador Lucas");
 break;
 case "Grace":
 System.out.println("Bem vinda programadora Grace Hopper");
 break;
 default:
 System.out.println("Bem vindx pessoa programadora " + nome);
 }
 }
}

Esta é a estrutura comum que já conhecemos, como você pode ver temos os casos específicos que tratamos, o caso padrão e para que a avaliação do switch/case pare precisamos utilizar a clausula break, o que chega a me dar “gastura” em switch/cases muito grandes.

Pytest: Pequeno manual para o dia a dia - Fixtures

Mon, 20 Sep 2021 11:00:00 +0000

Depois que comecei a programar em Python no dia a dia eu me deparei com uma das ferramentas mais legais de teste que conheci, o Pytest. Por padrão o Python já vem com uma ferramenta de testes chamada Unittest, que é muito boa e funcional, porém como ela foi criada junto com o Python algumas arestas dela ficaram soltas, principalmente por não utilizar toda a potência que a própria linguagem oferece. Aqui eu vou deixar algumas coisas muito interessantes que uso no meu dia a dia e como podem servir principalmente como um guia rápido do Pytest.

Quem programa as linguagens de programação?

Mon, 13 Sep 2021 11:00:00 +0000

Acredito que todo programador já se perguntou ou irá se perguntar como as linguagens de programação são feitas, principalmente se você não teve nenhuma disciplina como compiladores na faculdade. Eu me fiz essa pergunta algumas vezes e aprendi muito com ela. Se você pesquisar na internet sobre como compiladores são feitos ou perguntar por ai um dos conteúdos que irá descobrir é o excelente, porém bem complexo para iniciantes, Compiladores: Princípios, técnicas e ferramentas de Alfred V. Aho Et al.

Escrevendo um sistema operacional em Rust de Philipp Oppermann

Mon, 06 Sep 2021 11:30:00 +0000

Eu me lembro que em 2008 eu imaginei como seria criar um sistema operacional e na época eu busquei algo na internet para fazer uma introdução no assunto. Eu lembro que a primeira coisa que imaginei foi que pelo menos a “entrada” do sistema operacional precisaria ser escrita em Assembly. Procurando pela internet algo como “fazer um Hello World bootável”, ou como criar um programa que não precisa de sistema operacional para escrever algo na tela. Lembro-me que encontrei algo em C sobre um tal de endereço 0x800000 mas ficou por isso mesmo, na época o assunto estava muito além do que eu conseguia fazer facilmente e também não continuei aprendendo para entender como fazer algo.

Fazendo queries SQL em arquivos CSV

Thu, 02 Sep 2021 11:30:00 +0000

Vira e mexe eu recebo alguns arquivos CSV que preciso fazer algum filtro ou alguma análise. Eu gosto muito de usar o Python para alguns processamentos, mas não é a coisa mais prática do mundo, ou abrir um script ou abrir um Jupyter Notebook para essa análise. Foi então que descobri que o DBeaver pode nos ajudar com este processo e é muito simples.

Após abrirmos o DBeaver basta criarmos uma nova conexão e selecionarmos o diretório onde constará o(s) arquivo(s) CSV.

Realizando commits parciais no Git

Mon, 30 Aug 2021 14:00:00 +0000

Durante o desenvolvimento é comum alterarmos o mesmo arquivo diversas vezes e se você gosta de manter um histórico consistente de suas alterações você pode esbarrar na situação onde um arquivo foi alterado em mais de um ponto e quer separar em commits distintos essas alterações.

Pra exemplificar este aqui é o código que iremos trabalhar:

from collections import namedtuple

Cliente = namedtuple('Cliente', 'nome,idade'.split(','))

def inserir_cliente(cliente):
 print(f'Cliente {cliente.nome} inserido com sucesso')

 return 'ok'


def test_inserir_cliente():
 cliente = Cliente("Monicão", 3)

 resultado = inserir_cliente(cliente)

 assert resultado == 'ok'

Agora o que queremos fazer é adicionar uma função que verifica se o cliente é valido (o nome deverá ter mais de três caracteres e a idade deve ser um número maior ou igual a zero).

O jeito pythonico das propriedades no Python - Parte 2

Mon, 23 Aug 2021 11:01:00 +0000

Este post é uma sequência deste outro post sobre os getters, vale apena conferi-lo antes.

Após entendermos melhor como funcionam as propriedades em Python e aplicarmos os getters em nossa classe Circulo, ficamos com a pendência de entender como podemos agora aplicarmos os setters. O principio é muito similar e simples. Para isso basta definirmos o método em questão e decorá-lo com @nome_da_propriedade.setter.

import math

class Circulo:
 def __init__(self, raio):
 self._raio = raio

 @property
 def raio(self):
 return self._raio

 @property
 def area(self):
 return self.raio ** 2 * math.pi

 @property
 def circunferencia(self):
 return self.raio * 2 * math.pi

 @raio.setter
 def raio(self, value):
 assert value > 0, 'O valor do raio deve ser maior que 0'
 self._raio = value


c = Circulo(5)
print(c.area)
c.raio = -1

Aproveitei também para já colocar uma validação no método e passei a utilizá-lo no método __init__. A criação é muito simples e prática, apesar de a API do setter não ser tão intuitiva, seu funcionamento é tão simples como a criação dos getters. Por se tratar um método podemos inclusive fazer outras computações nele, como por exemplo criar um setter para a área:

Visualizando diferenças de código de maneira mais simples com o Delta

Thu, 19 Aug 2021 14:00:00 +0000

Eu sempre tive um pouco de dificuldade de assimilar as diferenças de código do jeito padrão do Git, que é feita da forma padrão do diff do GNU/Linux. É algo que vem muito com o hábito e em arquivos pequenos é até mais simples visualizar as diferenças:

Visualização de diferença com o diff padrão

O jeito pythonico das propriedades no Python - Parte 1

Mon, 16 Aug 2021 14:00:00 +0000

Uma constante na orientação a objetos é a presença de propriedades dentro dos objetos quando precisamos armazenar dados para alguma manipulação posterior. É muito comum, principalmente quando viemos de outras linguagens, criarmos os famosos getters and setters para manter também um bom nível de encapsulamento. Vamos ter como exemplo a classe Circulo abaixo:

import math

class Circulo:
 def __init__(self, raio):
 self.raio = raio

 def area(self):
 return self.raio ** 2 * math.pi

 def circunferencia(self):
 return self.raio * 2 * math.pi


c = Circulo(1)
print(c.raio)
print(c.area())
print(c.circunferencia())

Perceba que para definirmos um círculo temos que passar o seu raio, com isso podemos calcular facilmente a sua área e circunferência. Precisamos também acessar ocasionalmente esse raio, podemos fazer isso através de dos getters que comentamos, mas isso não é o jeito do Python, ou como falaremos, o jeito mais Pythonico.

Minha aventura com o DNS no Ubuntu - meu primeiro contato com o systemd

Mon, 09 Aug 2021 14:30:00 +0000

Há algum tempo eu precisei mexer com as configurações de DNS no meu computador para conseguir utilizar o excelente projeto Pi Hole. Para quem não conhece, o Pi Hole é um projeto de servidor de DNS que possui uma lista de servidores de propaganda e bloqueia elas. Ele é excelente pois ao contrário dos Ad-Blockers ele não é tão facilmente detectável e como o bloqueio ocorre já na requisição de DNS ele também ajuda a economizar banda.

Analisando queries no PostgreSQL

Mon, 02 Aug 2021 14:00:00 +0000

O banco de dados é uma das partes mais importantes de qualquer aplicação e da mesma forma que as linguagens de programação que usamos, as vezes é necessário depurar o que está acontecendo dentro dele.

Uma das coisas que sempre devemos fazer ao digitar uma query nova que será utilizada pelo nosso programa é analisar o seu custo computacional no banco. Para conseguirmos fazer isso no PostgreSQL basta ativarmos uma diretriz antes da query (usaremos um banco de dados de filmes como exemplos que peguei aqui):

O problema de Monty Hall e como estatística não é algo intuitivo

Thu, 29 Jul 2021 14:00:00 +0000

Quando estudamos estatística é muito comum esbarrarmos no problema de Monty Hall. Monty Hall era um programa de TV onde o apresentador oferecia três portas para uma pessoa, atrás de uma delas havia um prêmio e das outras duas alguma coisa desagradável para dar o tom de humor do programa. Aqui no Brasil tinhamos o nosso equivalente apresentado pelo Sérgio Malandra, a Porta dos Desesperados. Aqui temos uma explicação do problema com sua solução:

Melhorando as requisições assíncronas com Python - Parte 3

Mon, 26 Jul 2021 13:45:00 +0000

Este post é uma continuidade dos posts Lendo arquivos CSV em Python e fazendo requisições e do post Fazendo requests concorrentemente (assíncronas) no Python

Após fazermos as requests assíncronas no último post obtivemos uma melhoria signifcativa em nosso processamento, conseguindo paralelizar as requests e reduzindo muito o tempo. Porém não estamos fazendo o melhor proveito da API async do Python, percebam que cada função async também é responsável por também imprimir o resultado e o ideal seria retornarmos os resultados para tratar posteriormente. Vamos fazer isso:

Executando scripts no banco PostgreSQL com o psql

Thu, 22 Jul 2021 14:00:00 +0000

As vezes precisamos executar scripts grandes, como inserir uma massa de dados muito grande ou fazer diversas queries ao mesmo tempo. As ferramentas de bancos de dados ajudam muito nisso, mas as vezes o script pode ser tão grande que a ferramenta não aguenta e pode encher muito a memória (caso que aconteceu comigo recentemente onde o DBeaver tinha onze mil inserts para fazer).

Felizmente existe uma ferramenta de linha de comando muito prática chamada psql, ele é mantido também pelas mesmas pessoas do PostgreSQL e é muito eficiente. O psql é um utilitário de linha de comando que permite executar comandos no banco de dados e também executar scripts em lote. Um exemplo de execução poderia ser assim:

Adicionando alterações em commits antigos com o rebase interativo

Mon, 19 Jul 2021 14:00:00 +0000

Durante o desenvolvimento é muito comum encontrarmos alterações para fazermos em arquivos que já foram alterados e não estão mais no último PR. Para não gerar um grande número commits de ajustes pequenos podemos reorganizar estas alterações utilizando o rebase interativo.

Preciso deixar apenas um aviso importante, como alteramos a ordem dos commits isso irá gerar uma reescrita de histórico de commits, assim caso você já tenha feito o push da versão anterior para uma branch remota será necessário refazer o procedimento com o famigerado –force, o que pode trazer perdas de commits caso essa branch esteja sendo usada por outra pessoa, outro ponto, evite fazer reescrita de histórico na branch principal do projeto.

Achados: aprendendo Node.js

Thu, 15 Jul 2021 14:00:00 +0000

Comecei a trabalhar recentemente com Node.js e estou curtindo bastante as particularidades dele. Além do Javascript existe todo um mundo de conceitos por trás do Node.js, na forma como ele foi construido e sua arquitetura.

A único “defeito” do Node.js para mim, que na verdade é algo do Javascript, é que se você for iniciante em programação logo de cara terá que lidar com a questão de programação concorrente, eventos e coisas um pouco mais complexas, o que em outras linguagens muitas vezes ficam para um segundo momento serem aprendidas.

Fazendo requests concorrentemente (assíncronas) no Python - Parte 2

Mon, 12 Jul 2021 14:30:00 +0000

Este post é uma continuação direta do post Lendo arquivos CSV em Python e fazendo requisições - Parte 1

Depois de conseguirmos ler o CSV e conseguirmos fazer requisições em lote, podemos agora iniciar uma primeira otimização, realizar as cotações em paralelo. Para isto usaremos a API assíncrona do Python em conjunto com uma nova biblioteca de requests, a HTTPX.

A primeira coisa que faremos é alterar a biblioteca Python que utilizamos, adaptar a requisição e nosso programa para começar a trabalhar assíncronamente. As alterações são principalmente na definição das funções e também nas mudanças para as chamadas das funções assíncronas que agora precisam do await antes:

Aprendendo a desenvolver jogos

Thu, 08 Jul 2021 14:30:00 +0000

Já faz algum tempo em que estou interessado a aprender a desenvolver jogos, apenas por diversão e aprendizado mesmo. A área de desenvolvimento de jogos tem algumas coisas muito diferentes do desenvolvimento que estou acostumado, por exemplo, em alguns momentos é comum carregar tudo na memória no inicio da execução para depois só ir exibindo, algo que as vezes pode ser dispendioso em um programa que precisa atender diversas requisições o mais rápido possível.

A infraestrutura da minha mesa

Mon, 05 Jul 2021 14:30:00 +0000

Recentemente tirei uma certificação de analista de infraestrtura da minha mesa! 😂

Piadas a parte, consegui deixar minha mesa de trabalho muito organizada utilizando alguns acessórios bem diferentes. Possuo dois computadores, sendo um notebook do trabalho e o meu desktop onde estudo, programo e jogo. Além dos computadores tenho dois monitores na minha mesa, um na vertical que costumo trabalhar dividido em dois (muito útil para deixar chats abertos) e outro widescreen (que também costuma trabalhar dividido) na horizontal.

Pequeno achado: Por que numeração deve iniciar em zero? De Edsger Dijkstra

Thu, 01 Jul 2021 14:00:00 +0000

Talvez você não conheça, mas Edsger W. Dijkstra é um dos nomes mais proeminentes da história da ciência da computação, sendo uma das pessoas que trabalhou na área ainda nos primeiros protótipos de computadores. Caso você tenha estudado algoritmos já deve ter esbarrado no algoritmo de Dijkstra, que é para encontrar o menor caminho em grafos, mas caso ainda não tenha esbarrado em nenhum trabalho dele, vale apena conhecer este artigo (em inglês) em que ele explica por que a número em sequências numéricas deve iniciar em zero, artigo indicado no excelente livro Python Fluente do Luciano Ramalho.

Lendo arquivos CSV em Python e fazendo requisições - Parte 1

Mon, 28 Jun 2021 14:30:00 +0000

Algumas vezes surge a necessidade de fazermos algum processamento em uma base de dados, como requisições e afins. É muito comum neste momento recebermos um CSV ou até mesmo uma planilha do Excel, ai neste momento devemos escrever um script que processe essa informação. Suponhamos que precisamos atualizar o nome de algum cliente dado seus id’s e nomes, seguindo um arquivo neste modelo:

id,nome
1,Cebolinha
2,Monica
3,Magali
4,Cascão
5,Penadinho
6,Alminha
7,Horácio

A abordagem mais simples que eu sigo é iniciar criando uma função primária, que no geral chamo de main e iterar no arquivo CSV usando um DictReader:

Fira Code: a fonte para programadores

Thu, 24 Jun 2021 14:30:00 +0000

As vezes não nos atentamos aos pequenos detalhes da nosso dia a dia, e após anos programando e lendo código eu esbarrei numa coisa muito interessante: fontes para desenvolvedores.

Estas fontes específicas para programação ajudam a realçar algumas características específicas do nosso cotidiano, como simbolos e outros detalhes, como também proprorcionam uma leitura agradável do código.

A que venho usando nos último tempos é a Fira Code, uma fonte criada com uma funcionalide muito interessante, as ligaturas, que são conexões entre simbolos que semanticamente significam uma única coisa. Por exemplo, por mais que >= sejam dois simbolos, o significado é únificado, assim a Fira Code faz o seguinte quando utilizamos ele:

O poder do coletivo e o caminho das formigas

Mon, 21 Jun 2021 14:00:00 +0000

Alguns anos atrás esbarrei em um vídeo incrível do Nerdologia sobre O poder do Coletivo, que falava como a inteligência das populações poderiam chegar em resultados excelentes para diversas questões (salvo algumas exceções, como polarizações). Todo esse conceito anda lado a lado com o conceito de Big Data e inteligência artifical, onde analisando dados individuais podemos chegar a resultados ótimos pois o erro da multidão tende a se aproximar de zero:

Dependências de montagem (build) do Python

Thu, 17 Jun 2021 14:30:00 +0000

Ocasionalmente precisamos instalar o Python na máquina montando (buildando) ele pelo código fonte, seja através de ferramentas como o pyenv ou o asdf como até manualmente. Para isso são necessárias algumas bibliotecas instaladas, segue a lista delas e o comando para instalar em sistemas baseados no Debian:

sudo apt-get install dpkg-dev \
 build-essential \
 python-dev \
 python3-dev \
 libncursesw5-dev \
 libsqlite3-dev \
 libreadline-dev \
 libbz2-dev \
 libffi-dev \
 libssl-dev \
 libgdbm-dev \
 zlib1g-dev \
 libjpeg-dev \
 libtiff-dev \
 libpq-dev \
 libxml2-dev \
 libxslt1-dev \
 libsdl2-dev \
 libsm-dev \
 libxtst-dev \
 libcurl4-openssl-dev

Resenha do Livro: Fundamentos de Algoritmos para Jogos Digitais de David Santos

Mon, 14 Jun 2021 14:00:00 +0000

Recentemente eu estava em uma empreitada para aprender um pouco mais sobre desenvolvimento de jogos e comecei a procurar alguns materiais na internet. Hoje em dia boa parte desses materiais são voltados para os grandes frameworks de desenvolvimento de jogos, como o Unit, o que é muito interessante, pois além de facilitarem fazer coisas complexas também já se encaixam com os requisitos do mercado que adotam em massa estes frameworks. Porém eu não estava necessariamente querendo aprender a fazer coisas complexas, mas aprender as bases do desenvolvimento de jogos e tive uma grata surpresa ao descobrir o livro Fundamentos de algoritmos para jogos digitais do David V. Santiago (versão Java).

Criando entradas de desktop no Ubuntu

Fri, 11 Jun 2021 01:09:00 +0000

Ocasionalmente baixamos diretamente o binário ou até mesmo criamos as nossas aplicações e queremos que elas apareçam na lista de aplicações do Ubuntu com icones e tudo. Para fazer isso é bem simples, basta criar um arquivo no diretório ~/.local/share/applications/, exemplo ~/.local/share/applications/meu_aplicativo.desktop. Depois disso basta preencher o arquivo com o seguinte formato:

[Desktop Entry]
Encoding=UTF-8
Name=Nome da Aplicação
Exec=/caminho/para/executavel
Icon=/caminho/para/imagem/do/icone
Terminal=false
Type=Application
Categories=Development;

Agora já estará disponível o ícone na lista de aplicativos e você poderá invocar o aplicativo pelo launcher.

Minhas ferramentas do dia a dia - Aplicações

Mon, 07 Jun 2021 14:30:00 +0000

No dia a dia utilizo muitas aplicações para auxiliar no meu processo de trabalho, as principais são estas:

DBeaver Community: este aqui é um destaque, aplicativo que permite acesso a diversos bancos de dados para gerenciamento e execução de queries. Já utilizei ele com PostgreSQL, MySQL, SQLite, MS SQL Server, Oracle e até Informix. Não digo que ele é perfeito, mas como permite a utilização com diversos bancos, é muito prático pois mantém tudo concentrado num único app.

Achados - Cheat Sheet fácil e rápido

Thu, 03 Jun 2021 12:35:00 +0000

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.

Minhas ferramentas do dia a dia - Compiladores, Interpretadores, IDEs e Editores

Mon, 31 May 2021 14:40:00 +0000

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)

Achados - Rust Cheat Sheet

Thu, 27 May 2021 14:30:00 +0000

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!

Minhas ferramentas do dia a dia - Sistemas operacionais e Terminal

Tue, 25 May 2021 03:19:00 +0000

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.

Meus pequenos aprendizados diários

Mon, 26 Apr 2021 00:12:00 +0000

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

Programação Orientada a ob... classes

Tue, 12 May 2020 09:31:00 +0000

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?

Micro tutorial de como funcionam corrotinas

Sun, 29 Mar 2020 00:18:00 +0000

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())

JoKenPo em Python

Tue, 11 Feb 2020 00:23:00 +0000

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.

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,
 )

Python que nem Javascript!

Sun, 19 Jan 2020 23:20:00 +0000

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:

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.

Fazendo upload de arquivos para o Google Cloud Storage com Python (versão de 2020)

Fri, 10 Jan 2020 15:52:00 +0000

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):

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()

Pense sobre o seu trabalho - O programador pragmático

Mon, 06 Jan 2020 23:53:00 +0000

Os dias não são fáceis, você acorda cedo e se desloca para o seu trabalho, então você faz algumas coisas e chega o fim do dia, você faz o caminho inverso para sua casa. No fim do mês você é pago por isso, o que é bom, e se for da área de TI, é “mais bom” do que 90% do restante do Brasil.

Agora voltemos ao “faz algumas coisas” do paragrafo acima, que coisas são essas? Onde você aprendeu elas? Como lida com elas? Todas essas coisas são a sua profissão, mas o que é profissão? Será que é apenas o seu trabalho? Aquilo que você é pago para fazer? Vamos buscar a definição de profissão:

Drops: Quicksort em Python

Fri, 03 Jan 2020 14:16:00 +0000

from typing import List


def quicksort(l: List):
 """
 Recebe uma lista de elementos e devolve eles ordenados
 """

 # Caso base! Nunca se esqueça disso em funções recursivas@
 if not len(l):
 return l

 # Escolhemos um pivot, removemos ele da lista!
 # Reduzir a entrada também é essêncial!
 pivot = l.pop(0)

 # Separamos os elementos menores
 lower = [e for e in l if e <= pivot]
 # Separamos os maiores
 uppper = [e for e in l if e > pivot]

 # Os menores ficam na esquerda do pivo
 # Os maiores ficam na direita
 # Ai acontece a magia da recursão... 
 # Ordedamos os menores e os maiores com a mesma função.
 return quicksort(lower) + [pivot] + quicksort(uppper)


def main():
 elems = [3,2,3,6,7,4,2,-1]

 print(quicksort(elems))


if __name__ == '__main__':
 main()

O caminho do programador (pragmático) - Um pouco sobre a primeira edição do Programador Pragmático

Tue, 31 Dec 2019 01:53:00 +0000

Disclaimer: Este post é o primeiro de uma série sobre o livro O Programador Pragmático, tratando sobre a primeira edição, caso deseje compra-lo dá uma conferida no último parágrafo (o que já irá acontecer se você ler o post inteiro).

Durante nossas carreiras existem alguns momentos enigmáticos que nos fazem refletir sobre o que realmente queremos para o nosso futuro, sobre o profissional que queremos ser e como iremos nos portar pelos próximos anos. Tais momentos são motivados por diversos fatores, como um perrengue no trabalho, um professor que sabe te direcionar, a comunidade, ou como é no caso, um livro.

Utilizando Celery junto com o SQS

Sun, 17 Mar 2019 23:36:00 +0000

Uma das formas de lidar com processamento assíncrono no Python (e diversas outras linguagens) sem a necessidade de usar threads e afins é utilizando filas e tasks (que são aplicações que rodam conforme demanda, em um processamento similar a batches).

Para isso o Python dispõe de uma biblioteca chamada Celery, que de uma maneira bem simples permite realizar o processamento assíncrono. Explicando de uma maneira simples, ao invocar uma função, ao invés de executar seu código, o Celery pega os parâmetros e mais algumas meta-informações da chamada e coloca numa fila, enquanto isso, em outro lugar (processo, computador ou continente), o Celery captura as mensagens desta fila e dispara as tasks. Aqui está uma implementação básica de uma task que soma dois valores:

Usando terminal e programando em Python no Android

Mon, 25 Feb 2019 01:59:00 +0000

O terminal é uma das ferramentas mais poderosas que temos ao manipular informações no computador, desde o desenvolvimento de software até o hacking, passando por manipulação de texto, administração de sistemas e também para algumas brincadeiras. O acesso ao terminal é simples quando você está dentro de um Linux no computador (e até no Windows agora), porém nem sempre temos um notebook por perto, que por mais que seja portátil, não é simples de carregar por ai. Então, nas pesquisas pela internet, buscando uma alternativa para o tablet e smartphone, eu encontrei o Termux.

Construindo um interpretador de Lisp em Python

Tue, 22 Jan 2019 23:48:00 +0000

Ultimamente tenho me interessado cada vez mais em como linguagens de programação funcionam e encontrei um material bem legal, simples e prático para ajudar nos estudos. É um artigo do Peter Norvig sobre como criar um interpretador de Scheme em Python, confira: http://norvig.com/lispy.html

Git Squash: Agregando seus commits em um só!

Fri, 11 Jan 2019 13:00:00 +0000

Durante o processo de desenvolvimento de software é comum que ao criarmos mais código, possamos enviar ele para o repositório de código, assim os colegas podem acompanhar o que está sendo alterado e também você criar um backup de suas informação.

Mas surge uma dúvida na cabeça do programador: qual é o mínimo de código que deve criar antes de realizar um commit? Uma linha? Duas? Cem? Fica complexo definir isso, pois se criarmos muitos commits a nossa funcionalidade nova não fica atômica, mas se demorarmos para commitar e enviar para o repositório, corremos o risco de criar um commit grande demais para review, além é claro do risco de perder o código local.

Desempacotando parâmetros em Python

Fri, 04 Jan 2019 13:00:00 +0000

Uma das coisas mais interessantes do Python é como ele interage com as suas estruturas de dados padrão, sendo um dos exemplos mais interessantes o desempacotamento de listas e dicionários. A situação é simples, vamos supor que você tenha uma lista de parâmetros e deseja passar para uma função, podemos testar a seguinte situação:

def funcao(parametro1, parametro2, parametro3):
 print(parametro1, parametro2, parametro3)


parametros = [1,2,3]

funcao(parametros)

Mas temos o seguinte erro:

Um pouco sobre cálculo lambda

Thu, 25 Oct 2018 22:11:00 +0000

Rodando automaticamente o Flake8 antes de todos os commits do Git

Fri, 06 Jul 2018 14:00:00 +0000

Quando programamos em Python é importante verificarmos se o nosso código está de acordo com a PEP 8, seguindo seu guia de estilos. Para isto muitas vezes rodamos o Flake8, que é uma aplicação que analisa o nosso código e avalia o que está seguindo e não está seguindo as boas práticas da PEP 8.

Para instalar o Flake8 é muito simples, basta rodarmos o comando:

pip install flake8

Após instalarmos para podermos avaliar nosso código no diretório atual basta executarmos o comando:

Acessando webservices SOAP em Python

Sat, 16 Jun 2018 01:09:00 +0000

Apesar da grande adoção de REST para a criação de webservices, ainda é muito comum (e necessário) termos que trocar mensagens com sistemas legados, inclusive em outras linguagens como Java e .NET, assim poder fazer em chamadas a endpoints SOAP se torna necessário muitas vezes.

Esta necessidade surgiu para mim quando vi que testar serviços em SOAP seria muito mais fácil ser feito em Python, devido sua sintaxe idiomática e scripts muito simples de serem construídos. Buscando nas “internets” eu descobri uma biblioteca chamada Zeep, que de tão simples que é o seu acesso não compensa nem discutir muito, mas já irmos direto ao código, utilizando o webservice dos Correios:

Nashorn: Javascript sobre a JVM

Tue, 22 Aug 2017 01:23:00 +0000

Programar em Java está cada vez mais rápido e simples, desde as mudanças que começaram a surgir na versão 7 do Java, a verbosidade característica da linguagem foi reduzindo e agora no Java 8 alcançamos um nível muito superior com a programação funcional presente na linguagem.

Porém, muitos ainda dizem que estas funcionalidades chegaram um pouco atrasadas na linguagem, e durante este tempo que ainda não tinhamos a programação funcional presente no Java, foram surgindo outras linguagens sobre a JVM que visavam trazer novos paradigmas para os programadores.

Iterando sobre uma matriz com um único loop

Sat, 16 Jul 2016 15:26:00 +0000

Quando estamos nas aulas iniciais de programação, aprendemos a iterar sobre vetores e matrizes, sendo que no segundo caso é necessário criar um loop (for, while e etc) para cada dimensão de nossa matriz. Desta forma criamos muitas vezes um código com vários níveis de aninhamento no nosso código.

Uma outra forma de lidar com isto é criando uma forma de a partir de um único índice extrair o valores dos sub-índices, uma tarefa simples se utilizarmos módulo.

Encurtando links em Java usando o Migre.me

Sun, 18 May 2014 18:59:00 +0000

Uma pequena forma de como usar o Migre.me dentro de sua aplicação para encurtar URLs. A requisição é feita utilizando alguns componentes da especificação JAX-RS, utilizando o Jersey como implementação.

Para fazer parser do JSON recebido, utilizamos o Jackson, o que deixa as coisas muito simples.

package br.com.lucaspolo.json.teste;

import java.net.URI;
import java.net.URISyntaxException;
import java.util.HashMap;
import java.util.Map;

import javax.naming.LimitExceededException;
import javax.ws.rs.client.Client;
import javax.ws.rs.client.ClientBuilder;
import javax.ws.rs.client.WebTarget;
import javax.ws.rs.core.Link;

import org.codehaus.jackson.map.ObjectMapper;
import org.codehaus.jackson.type.TypeReference;

/**
 * @author lucaspolo
 * Classe de teste que faz a requisição do migre.me, encurta a URL e converte em um Hash.
 * A dica do parser para Map foi retirada de
 * {@link http://www.mkyong.com/java/how-to-convert-java-map-to-from-json-jackson/}
 * O POM com as dependencias do Maven para rodar este exemplo é este
 * {@link https://gist.github.com/lucaspolo/7a2a0ea33f3ce0c93975}
 */
public class App
{
 public static void main( String[] args ) throws Exception
 {
 URI uri = new URI("http://migre.me/api.json?");
 Client client = ClientBuilder.newClient();
 WebTarget target = client.target(uri.toURL().toString())
 .queryParam("url", "http://www.ocaminhodoprogramador.com.br");
 String conteudo = target.request().get(String.class);
 System.out.println(conteudo);

 Map<String, String> map = new HashMap<>();
 ObjectMapper mapper = new ObjectMapper();

 map = mapper.readValue(conteudo, new TypeReference<HashMap<String, String>>() {});
 System.out.println(map.get("migre"));
 }
}

Dando um close no Java 7: AutoCloseable

Sun, 16 Mar 2014 14:16:00 +0000

Gerenciar recursos sempre foi algo muito chato, principalmente quando parte do ciclo de vida do objeto é fecha-lo, senão você poderá ter problemas na execução do seu programa. Vamos por exemplo analisar um código que abre um arquivo e itera sobre ele exibindo seu conteúdo linha a linha:

FileReader readerAntigo = null;
try {
 readerAntigo = new FileReader("arquivo.txt");
 Scanner scanner = new Scanner(readerAntigo);
 while(scanner.hasNext()) {
 System.out.println(scanner.next());
 }
} catch (FileNotFoundException e ) {
 System.out.println("Arquivo não encontrado");
} finally {
 try {
 readerAntigo.close();
 } catch (IOException e) {
 System.out.println("Erro ao fechar o arquivo");
 }
}

Perceba como é chato gerenciar o arquivo, para que eu possa abrir e fechar são necessário duas capturas de sessão, sem contar que ainda é necessário que o programador lembre-se de fechar o arquivo, algo que não pode ser tão crítico, mas se imaginarmos conexões JDBC, logo o banco começará a recusar conexões pois esquecemos de fecha-las anteriormente.

Mapeando e Reduzindo - Java 8

Thu, 06 Mar 2014 14:00:00 +0000

As vezes precisamos processar dados em um volume maior, onde é necessário filtrar a informação, selecionar ou alterar o que queremos para depois realizar o processamento. Como exemplo, vamos imaginar uma lista de alunos, onde cada instância tem seu nome e nota. Desta lista queremos a média geral, a média dos alunos aprovados (ou seja, quem tirou nota seis ou mais) e a média dos reprovados (nota menor que seis). Para isso, vamos primeiro visualizar nossa lista:

Filtrando resultados (Predicados) - Java 8

Sun, 02 Mar 2014 14:51:00 +0000

Muitas vezes precisamos filtrar listas, listas de todos os tipos, desde números básicos, passando por Strings, até tipos complexos. Abaixo temos um exemplo simples disto, onde temos uma lista com alguns nomes e queremos filtra-la e exibi-la para o usuário (no caso, todos os nomes que tiverem a letra “u” serão exibidos):

List<String> nomes = new ArrayList<>();

nomes.add("João da Silva");
nomes.add("Joaquim da Padaria");
nomes.add("Lucas Polo");
nomes.add("Chaves");

List<String> nomesFiltrados = new ArrayList<>();

System.out.println("Iniciando filtragem");

for (String nome : nomes) {
 System.out.println("Avaliando: " + nome);
 if (nome.contains("u")) nomesFiltrados.add(nome);
}

System.out.println("Iniciando impressão");

for (String nome : nomesFiltrados) {
 System.out.println(nome);
}

A saida é:
Iniciando filtragem
Avaliando: João da Silva
Avaliando: Joaquim da Padaria
Avaliando: Lucas Polo
Avaliando: Chaves
Iniciando impressão
Joaquim da Padaria
Lucas Polo

Repare que primeiros os resultados são filtrados e depois exibidos, mas variando com o tamanho da lista, pode demorar muito tempo para filtrarmos uma lista inteira, e por isso, muitas vezes, é melhor avaliar se o elemento passa no filtro e trata-lo devidamente, ganhando assim mais velocidade. Na programação funcional, temos um meio de lidar com isso, chamado avaliação preguiçosa.

Inversão de Controle e Injeção de Dependências

Mon, 23 Sep 2013 16:37:00 +0000

Quando comecei a programar na escola (curso técnico que fiz na época), comecei em uma das linguagens mais legais e, de certo modo, estranha que existe, a linguagem C. Alguns conceitos dela não são claros logo de inicio, pois não fazem nenhum paralelo com o mundo real. Um deles é o conceito de ponteiros e alocação de memória, onde você dinamicamente pode alocar memória para seu programa utilizar. Porém, como dizia o Tio Ben: “Grandes poderes trazem grandes responsabilidades”, logo você se via obrigado a “lembrar” de liberar toda a memória alocada quando não fizesse mais uso dela, senão seu programa logo travaria junto com o seu sistema operacional.

Métodos como parâmetros - Java 8

Sun, 22 Sep 2013 22:45:00 +0000

O Java 8 que será lançado em breve e já possui versões de teste disponíveis para download tem uma novidade interessante, que é tratar métodos como objetos (criando assim o suporte a funções Lambda). Uma vez que métodos podem ser tratados como objetos, você pode passa-los como parâmetro ou cria-los em tempo de execução.

Vamos dissecar mais sobre essas novidades no decorrer do tempo, mas por enquanto vamos ver um exemplo do que podemos fazer. Antigamente, para ler um arquivo e imprimir o seu conteúdo linha a linha poderíamos fazer algo assim:

Desconstruindo a orientação a objetos: Encapsulando de verdade os seus atributos

Fri, 20 Sep 2013 02:07:00 +0000

Existe uma lei que rege todos os lugares do mundo, em todos os planos e dimensões. Esta lei é a Lei de Murphy, dizendo que você pode morrer e virar um superpolicial robô chamado Robocop. Brincadeiras a parte, a Lei de Murphy diz basicamente que se algo pode dar errado, isto irá dar errado, ou seja, você não deve deixar nenhuma fresta onde o erro pode ocorrer. O seu criador, Edward A. Murphy, um engenheiro aeroespacial, dizia que nunca devemos deixar uma brecha no projeto, pois será neste ponto onde ocorrerá a falha, e como muitas outras coisas que vieram do mundo da engenharia para a informática, esta lei também veio para o nosso ambiente.

Desconstruindo a Orientação a Objetos (ou esquecendo o que você aprendeu na escola) - Parte 1

Wed, 18 Sep 2013 00:39:00 +0000

Lembro-me como se fosse ontem (que poético isso) a primeira vez que eu ouvi sobre a orientação a objetos. Depois de muito tempo lidando com linguagens puramente procedurais (C, COBOL, Visual Basic), eu ouvi falar sobre esse novo paradigma e é claro, sobre uma das linguagens que usa ele, o Java. A primeira coisa que eu ouvi foi “a orientação a objetos é ótima para construir interfaces gráficas”, e eu sei, que se você tem o mínimo de noção sobre o que é orientação a objetos, sabe que isso foi uma enorme canelada*.

Syntax highlighting no blog

Tue, 17 Sep 2013 01:27:00 +0000

Não podemos ter um blog de programação sem uma das coisas mais úteis que o programador usa para destacar a facilitar a leitura de seu código, o syntax highlight! Uma rápida pesquisa me retornou uma das bibliotecas mais usadas para tratar isso, o SyntaxHighlighter.

Sua instalação é muito simples, em dois minutos eu consegui incorporar as bibliotecas no blog e já fiz o código a seguir usando ele.

Um pequeno teste, instalando o SyntaxHighlighter no blog:

Qual o caminho do programador?

Sun, 15 Sep 2013 21:42:00 +0000

A pergunta do título com certeza tem mais de uma resposta, se você está na área de desenvolvimento já sabe disso. Uma pessoa que escolhe ser programador, apesar de ter filtrado todas as possíveis áreas da tecnologia da informação (aka T.I.), ainda precisa se decidir dentro da área de desenvolvimento o que fazer, quais tecnologias usar, quais paradigmas dominar e por ai segue. Trilhar esse caminho da maneira correta, sabendo quais escolhas fazer, o quer deixar para trás e para onde ir é o que separa os que apenas trabalham na área dos que realmente gostam de programar.