diff --git a/content/links/20200531.md b/content/links/20200531.md
new file mode 100644
index 0000000..f3010e6
--- /dev/null
+++ b/content/links/20200531.md
@@ -0,0 +1,158 @@
++++
+title = "Links for 2020-05-31"
+date = 2020-05-31
+
+[taxonomies]
+tags = ["links", "python", "emacs", "post-mortems", "rewrites", "copyleft",
+"technical debt", "leading", "microservices", "rust", "cities", "roads",
+"stallman"]
++++
+
+Running Things in Python, Emacs, Everything That Can Go Wrong, Why We Believe
+that Rewrites Go Right, Copyleft, Analogies for Technical Debt, Leading
+Projects, Microservices in Rust, Cities as Roads, Complaining about Stallman.
+
+<!-- more -->
+
+## [The many ways to pass code to Python from the terminal](https://snarky.ca/the-many-ways-to-pass-code-to-python-from-the-terminal/)
+
+This is a curious post. Although I've been using Python for a long time, 
+some of those were completely unknowns to me -- for example, making a zip file
+and running it directly with the interpreter.
+
+## [Emacs - Productivity Tricks/Hacks](http://www.mycpu.org/emacs-productivity-setup/)
+
+Although I don't usually use Emacs -- I'm a Vim user myself -- I can't stop
+myself from sharing a post about Emacs that suggests using Evil, the Vim
+keybinds emulation mode.
+
+And the suggestion of using Helm is something that I really need to add on my
+Emacs configuration.
+
+## [Postmortems](https://postmortems.info/)
+
+A Discord place for posting things going wrong.
+
+I've been mentioning this for a year already: Most presentations we do, when
+we go in public, is to talk about the things the go perfecting fine -- you
+just do a build, it will never fail; just write the code, you won't find a
+corner case; just create something, everything will be fine -- and that's not
+the real life.
+
+Postmortens is a forum exactly for describing things going wrong. And there is
+a lot more to learn from things going wrong than from perfect steps that does
+not reflect reality.
+
+## [Why do we fall into the rewrite trap?](https://www.justindfuller.com/2020/01/why-do-we-fall-into-the-rewrite-trap/)
+
+Yes, everybody, at this point, heard about the "Refactor, Don't Rewrite". And
+this is just more of that.
+
+But there are some things that really caught my eye[^1]: First, "Contempt
+Culture", the idea that something is bad because it's old and bad and the new
+thing is good because it's new. I mentioned this on my "Things I Learnt The
+Hard Way in 30 Years of Software Development", but "right tool for the job" is
+mostly a way to push an agenda and the right tool is mostly the tool your team
+knows the best.
+
+Also, instead of just going through "Rewrite BAD!", it actually list some
+situations when doing a rewrite is the right option -- and I won't spoil, but
+it does seems _really_ the right situation.
+
+## [Toward Copyleft Equality for All](https://sfconservancy.org/blog/2020/jan/06/copyleft-equality/)
+
+A lot of the things in this post would be just for me to repeat things I
+pointed in other posts: Companies are using the Free Software label just as
+marketing, working on new features and charging for it, while leaving the
+bugfixing part to the community, for example.
+
+Here, the thing is a bit more complex, and I'm not sure if I can have an
+concrete opinion about what is being said. Basically, the idea of 
+"copyleft" -- using copyright to make sure the code will still be available
+and accessible to everything -- has been been subverted with the "dual
+licensing".
+
+In one hand, companies should be able to let the code be available and still
+charge for it, but the way they have been using free software seems to be only
+as a marketing plot. "Look, it's free software!" but listen to the community,
+let them point the destiny of the project, making sure contributing is easy,
+nothing of that makes part of those projects.
+
+## [Technical Debt Is like a Tetris Game](https://www.fluentcpp.com/2020/01/17/technical-debt-is-like-a-tetris-game/)
+
+This may be the best Technical Debt analogy I ever seen: It is a game of
+Tetris.
+
+In the start, everything is clear and it is simple to fit the pieces. But, if
+you don't take the time to clear things from time to time, it will get more
+and more chaotic till you lose.
+
+If this isn't an explanation that everyone understands why you need to stop
+from just piling up pieces and try to clear the field from time to time, I
+really don't know what will.
+
+## [How to Lead a Project - as a Software Engineer](https://blog.pragmaticengineer.com/how-to-lead-a-project-in-software-development/)
+
+A list of things software engineers should take care when they become project
+leaders.
+
+I can attest that the general concept here works, 'cause that's what I did
+when I was technical leader in projects.
+
+## [Building a Microservice with Rust](https://medium.com/@diego_pacheco/building-a-microservice-with-rust-957420f196fc)
+
+Ok, the fact that I love Rust may be related to me wanting to share this, but
+you have to agree that the post is really complete, showing all the hops and
+jumps you need to do to make a microservice in Rust.
+
+## [city roads](https://anvaka.github.io/city-roads/)
+
+This is a cool project: Instead of drawing a city using its geographical
+limits, draw it using their roads.
+
+## [Burning the House That Richard Stallman (RMS) Built: An Open Letter to GNU Maintainers Who Opposed RMS](http://techrights.org/2020/05/30/open-letter-to-gnu-maintainers/)
+
+Let's complain about those complaining?
+
+Another one of those "Leave rms alone!" kind of posts. This time, whoever
+works for Microsoft -- which is extremely weird for this kind of post for not
+calling it Micro$oft -- are the real pirates and who works for Red Hat have as
+bad character as them.
+
+Honestly, there is no denying in the work Richard Stallman did to promote free
+software. But, at the same time, we can't ignore that, for years, GCC got
+stuck on its architecture 'cause any changes were denied and we can't deny
+that this "tantrum" in improving GCC is what gave Clang the space it got --
+just remember that Apple used GCC to build macOS and iOS binaries. And we
+can't ignore that just one day before the pressure for rms to leave the FSF
+reached critical levels he was still saying that there was no problem in an
+underage girl to have a sexual relationship to an old man.
+
+This kind of though -- "But he did lots, and can say and do whatever he 
+wants" -- it's the most pure teenage thought of no worrying about the
+consequences. "Oh, look at the consequences in the history of Microsoft
+against free software! But don't look on what rms is saying and how his
+posture hurts important projects and the community, 'cause he's my friend".
+
+The community has grown up -- not only in numbers, but also in its mental 
+age -- and now we are asking when important figures will be hold responsible
+for whatever they say and whatever they do.
+
+... and it is really weird for a post like this that attacks Microsoft and
+Red Hat, but says absolutely NOTHING about what Google has been doing with the
+term "open source".
+
+---
+
+[^1]: ... specially since I saw some things related to this yesterday
+  morning...
+
+---
+
+This post was built with the help of
+
+* [newsbot](https://mastodon.social/@newsbot)
+* [Ed S](https://mastodon.sdf.org/@EdS)
+* [HN Tooter](https://mastodon.social/@hntooter)
+* [codesections](https://fosstodon.org/@codesections)
+* [Starfish](https://social.linux.pizza/@redstarfish)
diff --git a/content/links/20200531.pt.md b/content/links/20200531.pt.md
new file mode 100644
index 0000000..b803a03
--- /dev/null
+++ b/content/links/20200531.pt.md
@@ -0,0 +1,165 @@
++++
+title = "Links de 2020-05-31"
+date = 2020-05-31
+
+[taxonomies]
+tags = ["links", "python", "emacs", "post-mortems", "reescritas", "rewrites",
+"copyleft", "technical debt", "débito técnico", "liderando projetos",
+"microserviços", "rust", "cidades", "estradas", "stallman"]
++++
+
+Executando Coisas em Python, Emacs, Tudo Que Pode Dar Errado, Por Que
+Acreditamos que Reescrever Dá Certo, Copyleft, Analogias Para Débito Técnico,
+Liderando Projetos, Microserviços em Rust, Cidades Como Estadas, Reclamando de
+Quem Reclama do Stallman.
+
+<!-- more -->
+
+## [The many ways to pass code to Python from the terminal](https://snarky.ca/the-many-ways-to-pass-code-to-python-from-the-terminal/)
+
+Esse post é curioso. Embora eu utilize Python por um bom tempo já, alguns
+desses métodos eram completos desconhecidos pra mim -- por exemplo, criar um
+arquivo Zip e rodar usando diretamente o interpretador.
+
+## [Emacs - Productivity Tricks/Hacks](http://www.mycpu.org/emacs-productivity-setup/)
+
+Embora eu não utilize o Emacs normalmente -- eu sou usuário de Vim de
+carteirinha -- eu não posso deixar de compartilhar um post sobre Emacs que
+sugere o uso do Evil, o modo que utiliza as teclas do Vim.
+
+E a sugestão de usar o Helm é algo que eu tenho que usar na minha instalação
+do Emacs.
+
+## [Postmortems](https://postmortems.info/)
+
+Um fórum do Discord para postar coisas dando errado.
+
+Eu tenho mencionado isso por quase um ano já: A maior parte das apresentações
+que nós fizemos, quando mostramos pro público, é para falar de coisas que
+acontecem de forma perfeita -- você só faz o build e ele nunca falha; você
+escreve o código e nunca encontra um "corner case"; é só criar o que quiser,
+tudo vai dar certo -- e isso não é a vida real.
+
+Postmortems é um fórum justamente para descrever as coisas dando errado. E
+existe muito mais que pode ser aprendido com coisas dando errado do que com os
+passos perfeitos que não refletem a realidade.
+
+## [Why do we fall into the rewrite trap?](https://www.justindfuller.com/2020/01/why-do-we-fall-into-the-rewrite-trap/)
+
+Sim, todo mundo, nesse ponto, deve ter ouvido falar que "Refatore, Não
+Reescreva". E esse post é mais do mesmo.
+
+Mas tem algumas coisas que realmente me chamaram a atenção[^1]: Primeiro,
+"Cultura do Desprezo", a ideia de que algo é ruim porque é velho e ruim, e que
+a coisa nova é boa porque é nova. Eu mencionei isso no meu post de "Coisas Que
+Eu Aprendi Na Marra em 30 Anos de Desenvolvimento de Software", mas
+"ferramenta certa para o trabalho" nada mais é que uma forma de uma agenda e a
+ferramenta certa é aquela que o seu time conhece melhor.
+
+Ainda, ao invés de ir para "Reescrever, RUIM!" o post indica algumas situações
+em que reescrever é a opção correta -- e eu não vou mostrar spoilers, mas
+parece ser _realmente_ a situação correta.
+
+## [Toward Copyleft Equality for All](https://sfconservancy.org/blog/2020/jan/06/copyleft-equality/)
+
+Tem um monte de coisas nesse post que serviriam apenas para repetir coisas que
+eu comentei em outros: Empresas estão usando Software Livre como propaganda,
+se encarregando de novas features, cobrando por isso e deixando a correção de
+bugs para a comunidade, por exemplo.
+
+Aqui, a coisa é mais complexa, e eu não sei se eu consigo ter uma opinião
+concreta sobre o que está sendo dito. Basicamente, que a ideia de "copyleft" --
+usar o copyright para garantir que um código vai continuar liberado e
+acessível a todos -- tem sido subvertido com as "duplas licenças".
+
+Por um lado, empresas poderiam sim deixar o código disponível e ainda cobrar
+para manter o software, mas a forma como software livre tem sido usado tem
+sido, na verdade, como propaganda. "Olha, é software livre!", mas escutar a
+comunidade, deixar que eles apontem o destino do projeto, facilitar a
+contribuição de outros, nada disso faz parte desses projetos.
+
+## [Technical Debt Is like a Tetris Game](https://www.fluentcpp.com/2020/01/17/technical-debt-is-like-a-tetris-game/)
+
+Essa pode ser a melhor analogia de como Débito Técnico funciona: É um jogo de
+Tetris.
+
+No começo, tudo está vazio e é simples de encaixas as peças. Mas, se você não
+tomar cuidado, o jogo vai ficando cada vez mais caótico até que você perde.
+
+Se essa não for uma explicação que todo mundo entenda porque é preciso parar
+de ficar empilhando pecinhas e tentar limpar o campo de tempos em tempos, eu
+realmente não sei o que vai fazer.
+
+## [How to Lead a Project - as a Software Engineer](https://blog.pragmaticengineer.com/how-to-lead-a-project-in-software-development/)
+
+Uma lista de coisas que engenheiros de software devem cuidar quando se tornam
+líderes de projeto.
+
+Eu posso comprovar que o conceito geral apresentado aqui funciona, porque foi
+o que eu fiz quando fui líder técnico de projetos.
+
+## [Building a Microservice with Rust](https://medium.com/@diego_pacheco/building-a-microservice-with-rust-957420f196fc)
+
+Ok, talvez o fato que eu adore Rust pode estar relacionado com o fato d'eu
+querer compartilhar algo desse tipo, mas vocês tem que concordar que esse post
+é realmente complete, mostrando todos os pontos necessários para fazer um
+microserviço em Rust.
+
+## [city roads](https://anvaka.github.io/city-roads/)
+
+Isso é um projeto curioso: Ao invés de desenhar cidades usando seus limites
+geográficos, desenhe essa usando apenas as estradas.
+
+## [Burning the House That Richard Stallman (RMS) Built: An Open Letter to GNU Maintainers Who Opposed RMS](http://techrights.org/2020/05/30/open-letter-to-gnu-maintainers/)
+
+Vamos reclamar de quem tá reclamando?
+
+Mais um dos posts de "Deixem rms em paz!" Dessa vez, quem trabalha para a
+Microsoft -- que, estranhamente pelo tom do post, não foi chamada de 
+Micro$oft -- são os piratas de verdade e quem trabalha na Red Hat é tão mal
+caráter quanto.
+
+Honestamente, não dá para negar o trabalho que o Richard Stallman fez para
+promover open source. Mas ao mesmo tempo não dá pra deixar de ignorar que, por
+anos, GCC ficou travado porque mudanças de arquitetura eram negadas e também
+não dá pra ignorar que justamente essa "birra" em melhorar o GCC é que deu ao
+Clang o espaço que ele ganhou -- lembrem-se que a Apple usava GCC inicialmente
+tanto para gerar binários no Macos quanto para iOS. E também não dá para
+ignorar que até um dia antes da pressão para que o rms deixasse a FSF
+atingisse níveis críticos ele ainda afirmava que não havia qualquer problema
+em meninas menores de idade terem relacionamentos sexuais com homens mais
+velhos.
+
+Esse tipo de pensamento -- "O cara fez muito, e pode falar o que quiser e
+continuar fazendo o que quiser" -- é o mais puro pensamento adolescente de não
+se preocupar com as consequências. "Oh, olhem as consequências da história da
+Microsoft contra o software livre! Não, não olhem o que o rms anda falando e
+como a postura dele prejudica projetos importantes e a comunidade, porque ele
+é meu amigo".
+
+A comunidade cresceu -- não apenas em número, mas também em mentalidade -- e
+agora estamos nos perguntando quando é que figuras importantes vão se
+responsabilizar pelo que falam e pelo que fazem.
+
+... e é extremamente estranho ver um artigo como este que ataca a Microsoft e
+a Red Hat, mas fala absolutamente NADA sobre o que o Google tem feito com o
+termo "open source".
+
+---
+
+[^1]: ... especialmente com uma discussão que eu vi ontem de manhã.
+
+---
+
+Esse post foi feito com a ajuda de
+
+* [newsbot](https://mastodon.social/@newsbot)
+* [Ed S](https://mastodon.sdf.org/@EdS)
+* [HN Tooter](https://mastodon.social/@hntooter)
+* [codesections](https://fosstodon.org/@codesections)
+* [Starfish](https://social.linux.pizza/@redstarfish)
+
+<!-- 
+vim:spelllang=pt:
+-->
+
diff --git a/content/links/20200601.md b/content/links/20200601.md
new file mode 100644
index 0000000..7941647
--- /dev/null
+++ b/content/links/20200601.md
@@ -0,0 +1,130 @@
++++
+title = "Links for 2020-06-01"
+date = 2020-06-01
+
+[taxonomies]
+tags = ["links", "distributed", "c", "rust", "protection", "no code",
+"android", "research", "blog", "contact tracing", "privacy"]
++++
+
+Distributed Systems, C in Rust, Protecting Projects, No Code, Android,
+Research Blog, Contact Tracing and Privacy (again).
+
+<!-- more -->
+
+## [Notes on Distributed Systems for Young Bloods](https://www.somethingsimilar.com/2013/01/14/notes-on-distributed-systems-for-young-bloods/)
+
+A bunch of "things you need to remember when working on distributed systems",
+not only for "young bloods", but also for those who are doing this for
+sometime, just as a reminder.
+
+## [writing c library in rust](https://www.ultrasaurus.com/2020/01/writing-c-library-in-rust/)
+
+One of the cool things about Rust is that you can combine Rust applications
+with any other C library. But not only that, it is also possible to write code
+in Rust and export it as a C interface -- and, with that, combine with any
+other language that can bind with C, which are basically every language around.
+
+## [Self-Protecting Projects](https://amihaiemil.com/2020/01/17/self-protecting-projects.html)
+
+Projects without a CI/CD pipeline are doomed to fail.
+
+That's basically the gist of the post and I'm all for it too. There are a few
+missing bits, like you can have a CI/CD pipeline and not having a policy for
+writing tests; but, at the same time, I reckon there is no easy way to measure
+if the proper things are being tested (and no, "every single function" is not
+a measure).
+
+Also, the idea of making the application open tickets every time the
+application crashes is cool and all, but that only works for applications that
+run on your own environment -- an embedded application would have a hard time
+making this.
+
+## [Why I Keep a Research Blog](http://gregorygundersen.com/blog/2020/01/12/why-research-blog/)
+
+I've been thinking about this for some time: I have a list of "Things I Don't
+Know", which I keep on [Joplin](https://joplinapp.org/). The idea is that,
+when I have some time, or when I see some information related to the topic, I
+can add to the note, till I finally feel confident enough to say "Ok, now I
+understand this".
+
+But for some time I've been writing this kind of post (the
+"[Links](https://blog.juliobiason.me/tags/links/)" ones) as a way to keep a
+list of things that I feel I may need in the future. So, if I keep a list of
+"maybe in the future" links, why don't I put the research topics also in this
+blog? Surely, right now, it will have only the topics and no content (sorry!)
+but making it available may also help someone else.
+
+There is one point that one could make: If I share links, why not share links
+related to those topics, and let the blog engine worry about grouping them?
+The point is actually to write whatever I learnt in my own words, 'cause those
+are easier to recall in the future.
+
+I'm still wrangling with the idea, though. No promises.
+
+## [Minnesota is now using contact tracing to track protestors, as demonstrations escalate](https://bgr.com/2020/05/30/minnesota-protest-contact-tracing-used-to-track-demonstrators/)
+
+You may recall that I've been, for a while, mentioning that contact tracing
+applications may sound good to find someone that had contact with another
+someone with COVID-19 (so we could alert and/or take that person to a
+hospital, before it was too late for treatment), but there were serious
+privacy problems with it? Well, there we go.
+
+A black person was brutally killed by the police in the USA, and the community
+rioted to the point that a police department was set afire -- I'm not saying
+it was right or wrong, but you have to think the type of indignation that make
+people set a _police department_ on fire.
+
+And those people who worried that they may get in contact with someone that
+got infected with COVID-19 and installed any contact tracing application are
+now being tracked by their association with other demonstrators.
+
+And _that's_ what I was talking about. There is no policy that says "this
+tracing information may be _only_ used for diseases and nothing else".
+
+## [The 'No Code' Delusion](https://www.alexhudson.com/2020/01/13/the-no-code-delusion/)
+
+Ignoring the fact that the post talks about a movement for "creating
+business rules without the need of a developer", what I found interesting is
+the visual comparison of the business rule (in a diagram) and the code (a
+piece of Python code). Why? Because that's exactly the way applications should
+be written: There is logic and it is described in a combination of functions,
+which content doesn't make part of the rule itself and there are no rules
+"hidden" inside the function of a rule. There is nothing of "let me put a
+regexp here to validate the email". That's not what the business rule says, so
+that's not in the code. If the business rule said "You should test this,
+convert to that and send this to there", that's exactly what the function
+should have.
+
+On the other hand, I didn't realized that diagrams require some previous
+knowledge: Which symbol represents a test? Which symbol represents "white in
+the screen"? And so on.
+
+What I need to mention, though, is that COBOL was created for non-programmers
+so they could describe business rules and run them; SQL was desgiedn so
+non-programmers could describe how to retrieve and process data; BDD has
+always been described as a way for non-programmers to describe how a system
+should be validated.
+
+## [Google pushed to take action against Android bloatware by 50+ organizations](https://9to5google.com/2020/01/11/android-bloatware-privacy-open-letter/#adnrb=900000)
+
+A post from earlier this year, but there is one point that I need to bring:
+
+Android is "open source", right? If it is, why doesn't those 50+ organizations
+just fork it and make their own Android? Surely, in a 50+ organization group,
+there should be a few developers and making them all work on that could solve
+the problem, right?
+
+Well, thing is, Google controls Android. You can't simply fork and hope that
+you can run on your device. You can't simply make a pull request and hope it
+will, one day, be part of the system.
+
+"Android is opensource" is a farce. It is "source available", not "open
+source" by any stretch of imagination.
+
+---
+
+This post was built with the help of
+
+* [HN Tooter](https://mastodon.social/@hntooter)
+* [Read Rust](https://botsin.space/@readrust)
diff --git a/content/links/20200601.pt.md b/content/links/20200601.pt.md
new file mode 100644
index 0000000..3b8261d
--- /dev/null
+++ b/content/links/20200601.pt.md
@@ -0,0 +1,142 @@
++++
+title = "Links de 2020-06-01"
+date = 2020-06-01
+
+[taxonomies]
+tags = ["links", "distributed", "c", "rust", "no code", "android", "pesquisa",
+"blog", "contact tracing", "privacidade"]
++++
+
+Sistemas Distribuídos, C em Rust, Protegendo Projetos, Sem Código, Android,
+Blog de Pesquisa, Contact Tracing e Privacidade.
+
+<!-- more -->
+
+## [Notes on Distributed Systems for Young Bloods](https://www.somethingsimilar.com/2013/01/14/notes-on-distributed-systems-for-young-bloods/)
+
+Uma lista de "coisas que você precisa se lembrar quando estiver trabalhando
+com sistemas distribuídos", não apenas para iniciantes, mas também para
+aqueles que já estão fazendo isso por algum tempo, como lembrete.
+
+## [writing c library in rust](https://www.ultrasaurus.com/2020/01/writing-c-library-in-rust/)
+
+Uma das coisas legais de Rust é que é possível combinar aplicações em Rust com
+qualquer outra biblioteca em C.  Mas não só isso, é possível escrever código
+em Rust e exportar como uma interface em C -- e, com isso, combinar com
+qualquer outra linguagem que consiga utilizar C, que é basicamente tudo que
+tem por aí.
+
+## [Self-Protecting Projects](https://amihaiemil.com/2020/01/17/self-protecting-projects.html)
+
+Projetos sem um pipeline de CI/CD estão condenados ao fracasso.
+
+Isso é basicamente o resumo do post e eu concordo plenamente. Existem alguns
+pontos faltantes, por exemplo, você pode ter um pipeline de CI/CD e não ter
+uma política para testes; mas, ao mesmo tempo, eu reconheço que não existe uma
+forma fácil de medir se estão sendo testadas as coisas certas (e não, "toda e
+qualquer função" não é uma métrica).
+
+Ainda, a ideia de fazer a aplicação abrir tickets toda vez que ela capota é
+legal, mas isso só funciona para aplicações que rodam no seu ambiente -- seria
+complicado fazer uma aplicação embedded ter isso.
+
+## [The 'No Code' Delusion](https://www.alexhudson.com/2020/01/13/the-no-code-delusion/)
+
+Ignorando o fato que o post que fala sobre o movimento de "gerar regras de
+negócio sem a necessidade de um desenvolvedor", o que eu achei interessante
+mesmo é a comparação visual da regra (um fluxograma) com o código (um trecho
+um Python). Por que? Porque é exatamente assim que aplicações deveriam ser
+escritas: Há uma lógica e ela é descrita em uma combinação de funções, cujo
+conteúdo não faz parte da regra e regras não estão "escondidas" dentro de uma
+função de outra regra. Nada de "deixa eu botar uma regexp aqui para validar se
+o email é válido ou não". Não é isso que a regra de negócio diz, e não é isso
+que o código contém. Se a regra de negócio diz "Você deve testar isso,
+converter praquilo e enviar para aquele outro", é exatamente o que a função
+deveria ter.
+
+Por outro lado, eu não havia me ligado que mesmo descrições com fluxogramas
+requerem um conhecimento: Qual símbolo representa um teste?  Qual símbolo
+representa "mostrar na tela"? E assim por diante.
+
+O que eu não posso deixar de citar é que COBOL foi criado para que não
+programadores pudesse descrever as regras de negócio e executar as mesmas; SQL
+foi criado para que não programadores pudessem descrever como recuperar e
+processar dados; BDD sempre foi descrito como uma forma de não-programadores
+pudessem descrever as validações do sistema.
+
+## [Google pushed to take action against Android bloatware by 50+ organizations](https://9to5google.com/2020/01/11/android-bloatware-privacy-open-letter/#adnrb=900000)
+
+Um post do começo do ano, mas tem um ponto aqui que eu quero trazer:
+
+Android é "open source", certo? Se é, então porque essas 50+ organizações não
+fazem um fork e criam o seu próprio Android? Certamente, num grupo de 50+
+organizações, devem haver alguns programadores e se esses fossem colocados
+para trabalhar juntos, eles poderiam resolver esse problema, certo?
+
+Bom, o fato é que o Google controla o Android. Você não pode simplesmente
+fazer um fork e esperar que ele irá rodar no seu dispositivo. Você não pode
+simplesmente fazer um pull request e esperar que ele será, um dia, parte do
+sistema.
+
+"Android é open source" é uma farça. É "fontes disponíveis" ("source
+available"), não "open source" em qualquer força de imaginação.
+
+## [Why I Keep a Research Blog](http://gregorygundersen.com/blog/2020/01/12/why-research-blog/)
+
+Eu tenho pensando sobre isso por algum tempo: Eu tenho uma lista de "Coisas
+Que Eu Não Sei" que eu mantenho no [Joplin](https://joplinapp.org/). A ideia é
+que, quando eu tenho algum tempo livre, ou quando eu tenho alguma informação
+relacionada com o tópico, eu posso adicionar na nota, até que eu me sinta com
+confiança suficiente para dizer "Ok, agora eu entendo isso".
+
+Mas ao mesmo tempo, eu tenho gerado esse tipo de post (os posts dos
+"[Links](https://blog.juliobiason.me/pt/tags/links/)") como uma forma de
+manter os links que eu acho que eu vou precisar no futuro. Então, se eu
+mantenho uma lista de links de "talvez, no futuro", porque eu não coloco os
+tópicos de pesquisa no meu blog também"? Por enquanto, eu só vou ter os
+tópicos e nada de conteúdo (desculpem-me!) mas deixar os mesmos disponíveis
+pode ajudar mais alguém.
+
+Existe um ponto que tem que ser feito: Se eu compartilho links, porque não
+compartilhar links relacionados com esses tópicos e deixo a ferramenta de blog
+que eu uso se preocupar em agrupar essas informações? A ideia é descrever a
+informação com meus minhas próprias palavras, porque essas são mais fáceis de
+lembrar no futuro.
+
+Eu ainda estou pensando nessa ideia, no entanto. Não faço nenhuma promessa que
+vai acontecer.
+
+## [Minnesota is now using contact tracing to track protestors, as demonstrations escalate](https://bgr.com/2020/05/30/minnesota-protest-contact-tracing-used-to-track-demonstrators/)
+
+Eu tenho comentado por algum tempo sobre o fato que aplicações de "contact
+tracing" (pessoas com quem o usuário do celular teve proximidade) podem soar
+boas para encontrar alguém que teve contato com outra pessoa que teve COVID-19
+(de forma que essa pessoa possa ser alertada e/ou levada para um hospital,
+antes que os sintomas se tornem muito fortes para qualquer tratamento), mas
+que haviam sérios problemas de privacidade com eles? Bom, aqui está.
+
+Uma pessoa negra foi brutalmente morta pela polícia nos EUA, e a comunidade se
+amotinou ao ponto de que uma delegacia de polícia foi queimada -- eu não estou
+dizendo que está certo ou errado, mas vocês tem que pensar no tipo de
+indignação que faz com que pessoas botem fogo numa _delegacia de polícia_.
+
+E as pessoas que se preocuparam que elas poderiam entrar em contato com alguém
+que fosse infectado pelo COVID-19 e instalaram qualquer aplicação de "contact
+tracing" agora estão sendo procuradas por sua associação com outros
+manifestantes.
+
+E é _isso_ que eu tenho falado. Não existe uma política de "essa informação de
+contato pode ser usada _somente_ para controle de disseminação de doenças e
+nada mais."
+
+---
+
+Esse post foi feito com a ajuda de
+
+* [HN Tooter](https://mastodon.social/@hntooter)
+* [Read Rust](https://botsin.space/@readrust)
+
+<!-- 
+vim:spelllang=pt:
+-->
+
diff --git a/content/links/20200604.md b/content/links/20200604.md
new file mode 100644
index 0000000..6ae0c88
--- /dev/null
+++ b/content/links/20200604.md
@@ -0,0 +1,116 @@
++++
+title = "Commented Links for 2020-06-03"
+date = 2020-06-03
+
+[taxonomies]
+tags = ["links", "rust", "scotty", "python", "pyramid", "cornice", "datetime",
+"mercurial", "async requests", "httpx", "advertising", "google", "python 3"]
++++
+
+Scotty, Pyramid and Cornice, Problems with `datetime.now()`, Mercurial and
+Python 3, Fast Python, Async Python Request Library, Online Advertising,
+Google and Web.
+
+<!-- more -->
+
+## [scotty: Transports you to any directory you have visited before](https://github.com/wdullaer/scotty)
+
+I have been using Scotty for some time and I really like it.
+
+What Scotty does is keep a list of directories you accessed recently and,
+after a while, you can simply use `s <directory>` to get straight into it. Not
+only that, but Scotty uses fuzzy searching to find the directory that closely
+matches whatever you typed.
+
+## [How to write a Python web API with Pyramid and Cornice](https://opensource.com/article/20/1/python-web-api-pyramid-cornice)
+
+Pyramid is the "less known" Python web framework around. But this post shows
+how simple is to build a (simple) API with it.
+
+## [Stop Using datetime.now!](https://hakibenita.com/python-dependency-injection)
+
+Slightly clickbait title, but great content. Not only pointing out the
+problems when using `datetime.now()` (no, it's not the function itself that
+has a problem, it is the way we use that may cause problems), but going into
+lenghts explaining dependency injection in Python.
+
+## [Mercurial's Journey to and Reflections on Python 3](https://gregoryszorc.com/blog/2020/01/13/mercurial%27s-journey-to-and-reflections-on-python-3/)
+
+Ding dong, the witch is dead, and so is Python 2.
+
+But there is still a large base of Python 2 projects that need to be converted
+to Python 3, and Mercurial did this, and here's the experience of a
+maintained on doing it so.
+
+I do understand that converting Python 2 to 3 is not a simple task, but there
+are a few misconceptions in the post. For example, "the approach of assuming
+the world is Unicode is flat out wrong and has significant implications for
+systems level applications". The word _is_ unicode. Go read the Portuguese
+version of this blog to have some idea. Go read any Chinese/Japonese blog to
+see how it looks. Do you really think those people do not use system level
+applications anywhere? Also, what do you think are mostly used: User level
+applications or system level?
+
+Not saying the conversion is perfect -- in a way, unicode is simply a way of
+dealing with the underlying bytes -- but ranting that this change made _your_
+specific way to think harder is not an excuse to not understand where the
+whole ecosystem was moving -- and it also doesn't mean your specific thing is
+not welcome, but you have to understand you're in the minority case here.
+
+(Also, it's no surprise to me that claiming "world is unicode is wrong" is
+coming from someone living in an ASCII country.)
+
+## [Making Python Programs Blazingly Fast](https://martinheinz.dev/blog/13)
+
+A set of tips on how to make Python applications faster. Some of those may
+seem weird in the first glance (make a variable in the function point to the
+a variable in the same class?) but the post also explains _why_ this may
+improve the general performance.
+
+## [Httpx: A next-generation HTTP client for Python](https://www.python-httpx.org/)
+
+[Requests](https://2.python-requests.org/en/master/) shown to everyone how
+APIs should work, but it kinda got stuck in time, without async support (and a few
+other glitches in the project management). Now there is Httpx, which is,
+again, another HTTP request library, but this time with async support and,
+basically, the same interface.
+
+## [No-judgment digital definitions: Online advertising strategies](https://blog.mozilla.org/firefox/online-advertising-strategies/)
+
+Have you ever wondered why after you search something -- say, "gamer chair" --
+suddenly you start getting a lot of promotions and ads for chairs in your
+social networks?
+
+Nothing happens by simple chance, and that's the effect of all the trackers
+that someone puts on a page. But how they identify who is who is the real
+question.
+
+This post by Mozilla may seem a little bit basic, but shows pretty damn well
+how those things are done.
+
+## [Google Is Not God of The Web](https://bilge.world/google-page-experience)
+
+Another clickbait title but, again, good content.
+
+A point that caught my attention was "Google has the right to dictate 'Best
+Practices', although I think the topic is quite the opposite, based on its
+content.
+
+Imagine that Google start giving points of "user experience" to pages that use
+the Material design. Pages and pages that look like Android apps. But if you
+use your own layout, your own colors, you lose points. What now?
+
+This is the greatest problem on people depending on Google, and all the
+relationship of one of their groups working on web standards, a group working
+on a browser and a group to take advantage of whatever the previous two did.
+The less dependent on Google you become, the more you use alternative search
+engines (DuckDuckGo, Searx and even Bing), the more you use other email
+providers (ProtonMail), the more you use browsers that are not Chrome
+(Firefox, Safari or anything based on WebKit), the lesser the chance of the
+internet becoming the thing of a single company.
+
+---
+
+This post was built with the help of
+
+* [HN Tooter](https://mastodon.social/@hntooter)
diff --git a/content/links/20200604.pt.md b/content/links/20200604.pt.md
new file mode 100644
index 0000000..ff4e5f8
--- /dev/null
+++ b/content/links/20200604.pt.md
@@ -0,0 +1,126 @@
++++
+title = "Links Comentados de 2020-06-03"
+date = 2020-06-03
+
+[taxonomies]
+tags = ["links", "rust", "scotty", "python", "pyramid", "cornice", "datetime",
+"python 3", "mercurial", "requisições async", "propaganda", "google"]
++++
+
+Scotty, Pyramid e Cornice, Os Problemas Com `datetime.now()`, Mercurial e
+Python 3, Acelerando o Python, Biblioteca Async para Requisições HTTP,
+Propagandas Digitais, Google e a Web.
+
+<!-- more -->
+
+## [scotty: Transports you to any directory you have visited before](https://github.com/wdullaer/scotty)
+
+Eu tenho usado Scotty por algum tempo já e realmente tem me agradado.
+
+O que Scotty faz é guardar uma lista dos diretórios pelos quais você já passou
+e, depois de um tempo, você pode simplesmente fazer `s <diretório>` e cair
+diretamente no diretório específico. Não apenas isso, mas `<diretório>` nem
+precisa ser o nome correto do diretório; Scotty usa "fuzzy search" para
+encontrar o diretório com o nome mais parecido com o que você digitou.
+
+## [How to write a Python web API with Pyramid and Cornice](https://opensource.com/article/20/1/python-web-api-pyramid-cornice)
+
+Pyramid is o framework web para Python menos conhecido por aí. Mas esse post
+mostra como é simples fazer uma (simples) API com ele.
+
+## [Stop Using datetime.now!](https://hakibenita.com/python-dependency-injection)
+
+Embora o título seja um pouco "clickbait", o conteúdo é bem interessante. Não
+apenas apontando os problemas de se usar `datetime.now()` (não, não é a função
+em si que tem um problema, é a forma como usamos o resultado que pode gerar
+problemas), mas explicando minuciosamente injeção de dependências em Python.
+
+## [Mercurial's Journey to and Reflections on Python 3](https://gregoryszorc.com/blog/2020/01/13/mercurial%27s-journey-to-and-reflections-on-python-3/)
+
+Ding dong, a bruxa morreu, e o Python 2 também.
+
+Mas ainda existe uma grande base de projetos em Python 2 que precisam ser
+convertidos para Python 3, e o Mercurial fez isso, e aqui tem a experiencia do
+mantenedor em fazer essa conversão.
+
+Eu entendo que converter um projeto de Python 2 para 3 não é uma tarefa fácil,
+mas tem algumas coisas erradas no post. Por exemplo, "the approach of assuming
+the world is Unicode is flat out wrong and has significant implications for
+systems level applications" (a ideia de assumir que o mundo é unicode é
+completamente errada e tem sérias implicações para aplicações que nível de
+sistema). O mundo _é_ unicode. É só ler a parte em português desse site. É só
+ler um blog em chinês ou japonês para ver como ele é. Você realmente acredita
+que essas pessoas não usam aplicações de sistema em lugar algum? Ainda, o que
+você acham que são mais usadas: Aplicações de nível de sistema ou nível de
+usuário?
+
+Não estou dizendo que a conversão é perfeita -- de certa forma, unicode
+simplesmente é uma forma de tratar os bytes que estão por baixo -- mas
+reclamar que a mudança fez a _sua_ forma de pensar mais difícil não é desculpa
+para não entender para onde o eco sistema está indo -- e também não quer dizer
+que o seu projeto específico não é bem-vindo, mas você tem que entender que
+está no caso minoritário aqui.
+
+(E também não me surpreende que alguém dizendo que "mundo em unicode está
+errado" vem de alguém que vive num país ASCII.)
+
+## [Making Python Programs Blazingly Fast](https://martinheinz.dev/blog/13)
+
+Um conjunto de dicas de como fazer aplicações Python funcionarem mais rápido.
+Algumas coisas podem não parecer fazer muito sentido (colocar uma variável
+apontando pra outra dentro da mesma classe?), mas o post pelo menos explica
+_por que_ isso ajuda na performance.
+
+## [Httpx: A next-generation HTTP client for Python](https://www.python-httpx.org/)
+
+[Requests](https://2.python-requests.org/en/master/) mostrou pra todo mundo
+como APIs devem funcionar, mas o projeto meio que ficou parado no tempo, sem
+suporte a chamadas async (e alguns outros probleminhas na gerencia do
+projeto). Agora existe Httpx, que é outra biblioteca para fazer requisições
+HTTP, mas dessa vez com suporte a async e basicamente a mesma interface.
+
+## [No-judgment digital definitions: Online advertising strategies](https://blog.mozilla.org/firefox/online-advertising-strategies/)
+
+Já se perguntou como é que depois de pesquisar alguma coisa -- por exemplo,
+"cadeiras gamer" -- de repente começam a surgir promoções e propagandas de
+cadeiras na sua rede social?
+
+Nada acontece por acaso, e isso é um efeito de todos os trackers que são
+colocados numa página. Mas como é que eles identificam quem é quem é que é a
+questão.
+
+Esse artigo da Mozilla, embora pareça meio básico para quem acompanha, mostra
+bem como essas coisas funcionam.
+
+## [Google Is Not God of The Web](https://bilge.world/google-page-experience)
+
+Outro título um pouco "clickbait" mas, de novo, conteúdo interessante.
+
+Um ponto que me chamou a atenção foi "Google has the right to dictate 'Best
+Practices.'" (Google tem o direito de ditar o que são as "boas práticas") que
+apesar do título diz exatamente o contrário.
+
+Imaginem vocês que o Google comece a dar notas de "experiência de uso" para
+páginas que adotem o visual do Material. Páginas e páginas que parecem com
+aplicativos Android. Mas se você utilizar o seu próprio layout, seu próprio
+conjunto de cores, você vai perder pontos. E agora?
+
+Esse é o grande problema da dependência que as pessoas tem com o Google, e
+toda a simbiose que o mesmo tem tendo um grupo trabalhando para padrões da
+web, um grupo trabalhando para fazer um browser e um grupo pra tirar proveito
+do trabalho dos dois anteriores. Quando menos você usar o Google, quanto mais
+você usar ferramentas de pesquisa alterativos (DuckDuckGo, Searx, e até mesmo
+o Bing), quanto mais você usar outros provedores de email (ProtonMail), quanto
+mais vocês usarem browsers que não sejam Chrome (Firefox, Safari, ou algum
+outro baseado em WebKit), menor vai ser a probabilidade de que a internet se
+torne um ambiente de uma empresa só.
+
+--- 
+
+Esse post foi feito com a ajuda de
+
+* [HN Tooter](https://mastodon.social/@hntooter)
+
+<!-- 
+vim:spelllang=pt:
+-->