blog/content/links/20200419.md

+++
title = "Links for 2020-04-19"
date = 2020-04-19

[taxonomies]
tags = ["links", "hierarchical data", "mysql", "licenses", "commons clause",
"clojure", "generics", "configuration", "config files", "zoom", "rust", "cli",
"seo"]
+++

Managing Nested Data in MySQL, The Commons Clause License, Clojure, A Look
into Compilers, No `<>` to Generics, Configuration Files, Zoom Fiasco, Rust
CLI tools, SEO.

<!-- more -->

# [Managing Hierarchical Data in MySQL](http://mikehillyer.com/articles/managing-hierarchical-data-in-mysql/)

A bunch of tips on how to manage nested/hierarchical information in MySQL.
While the storage format could be used in any database, it seems the insertion
part in the post is MySQL specific.

Curious, nonetheless.

# [The Commons Clause will destroy open source](https://drewdevault.com/2018/08/22/Commons-clause-will-destroy-open-source.html)

While I don't agree with Drew in some points (mostly the things he rants
about), and while I don't think, on the surface, that the Commons Clause may
destroy open source, his words are a cautionary tale about picking the right
license[^1].

# [Guide to starting with Clojure](https://grison.me/2020/04/04/starting-with-clojure/)

It's been too long since I saw a very detailed introduction of a language like
this. Explaining installs, IDE/Editor configuration, a short description of
the language, a toy problem and a way to build and deploy the result.

Really complete -- and, on the plus side, it's Clojure!

# [The Svelte Compiler Handbook](https://lihautan.com/the-svelte-compiler-handbook/)

While related to Svelte -- the JavaScript templating language -- what it
describes is pretty close to what every compiler do, in a high level, even if
some do more stuff, like Rust having two more steps before the code
generation, for optimization.

# [Language Design: Stop Using \<\> for Generics](https://soc.me/languages/stop-using-for-generics)

Let's get into some controversy, shall we?

One the major points of Clojure is exactly how it pick one single pair for
each different aspect, contrary to Lisp, which used parenthesis for
everything.

So, what is being described here is to use `[]` instead of `<>` for generics.
But wouldn't that clash with array access? Sure, that's why array access
should be `()`. But wouldn't that clash with function calling? Sure, that's
why function calling should be... should be what again? Nothing? So we let it
clash?

"`<>` is hard for compilers to parse". Oh, poor compiwer, it is weaving a bad
time? Newsflash, the job of a compiler _is_ to take the hard work and leave
the simpler thing to users; the harder it does its work, the easier it is for
their users. If the users can clearly see generics with `<>` -- because it is
different from everything else -- then it is good.[^2]

# [Your configs suck? Try a real programming language.](https://beepb00p.xyz/configs-suck.html)

Another controversy, just for fun.

Ok, so config formats are bad 'cause you can't replicate some stuff -- I can
agree with that, imagine having to copy and paste the same value over and
over?

But the problem is: Using a "real programming language" for configuration may
also have a problem: you need to cut a lot of stuff. Django uses Python itself
as a configuration -- and, again, I can agree with that, 'cause it allows one
to have a default configuration and just import it and override things for
your local execution -- but it doesn't block running anything. Worse, because
you can import things into the configuration file, one project that gets
compromised will _always_ run the code.

Again, I agree with a lot of points, including the fact that the current
formats for configuration files are bad, but using a programming language for
it is not the solution. Besides, it is possible to overcome those problems
with better configuration settings themselves than the format; as hard as it
is.

# [Security and Privacy Implications of Zoom](https://www.schneier.com/blog/archives/2020/04/security_and_pr_1.html)

While articles about the raise of Zoom and its problems popping everywhere,
but Bruce Schneier, the father of internet security, made a post with all its
problems, from privacy to security.

# [My tools are going Rusty](https://elliehuxtable.com/my-tools-are-pretty-rusty/)

A short summary of common Unix/Posix/GNU tools written in Rust.

# [How SEO Ruined the Internet](https://www.superhighway98.com/seo)

Yes, everybody knows how the current trend of creating content focused on
producing better search results -- instead of, say, better quality content
that _should_ be indexed due its quality -- basically made the internet a
terrible place.

This post describes some of the effects of this focus on the general internet
content.

---

[^1]: This was weirdly timed with a presentation I finished talking about
  licenses -- it's in Portuguese, and I haven't present it yet, but at some
  point there will be a companion post for it, even in English.

[^2]: Personally, using Scala as an example of "doing right" feels really
  wrong. Scala does _a lot_ wrong, I don't freaking care how much you like
  Scala. Also, saying Python uses `[]` for generics is wrong 'cause Python
  does _not_ have generics.