Links for 2020-07-19

content/links/20200719.md

@@ -0,0 +1,81 @@
++++
+title = "Commented Links for 2020-07-19"
+date = 2020-07-19
+
+[taxonomies]
+tags = ["links", "unix", "build", "c", "data structures", "algorithms", "zig",
+"rust", "linux", "kernel", "ai", "git", "git ignore", "ci", "cd"]
++++
+
+Building Executables Unix Way, Really Used Data Structures and Algorithms, Zig
+Foundation, Rust on Linux, Bad AI, Git Ignore, What is CI and CD.
+
+<!-- more -->
+
+## [Traditional Unix Toolchains](https://bsdimp.blogspot.com/2020/07/traditional-unix-toolchains.html?m=1)
+
+While the title may give some impression that it will talk about common unix
+tools (and pipes, and `&&` and `||`), it actually talks about the process the
+unix compilers take on converting your C code into an executable.
+
+It is a bit succinct, but succinct in the right places. It gives a good
+explanation on the whole process, the involved tools and their jobs in the
+process.
+
+## [Data Structures & Algorithms I Actually Used Working at Tech Companies](https://blog.pragmaticengineer.com/data-structures-and-algorithms-i-actually-used-day-to-day/)
+
+When doing job interviews, we get asked about a lot of stuff. But what do we
+_actually_ use? Kinda reminds of that joke about the job interview asking to
+invert a binary tree and the job is just to move a button 2 pixels to the
+left.
+
+But it is good to know what is actually useful, in real life applications. And
+not just some CRUD or whatever, but what goes into Skype and Uber.
+
+## [Announcing the Zig Software Foundation](https://ziglang.org/news/announcing-zig-software-foundation.html)
+
+Zig is a small language aimed to fix the problems with C.
+
+What impressed me here is that the Rust community had talks about making a
+foundation, so the language would be open to everyone, but still didn't manage
+to make it.
+
+So, kuds to Zig developers for creating their foundation!
+
+## [Linux kernel in-tree Rust support](https://lkml.org/lkml/2020/7/10/1261)
+
+Alright, so it seems the Linux developers finally opened to doors to new
+languages in their tree.
+
+What feels "wrong" here is that Linus is saying that "Rust support" should
+always be up, so if something breaks, they can point that it was broken
+anyway. The "wrong" part is that this, obviously, puts visibility on things
+that _don't_ work instead of focusing on the things that _do_ work. What if
+there are a couple of modules working fine, but only one fails? Obviously
+everybody will point out that the support _doesn't_ work and people should
+stick with what still works.
+
+But Linus, you know...
+
+## [Awful AI](https://github.com/daviddao/awful-ai)
+
+Not every AI is good. Not every AI will help you find an open spot for that
+meeting with everyone. Not every AI will tag your photos with locations and
+loved one -- but they would tag any black people as "gorillas". Or maybe say
+who may be gay or not (and think how those people would be affected on
+countries that see homosexuality as a crime). The list goes on and on.
+
+## [gitignore.io](https://www.toptal.com/developers/gitignore)
+
+Create a comprehensive `.gitignore` for your project, based on your language
+and tools.
+
+## [The real difference between CI and CD](https://fire.ci/blog/the-difference-between-ci-and-cd/)
+
+What does CI and CD do? What they are there for?
+
+I've been thinking about doing a presentation for people starting with in
+development about each of those -- 'cause, you know, there are a bunch of
+people still thinking `git push` on your computer and `git pull` on the
+production server is a good decision...
+

content/links/20200719.pt.md

