UI redesign and merge of Tips and Tutorials (#12)

* Set Tailwind to use dark class for its dark theme

* Slightly change light theme

* Switch to a Serif font

* Make the ToC on Articles look better, increase font size

* Merge Tips and Tutorials back together and use tags to distinguish them

(R.I.P. SEO)

* Fix badge link on Articles list

* Add symlinks for Tips and Tutorials and refactor workflow

Author: mbuffa

Diff for: .github/workflows/main.yml

@@ -32,15 +32,26 @@ jobs:
           npm run build
           cp vendor/* public/
 
-      - name: Push
+      - name: Bake
         run: |
           cd $GITHUB_WORKSPACE
           git fetch -p
           git checkout master
           rm -rf config.toml content sass templates
           cp -R public/* .
+          # The two following lines are here to preserve SEO.
+          ln -s articles tips
+          ln -s articles tutorials
           rm -rf public
+
+      - name: Commit
+        run: |
+          cd $GITHUB_WORKSPACE
           git add -f .
           git status
           git commit -m "New release"
+
+      - name: Push
+        run: |
+          cd $GITHUB_WORKSPACE
           git push origin master

Diff for: content/tips/20200815-rails-deprecate-activerecord-attribute.md renamed to content/articles/20200815-rails-deprecate-activerecord-attribute.md

@@ -2,25 +2,29 @@
 title = "Rails: Deprecate an ActiveRecord attribute"
 date = 2020-08-15
 [taxonomies]
-tags = ["rails"]
+tags = ["tip", "rails"]
 +++
 
 ## Context
+
 When working on a growing application relying on a database, it is not uncommon to have a data model that collects dust: some of its data may become obsolete, but you may not want to delete it just yet, because you may need to migrate it, prepare its deletion later or keep it as history.
 
 You might want to flag this data as deprecated, so that no one (including you) would rely on this no longer updated or relevant data.
 
 ## How
+
 You could of course add comments in your code, but there would be no guarantee someone would check those comments before using those attributes. Also, you wouldn't notice anything if existing code would use those attributes indirectly.
 
 Fortunately, Rails provides [a nice way to flag ActiveRecord attributes as obsolete][0], stabilized since Rails 4.x.
 
 Let's create a `Deprecator` class, that'll embed any behavior we'd like to implement. We can be creative here, like:
+
 - logging the action
 - logging parts of the stacktrace
 - shaming your coworkers on Slack with a bot message
 
 But let's keep it simple for the time being:
+
 ```ruby
 # app/deprecators/field_deprecator.rb
 class FieldDeprecator
@@ -34,6 +38,7 @@ end
 We're not respecting the semantics of the second argument, but hey, this is duck-typing :trollface:
 
 Then, all we have to do is to add a call to this class method in our model:
+
 ```ruby
 class Racoon < ApplicationRecord
   deprecate \
@@ -44,11 +49,12 @@ end
 ```
 
 With our current deprecator, this would output a warning message everytime this field is being read and updated:
+
 ```
 > Racoon.first.owner_id
 owner_id is deprecated, please favor Racoon#caretaker_id
 ```
 
-*Et voilà.*
+_Et voilà._
 
 [0]: https://apidock.com/rails/v4.0.2/Module/deprecate

Diff for: content/tutorials/20200816-developing-on-wsl.md renamed to content/articles/20200816-developing-on-wsl.md

@@ -2,22 +2,25 @@
 title = "Developing on WSL"
 date = 2020-08-16
 [taxonomies]
-tags = ["wsl", "dev"]
+tags = ["tutorial", "wsl", "dev"]
 +++
 
 ## Context
+
 The latest versions of Windows 10 have seen the maturation of WSL, the Windows Subsystem for Linux. Basically, it allows installing a Linux distribution that'll use a special Linux kernel running "nativaly" on Windows 10. It doesn't run on a virtualized environment, although it seems to use a Hyper-V volume for storage.
 
 Oh, and you can also use their shiny new [Terminal][0] for ultimate ease of use.
 
 ## The Good
 
 ### Seamless development
+
 You will evolve in a familiar environment if you're already using VSCode, since it leverages its client/server architecture, each running on Windows and Linux respectively. Typing `code .` in your terminal will open VSCode. Extensions will be installed server-side.
 
 Other than that, you can enjoy the benefits of using any regular Linux distribution.
 
 ### You can use Docker
+
 Since the release of WSL 2 (included in the 2004 Windows update), you can use Docker containers inside your Linux distro, managed by your Docker daemon installed on Windows. "All" it requires is using a WSL2 compatible distribution, and enable WSL2 integration in the Docker Desktop preferences.
 
 And, instead of using a virtual machine to host the containers, you can also set Docker Desktop to use... WSL2.
@@ -29,18 +32,21 @@ I haven't made any benchmarks, but I suppose it helps to boost performance.
 I suppose you can even use your Kubernetes cluster installed with Docker on Windows from your Linux distribution, but I haven't come that far into testing yet.
 
 ### Accessing files between Linux and Windows
+
 Your Windows volumes are automatically mounted in `/mnt`, meaning you can literally access anything from your Windows installation. Also, typing `explorer.exe .` reveals the current folder in Windows' file manager, shown as a network shared volume.
 
 ## The Bad
 
 ### Occasional bugs and freezes
+
 I do backend development in Ruby (and Rails), Elixir (and mostly Phoenix) professionally, and I also wrote a bit of Elm and Rust in WSL2. I am quite satisfied with the quality of the integration WSL2 offers, but it isn't bug-free either.
 
-For example, when I first tried Zola and ran its web server, I just couldn't connect to it with my browser. Firefox was just displaying "Unable to connect". The reason? I don't know, but running `wsl.exe --shutdown` would "solve" this problem. I'm obviously more annoyed by the fact that I *need* to reboot than the fact that I only lose a few seconds of my time every week or so.
+For example, when I first tried Zola and ran its web server, I just couldn't connect to it with my browser. Firefox was just displaying "Unable to connect". The reason? I don't know, but running `wsl.exe --shutdown` would "solve" this problem. I'm obviously more annoyed by the fact that I _need_ to reboot than the fact that I only lose a few seconds of my time every week or so.
 
 But the most annoying thing was occurring during the compilation of my Rust project through Docker (it never happened when I was building "on bare metal"), which was the complete freeze of VSCode, my terminal, and really, any app related to WSL. In that case, I'd need to wait for a few minutes for the build to finish and my system to be responsive again. I assume this has something to do with my building process eating all of the IO reserved for WSL, or something related to this weird Docker setup.
 
 ### Wondering about long-term stability
+
 While Microsoft provided a migration script to switch from WSL to WSL2 (through the use of `wsl.exe`, to run in `cmd.exe` or PowerShell), it never worked on the Ubuntu I installed a few months ago, so I tried a few several other distributions (Alpine, Arch) after finally installing a fresh new Ubuntu, which worked instantly with Docker integration. I think not all distributions available on the store are compatible with WSL2, but information is a bit scarce.
 
 So far, my setup has been very stable, but I wonder if a future Windows update could break the whole thing. I got almost anything versioned and hosted somewhere, but still.
@@ -49,7 +55,9 @@ And sure, there's bugtracking through Github, but I think WSL as a whole is pret
 ## The Ugly
 
 ### Get out of my $PATH
+
 To achieve a seemless integration with Windows, my Ubuntu installation has basically the whole Windows mess injected into its default $PATH:
+
 ```
 ➜  / echo $PATH
 /home/makks/.asdf/shims:/home/makks/.asdf/bin:/home/makks/.cargo/bin:/home/makks/bin:/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin:/usr/games:/usr/local/games:/mnt/c/Windows/system32:/mnt/c/Windows:/mnt/c/Windows/System32/Wbem:/mnt/c/Windows/System32/WindowsPowerShell/v1.0/:/mnt/c/Windows/System32/OpenSSH/:/mnt/c/Program Files/NVIDIA Corporation/NVIDIA NvDLISR:/mnt/c/Program Files (x86)/NVIDIA Corporation/PhysX/Common:/mnt/c/Program Files/Git/cmd:/mnt/c/WINDOWS/system32:/mnt/c/WINDOWS:/mnt/c/WINDOWS/System32/Wbem:/mnt/c/WINDOWS/System32/WindowsPowerShell/v1.0/:/mnt/c/WINDOWS/System32/OpenSSH/:/mnt/c/Program Files/Docker/Docker/resources/bin:/mnt/c/ProgramData/DockerDesktop/version-bin:/mnt/c/Users/Makks/.cargo/bin:/mnt/c/Users/Makks/AppData/Local/Microsoft/WindowsApps:/mnt/c/Users/Makks/AppData/Local/Programs/Microsoft VS Code/bin:/mnt/c/Users/Makks.cargo/bin:/mnt/c/Users/Makks/AppData/Local/GitHubDesktop/bin:/mnt/c/Users/Makks/AppData/Local/Microsoft/WindowsApps
@@ -62,6 +70,7 @@ Whish is... yeah. It itched me in many places when I saw this, and when I saw ra
 This kind of dirty black magic may annoy you if you want your distro to be 100% clean. But I guess you wouldn't want to use WSL in the first place in that was the case ;)
 
 ## Conclusion
+
 I'm very satisfied with WSL and its related developments so far. My primary reason for using it is the need for good UI and accessibility tools, because I have an extremely low vision (but I'll run into details in a future article) but it's also really satisfying to leverage a good CPU (in that case, a Ryzen 3800X) instead of the traditional coughing overpriced Macbook Pro any startup company grants its employees with.
 
 And of course, you can launch a game or two when you need a break.

Diff for: content/tutorials/20201022-elixir-clustering-on-kubernetes.md renamed to content/articles/20201022-elixir-clustering-on-kubernetes.md

@@ -3,10 +3,11 @@ title = "Elixir: Clustering on Kubernetes"
 description = "A quick walkthrough to setup a cluster with Elixir, Kubernetes and libcluster."
 date = 2020-10-21
 [taxonomies]
-tags = ["elixir", "k8s"]
+tags = ["tutorial", "elixir", "k8s"]
 +++
 
 ## Context
+
 When developing Elixir applications, you may want to create a cluster of Erlang nodes at some point, for example, to provide redundancy, high availability,or to share a global state on the cluster (with Mnesia, for example) without hitting an outside DBMS.
 
 This can be easily achieved with `libcluster`. As you can see [in the docs][0], it supports multiple strategies.
@@ -16,17 +17,21 @@ I'll assume you want to deploy to a Kubernetes cluster, and I'll be covering thi
 We'll deploy a `cluster` of Erlang `nodes`. To avoid confusion with Kubernetes terminology, I'll use the prefix `k8s` when referring to Kube.
 
 ## A word about WSL
+
 You may run into one issue if you're using WSL: by default, WSL systems use the same hostname as their Windows host, which isn't fully qualified, and Erlang may not like that.
 
 To fix this (and to avoid breaking WSL), you can specify a full computer name on Windows.
+
 1. Go to your PC settings (`This PC` -> `Properties` -> `Change Settings` -> `Change`),
 2. In the `Computer/Domain Changes` window, keep a simple Computer Name,
 3. Click on More, and in the `DNS Suffix and NetBIOS Computer Name` window, specify a primary DNS suffix (like `localdomain`).
 
 You can keep the other settings unchanged, provided you have something like `barney` as computer name and `barney.localdomain` as full computer name.
 
 ## Connecting nodes locally
+
 Let's make a new clean project with Mix:
+
 ```
 > mix new cluster
 > cd cluster
@@ -41,57 +46,67 @@ And let's start a `iex` REPL, giving it a new argument:
 Here, we just passed a flag to the Erlang VM, specifying the shortname of the node we want to run.
 
 There's now a slight difference appearing in your prompt:
+
 ```
 iex(a@{HOSTNAME})1>
 ```
 
 You should see your PC hostname at the right of that `@` symbol. This is a default value, because we haven't specified a fully qualified name.
 
 Let's start a second Elixir app, in another terminal:
+
 ```
 > iex --sname b
 ```
 
 And let's discover a few functions!
 
-* `node()` (or `Node.self()`) returns the name of the current Node.
-* `Node.list()` returns a list of the connected Nodes in the cluster. At this point, it should be empty.
-* `Node.connect()` and `Node.disconnect()` allow you to, you guessed it, connect and disconnect nodes. Let's try it!
+- `node()` (or `Node.self()`) returns the name of the current Node.
+- `Node.list()` returns a list of the connected Nodes in the cluster. At this point, it should be empty.
+- `Node.connect()` and `Node.disconnect()` allow you to, you guessed it, connect and disconnect nodes. Let's try it!
 
 On the `b` Node, type:
+
 ```
 Node.connect(:a@hostname)
 ```
 
 Now, go back to the `a` Node, and run:
+
 ```
 Node.list()
 ```
 
 You should see `b@hostname` appearing there. Congratulations :) We haven't done anything spectacular this far, but this is exactly what `libcluster` will do under the hood once it's set up correctly.
 
 ## Todo
+
 So, here's what we'll have to do:
+
 1. Pass the relevant fully qualified name to each Erlang VM
 2. Update our Kubernetes configuration
 3. Define a cluster topology to configure `libcluster`
 
 ## VM Args
+
 We'll need to pass some arguments to our Erlang VMs.
 Since at least its version `1.10`, Mix can handle this (you won't need to add Distillery as a dependency).
 
 In your project directory, run:
+
 ```
 mix release.init
 ```
 
 This command will generate a few files. Let's take a look at `vm.args.eex`. It should contain a few commented lines, specifically:
+
 ```sh
 ## Customize flags given to the VM: http://erlang.org/doc/man/erl.html
 ## -mode/-name/-sname/-setcookie are configured via env vars, do not set them here
 ```
 
 Since we want to set `name` and deploy on Linux containers, let's get to `env.sh.eex`. There's a few commented lines in there, but we're most interested in the last block:
+
 ```sh
 # Set the release to work across nodes. If using the long name format like
 # the one below ([email protected]), you need to also uncomment the
@@ -101,12 +116,14 @@ Since we want to set `name` and deploy on Linux containers, let's get to `env.sh
 ```
 
 To enable clustering, we need to replace the `127.0.0.1` part with the fully qualified name of our pod. Kubernetes has its own internal DNS, and pods are typically named like this:
+
 ```
 # Assuming our Pod IP is 192.168.0.45
 192-168-0-45.namespace.pod.cluster.local
 ```
 
 So your setup should end up looking like this:
+
 ```sh
 export POD_A_RECORD=$(echo $POD_IP | sed 's/\./-/g')
 export RELEASE_DISTRIBUTION=name
@@ -116,7 +133,9 @@ export RELEASE_NODE=myapp@$(echo $POD_A_RECORD).$(echo $NAMESPACE).pod.cluster.l
 Both `$POD_IP` and `$NAMESPACE` will have to be defined when our application starts, so we'll add those to our k8s deployment manifest.
 
 ## Kubernetes configuration
+
 We should now declare our two new environment variables:
+
 ```yaml
 apiVersion: apps/v1
 kind: Deployment
@@ -155,19 +174,23 @@ spec:
 ```
 
 Both variables references the pod's information once it's started. You can check it by running:e by running:
+
 ```
 kubectl get pod myapp-456789 -o yaml
 ```
 
 If you already have one pod correctly labelled, you can check that libcluster will correctly poll the right pods from Kube by doing what it does: polling with a labelSelector:
+
 ```
 kubectl get pods -l app=myapp,tier=web
 ```
 
 If this returns off-topic pods, then you should fix this before proceeding :)
 
 ## Libcluster topology
+
 Last, but not least, we need to specify our libcluster strategy:
+
 ```elixir
 topologies = [
   default: [
@@ -190,29 +213,35 @@ topologies = [
 Once you deploy this, you should be good :) After scaling up your deployment (`kubectl scale --replicas=X deployment/my-app`), you should see various `[libcluster]` log entries on your pods.
 
 ## What now?
+
 There's a few things to toy around with if you want to leverage your cluster!
 
 Starting from there, and after cleaning your configuration and/or setting up cleaner environment variables, there are a few interesting things to do. How about:
-* Declaring a GenServer tracking nodes status?
-* Implementing a Cluster Singleton worker using [Individual][8]?
-* Toying around with Phoenix.PubSub?
-* Playing with process registries, like Phoenix.Tracker?
-* Discovering Erlang's [Mnesia][9], a powerful in-cluster DBMS to use for internal state or cache, and which makes Redis irrelevant?
+
+- Declaring a GenServer tracking nodes status?
+- Implementing a Cluster Singleton worker using [Individual][8]?
+- Toying around with Phoenix.PubSub?
+- Playing with process registries, like Phoenix.Tracker?
+- Discovering Erlang's [Mnesia][9], a powerful in-cluster DBMS to use for internal state or cache, and which makes Redis irrelevant?
 
 ## Node up/down notifications
+
 [Erlang exposes a simple function][10] that'll get the current process notified when nodes are up or down. This can allow us to react accordingly, like printing debug information in the logs, dereferencing the node, or push the self destruct button.
 
 In our first example, if you had run the following before connecting the two nodes together:
+
 ```elixir
 :net_kernel.monitor_nodes(true)
 ```
 
 Then running `flush` would show you the messages you received:
+
 ```elixir
 {:nodeup, :a@Hostname}
 ```
 
 You can call `monitor_nodes` in a [GenServer][11], of course, and implement the relevant callbacks:
+
 ```elixir
 def handle_info({:nodeup, node}, state) do
   IO.puts("[STORE] Node connected: #{inspect node}")
@@ -226,6 +255,7 @@ end
 ```
 
 ## Conclusion
+
 This article is a bit long and rough around the edges, but it should give you a better understanding on how to deploy Elixir applications as a cluster.
 
 I strongly suggest that you follow the official documentations of Elixir, Erlang and libraries. The snippets I included may get outdated over time, though I don't expect the process to be easier than it currently is :)