-
Dan Luu
03/05/2015 21:00
A preocupação com o consumo de energia nos hardwares não é à toa. Como mencionado, a eficiência energética para servidores é crucial, desde a perda no subestação até o calor gerado, que exige resfriamento constante. "Hennessy & Patterson estimam que 82% do custo de um datacenter está associado a energia e resfriamento". É uma conta que faz qualquer um querer sair de perto da fiação. Se os servidores não forem bem alimentados, pode ser que eles não floresçam como esperávamos, algo que faz ecoar um meme clássico de TI: sem energia, sem alegria.
-
Essa discussão sobre a regra do zero-um-infinito chama a atenção para como os números são essenciais na engenharia e ciência. A frase "os únicos números razoáveis são zero, um e infinito" resume a busca por limites arbitrários, que muitas vezes indicam falhas na concepção do sistema. E vamos combinar, ter uma boa intuição numérica é quase como ter um superpoder: saber quando calcular ou medir a primeira vez e quando jogar os números no lixo é o que separa os bons engenheiros dos medíocres. Afinal, em um mundo onde o crescimento exponencial é a norma, é preciso ter o radar ligado para evitar armadilhas estatísticas.
-
Ruslan Spivak
Ruslan Spivak
06/04/2015 08:00
A parte 2 dessa série promete responder a uma pergunta interessante: "Como rodar aplicações Django, Flask e Pyramid sem alterar o servidor?" Isso é como tentar encaixar o pé de um Stormtrooper em um sapato da Nike, mas é sempre possível encontrar um jeito. A adaptação entre frameworks é essencial em um mundo onde a interoperabilidade faz a diferença. Vamos ver se as soluções propostas conseguem manter tudo nas trilhas sem perder a performance no caminho.
-
Lua.org News
07/03/2015 07:35
Lua 5.2.4 chegou para corrigir todos os bugs conhecidos da versão anterior, como se a equipe de desenvolvimento tivesse feito uma sessão de depuração intensa. É sempre bom ver uma linguagem tão leve e rápida ganhando um ajuste que torna a vida dos devs menos complicada. E vamos ser sinceros, quem não gosta de um bug a menos para se preocupar na hora de programar?
-
Dan Luu
06/03/2015 21:00
A pergunta sobre o que acontece ao carregar uma URL é como abrir a caixa de Pandora para os devs mais curiosos. Desde como o teclado acusa pressionamentos até a mágica do DNS, a complexidade da tecnologia está em todos os lugares. O trecho que menciona como "a conexão pode lidar com 10Gb/s" é um lembrete de que, por trás de cada 'clique', há uma sinfonia de componentes que têm que trabalhar em harmonia. É fascinante perceber que entender essas interações pode realmente mudar a forma como avaliamos a performance total de sistemas.
-
Antirez (Salvatore Sanfilippo)
26/02/2015 09:48
O autor reflete sobre os seis anos de Redis e como sua jornada foi repleta de projetos paralelos que, em vez de serem um desvio, serviram como combustível para a criatividade e inovação. "Os projetos paralelos são os projetos que tornam seus projetos maiores possíveis" é uma verdade que muitos desenvolvedores conhecem bem. Manter essa diversidade de esforços não só ajuda a aliviar o estresse, mas também traz novas perspectivas para o trabalho principal, algo que poucos se atrevem a encarar. No final das contas, o equilíbrio entre ter foco e explorar novos caminhos pode ser a chave para o sucesso em projetos de longo prazo.
-
Antirez (Salvatore Sanfilippo)
29/01/2015 08:21
Comparar bancos de dados é tão complicado quanto tentar montar um PC gamer com peças de diferentes fabricantes e esperando que tudo funcione perfeitamente. Segundo o autor, "é quase sempre impossível comparar diferentes sistemas de maneira justa". Ele destaca que benchmarkings podem enganar, especialmente quando alegam altos números de ops por segundo em máquinas monstruosas. No fim das contas, tudo se resume a entender que cada sistema tem suas características e o que funciona para um pode não funcionar para outro, então, escolha seu DB com carinho e não apenas pelo número da velocidade.
-
Dan Luu
10/01/2015 23:00
David Albert fez uma boa pergunta sobre como os CPUs evoluíram desde os tempos em que computávamos com um 8-bit. Hoje em dia, estamos lidando com 64 bits, o que significa mais endereços e registros, além de resultados de ponto flutuante mais consistentes. O que realmente impacta nosso dia a dia de programação é a forma como a memória funciona agora, com caches que antecipam o que vamos precisar, evitando assim aquela espera de mais de 400 ciclos de acesso. Então, a próxima vez que você criticar aquele programinha que parece travar, lembre-se de que a culpa pode não ser só do código, mas também da batalha eterna entre CPU e memória.
-
Dan Luu
27/12/2014 23:00
Julia promete avelha tenra de performance em nível C com uma sintaxe que parece Python e Ruby, mas a realidade é que está cheia de bugs que podem fazer os devs desejarem ter um DeLorean para voltar no tempo. O autor menciona "quatro bugs no núcleo da linguagem" durante um script descartável, o que é bastante preocupante para algo que quer ser uma linguagem de produção. Se você está pensando em usar Julia para visualização de dados, prepare-se para reiniciar o REPL mais vezes do que você gostaria, só para esperar 30 segundos entre os plots. No final das contas, pode ser uma boa opção, mas lembre-se: nem todo superpoder vem sem seu quinhão de responsabilidades.
-
Dan Luu
16/12/2014 23:00
A discussão sobre o custo de habilitar verificações de estouro de inteiro é bem interessante, especialmente quando se considera que, no final das contas, pode resultar em um impacto de cerca de 3% no desempenho, mesmo com a suposição pessimista do efeito de uma penalidade de 2x nas operações de adição e subtração. "2x soa como muito", mas em relação ao que essas operações representam no total, não é tão catastrófico assim. Comparar com benchmarks como bzip2 é uma abordagem prática e, claro, um resgate digno do espírito de economizar um dinheirinho, não quer gastar 800 dólares à toa.
-
A pique da performance multithreaded é algo que pode pegar muitos desenvolvedores de surpresa. Como o autor descobriu, trazer threads para dentro do seu programa sem entender o impacto pode, ironicamente, torná-lo mais lento. A comparação feita entre o tempo de execuções e o número de 'context switches' é clara: quanto mais threads, mais troca de contextos e menos eficiência. No final das contas, nem sempre mais é melhor, principalmente quando se fala de paralelismo em sistemas que não foram projetados para isso. Cuidado com as threads, ou elas podem ser mais um bug do que uma feature.
-
Dan Luu
03/12/2014 23:00
Fazer um tutorial sobre malloc e suas tripulações é quase como tentar decifrar um código do Cthulhu em C. O autor menciona que "minha versão é mais simples e mais vulnerável a fragmentação de memória", o que já mostra que estamos no lado divertido do mundo da alocação de memória. Mas o problema com malloc é que, se você não cuidar bem, pode se transformar num grande 'memory leak' que nem um dev experiente consegue debugar. No final das contas, entender malloc é como entender a teoria da relatividade para alocação de memória: é complicado, mas essencial para quem não quer naufragar em problemas de performance depois.
-
Essa história dos dois fazendeiros é quase um bug da vida real. Eles precisam de uma solução técnica para um problema simples: comunicação. A analogia com sistemas que precisam garantir consistência é clara, mas mais divertida do que um evento de programação assistindo a um 'debug' de um código que nunca para de gerar 'you knows'. No fim das contas, a solução pode estar em um redesign do processo de comunicação, e quem sabe, um pouco menos de Karaoke ajudaria, né?
-
Dan Luu
16/11/2014 23:00
O autor teve uma epifania ao perceber que, mesmo com o suporte de uma plataforma que promete velocidade, sua página estava mais lenta que um disco rígido de 5400 RPM. Ao otimizar o carregamento de scripts, ele conseguiu cortar 4 segundos do tempo de carregamento, mostrando que a ordem como se carrega o conteúdo realmente importa. É como fazer suas dependências em JavaScript dançarem uma salsa para que a página comece a renderizar mais rápido. No fim das contas, menos é mais, e a lição aqui é que, às vezes, menos JavaScript é o caminho mais rápido para a felicidade do usuário.
-
A discussão sobre entrega exatamente uma ser "impossível" é interessante, mas o que realmente importa aqui é entender que nem todos os sistemas precisam desse tipo de exatidão. O autor menciona que "a maioria das pessoas está realmente interessada em processamento exatamente uma", que é um conceito mais alinhado com o que a galera no dev busca. Em vez de ficar obcecado por entregas exatas, focar em como lidar com falhas e garantir que a mensagem tenha um efeito colateral uma única vez pode ser mais útil. E no fim das contas, um pouco de redundância nunca fez mal a ninguém, especialmente em sistemas distribuídos.
-
Dan Luu
06/11/2014 23:00
A discussão sobre tipos está mais acirrada do que debate de devs sobre qual é melhor: pizza ou sushi. O estudo revela que, ao contrário do que alguns gurus de tipos podem afirmar, "a maioria dos estudos encontra efeitos muito pequenos, se é que há algum". O que importa aqui é que, mesmo que tipos fortes tenham um desempenho um pouco melhor que os fracos, fatores como tamanho do projeto e da equipe parecem ser muito mais decisivos. No fim das contas, o tipo de linguagem pode ser menos crucial que a habilidade do dev em lidar com o caos, já que às vezes a mágica acontece entre as teclas do teclado e não apenas nas linhas de código.
-
Dan Luu
04/11/2014 23:00
A nova versão do manual da Intel traz instruções para armazenamento não volátil que prometem revolucionar o uso de SSDs. Contudo, como apontam os pesquisadores, "o OS impõe um imposto bastante grande sobre I/O quando seu dispositivo I/O é realmente rápido". O desempenho pode ser severamente impactado pelo overhead do sistema operacional, além da incompatibilidade entre a hierarquia de memória x86 e a memória persistente. No fim das contas, usar NVRAM pode parecer mais promissor do que realmente é, se você não considerar esses detalhes.
-
Antirez (Salvatore Sanfilippo)
03/11/2014 14:58
Recentemente, testando a latência do Redis em instâncias EC2 m3.medium, percebi algo curioso: "picos de latência de ~300 milissegundos" não surgiram como esperado durante a chamada do fork(). O que o autor descobriu é que o Linux está fazendo o que chamo de 'lazy forking', onde as cópias de páginas são adiadas até uma falha de página ocorrer. Isso funciona bem para processos que chamam fork()+exec(), mas para o Redis, é um desafio. É como descobrir que o seu SSD é um pouco mais lento do que você pensava durante uma competição de pacotes.
-
Dan Luu
02/11/2014 23:00
O autor levanta um ponto interessante ao criticar a ideia de que "raciocínio informal" é prioritário em relação ao "teste". Embora a afirmação de Dijkstra sobre a inadequação dos testes tenha seu mérito, a realidade é que sistemas complexos, como CPUs modernas, não comportam apenas raciocínios simplistas. Como ele observa, "não há como evitar bugs se você cria um sistema que é complexo demais para ser verificado formalmente"; é exatamente isso que nos leva a simulações complexas e testes rigorosos. No fim, prescrever simplicidade como resposta pode ser tão ilógico quanto tentar depurar um código de 73 mil linhas que nem você mesmo consegue compreender.
-
Dan Luu
02/11/2014 23:00
A ideia de que uma política de evicção aleatória possa ser tão boa quanto o LRU é quase como dizer que a programação orientada a objetos é só uma moda. No entanto, "random tends to do worse than other algorithms" em cargas de trabalho reais, o que nos lembra que nem todo algoritmo aleatório é uma solução mágica. O estudo mostra que o 2-random é uma abordagem interessante, especialmente em caches maiores, onde o LRU pode sofrer com taxas de falha superiores. No fim, parece que a escolha do algoritmo de cache ainda é um dilema digno de debate entre desenvolvedores na hora do happy hour.