@@ -0,0 +1,87 @@
++++
+title = "Links Comentados de 2020-07-19"
+date = 2020-07-19
+
+[taxonomies]
+tags = ["links", "unix", "build", "c", "estruturas de dados", "algoritmos",
+"zig", "rust", "linux", "kernel", "ia", "git", "git ignore", "ci", "cd"]
++++
+
+Criando Executáveis no Estilo Unix, Estruturas de Dados e Algoritmos Realmente
+Usados, Fundação Zig, Rust no Linux, IA Ruim, Git Ignore, O Que É CI e CD.
+
+<!-- more -->
+
+## [Traditional Unix Toolchains](https://bsdimp.blogspot.com/2020/07/traditional-unix-toolchains.html?m=1)
+
+Embora o título possa dar a impressão que vai ser falado das ferramentas
+comuns de unix (e pipes, e `&&` e `||`), na verdade o post fala sobre o
+processo que os compiladores unix fazem quando estão convertendo seu código C
+em um executável.
+
+Pode ser um pouco sucinto, mas e sucinto nos lugares certos. Explica bem todo
+o processo, as ferramentas envolvidas e o que elas fazem no processo inteiro.
+
+## [Data Structures & Algorithms I Actually Used Working at Tech Companies](https://blog.pragmaticengineer.com/data-structures-and-algorithms-i-actually-used-day-to-day/)
+
+Quando estamos fazendo entrevistas de emprego, somos perguntados sobre um
+monte de coisas. Mas o que _realmente_ é usado? Me lembra aquela piada de que
+as pessoas são perguntadas, na entrevista, para escreverem um algoritmo para
+inverter uma árvoce binária, mas o trabalho é mover um botão 2 píxeis para a
+esquerda.
+
+Mas é bom saber o que é realmente utilizado, em aplicações de verdade. E não
+apenas em algum CRUD ou algo do tipo, mas o que acontece em aplicações como
+Skype e Uber.
+
+## [Announcing the Zig Software Foundation](https://ziglang.org/news/announcing-zig-software-foundation.html)
+
+Zig é uma pequena linguagem que se colocou para resolver os problemas com C.
+
+O que me impressionou aqui é que a comunidade Rust tem falado sobre criar uma
+fundação, para que a linguagem fique aberta para todos, mas até agora não
+conseguiram fazer.
+
+Então, parabéns para os desenvolvedores do Zig por criarem a sua fundação!
+
+## [Linux kernel in-tree Rust support](https://lkml.org/lkml/2020/7/10/1261)
+
+Parece que os desenvolvedores do kernel do Linux finalmente abriram as portas
+para novas linguagens na área de desenvolvimento.
+
+O que me parece "errado" aqui é o Linus dizendo que o "suporte a Rust" deve
+estar sempre ligado, e se algo quebrar, eles podem apontar que o suporte
+estava quebrado. A parte "errada" disso é que, obviamente, bota visibilidade
+nas coisas que _não_ funcionam ao invés das que funcionam. O que acontece se
+tiverem módulos que funcionam corretamente, mas um deles falha? Obviamente que
+todo mundo vai dizer que o suporte não funciona e que as pessoas devem
+continuar com o que funciona.
+
+Mas Linus, sabe como é...
+
+## [Awful AI](https://github.com/daviddao/awful-ai)
+
+Nem toda IA é boa. Nem toda IA vai te ajudar a encontrar um horário disponível
+para todo mundo pra uma reunião. Não é toda IA que vai colocar as tags nas
+suas fotos com localizações e as pessoas que você gosta -- mas que vão também
+marcar pessoas negras como "gorilas". Ou talvez dizer quem é gay ou não (e
+pense como isso afetaria essas pessoas em países que consideram
+homossexualidade um crime). E a lista continua.
+
+## [gitignore.io](https://www.toptal.com/developers/gitignore)
+
+Crie um `.gitignore` para todas as coisas do seu projeto, baseado na linguagem
+e ferramentas que você usa.
+
+## [The real difference between CI and CD](https://fire.ci/blog/the-difference-between-ci-and-cd/)
+
+O que CI e CD fazem? Para que eles servem?
+
+Eu tenho essa ideia de fazer uma apresentação para pessoas que estão começando
+com desenvolvimento sobre isso -- porque, vocês sabem, ainda existem pessoas
+que acham que fazer um `git push` no computador e `git pull` no servidor de
+produção e uma boa decisão...
+
+<!-- 
+vim:spelllang=pt:
+-->