Sort blog roll by SLD

-ish (sort "# Motherfucking websites" at 'M').  No idea how I
proceeded back then (date of discovery?); now I can stop wondering and
insert new sites the same way.

1 files changed, 165 insertions, 165 deletions

diff --git a/reviews/blog-roll.md b/reviews/blog-roll.md
index 1fed21a..6540e70 100644
--- a/reviews/blog-roll.md
+++ b/reviews/blog-roll.md
@@ -1,98 +1,14 @@
 This is a list of blog-ish websites where I found insightful stuff
 that I would like not to forget.
 
-# [LispCast](https://lispcast.com/category/writing/)
-
-Eric Normand's musings on programming paradigms and their application,
-with a soft spot for functional programming.
-
-## [When in doubt, refactor at the bottom]
-
-Quoting Sandi Metz:
-
-> Duplication is far cheaper than the wrong abstraction.
-
-The point being that blindly following the letter of the DRY law can
-lead developers to add complexity to extracted functions because "it
-almost does what I want; if I could add just one more parameter to
-it…".
-
-Normand and Metz encourage developers to "mechanically" extract small
-pieces of logic; even if they are not re-usable, bundling things
-together and naming them helps make the potential abstractions more
-visible.
-
-## [Programming Paradigms and the Procedural Paradox]
-
-A discussion on our tendency to conflate *paradigms* with their
-*features*; for example, when trying to answer "can this language
-express that paradigm?", we often reduce the question to "does this
-language possess those features?".
-
-Normand wonders whether we do this because the procedural paradigm's
-metaphor (a series of steps that each may contain any number of
-sub-tasks) maps so well to its features (sequential statements,
-subroutines) that it trained us to mix those up.
-
-[When in doubt, refactor at the bottom]: https://lispcast.com/refactor-bottom/
-[Programming Paradigms and the Procedural Paradox]: https://lispcast.com/procedural-paradox/
-
-# [null program](http://nullprogram.com/index/)
-
-Chris Wellons's in-depth looks into a fairly wide range of programming
-techniques and applications.  The articles often come with
-illustrative code samples, which are always broken down into
-bite-sized chunks that are easy to grok.
-
-Some recurring topics I enjoy reading about:
-
-- GNU/Linux plumbing
-    - [Raw Linux Threads via System Calls]
-    - [Appending to a File from Multiple Processes]
-    - [A Magnetized Needle and a Steady Hand]
-
-- C programming tricks
-    - [Global State: A Tale of Two Bad C APIs]
-    - [C Closures as a Library]
-
-- Software portability
-    - [How to Write Portable C Without Complicating Your Build]
-    - [A Tutorial on Portable Makefiles]
-    - [Test cross-architecture without leaving home]
-
-- Algorithmics
-    - [Inspecting C's qsort Through Animation]
-    - [A Branchless UTF-8 Decoder]
-    - [Render Multimedia in Pure C]
-
-- Emacs Lisp plumbing
-    - [Some Performance Advantages of Lexical Scope]
-    - [What's in an Emacs Lambda]
-
-[Raw Linux Threads via System Calls]: https://nullprogram.com/blog/2015/05/15/
-[Appending to a File from Multiple Processes]: https://nullprogram.com/blog/2016/08/03/
-[A Magnetized Needle and a Steady Hand]: https://nullprogram.com/blog/2016/11/17/
-[Global State: A Tale of Two Bad C APIs]: https://nullprogram.com/blog/2014/10/12/
-[C Closures as a Library]: https://nullprogram.com/blog/2017/01/08/
-[How to Write Portable C Without Complicating Your Build]: https://nullprogram.com/blog/2017/03/30/
-[A Tutorial on Portable Makefiles]: https://nullprogram.com/blog/2017/08/20/
-[Test cross-architecture without leaving home]: https://nullprogram.com/blog/2021/08/21/
-[Inspecting C's qsort Through Animation]: https://nullprogram.com/blog/2016/09/05/
-[A Branchless UTF-8 Decoder]: https://nullprogram.com/blog/2017/10/06/
-[Render Multimedia in Pure C]: https://nullprogram.com/blog/2017/11/03/
-[Some Performance Advantages of Lexical Scope]: https://nullprogram.com/blog/2016/12/22/
-[What's in an Emacs Lambda]: https://nullprogram.com/blog/2017/12/14/
-
-# [Et tu, Cthulhu](https://hpjansson.org/blag/)
+# [Bartosz Ciechanowski](https://ciechanow.ski/)
 
-## [A hash table re-hash]
+## [Alpha Compositing]
 
-A benchmark of hash tables that manages to succinctly explain common
-performance issues and tradeoffs with this data structure, to show
-results across a wide range of implementations, and to provide very
-understandable interepretations for those results.
+The good, bad and ugly of how we discretize colors, and
+color-blending.  With helpful interactive simulations.
 
-[A hash table re-hash]: https://hpjansson.org/blag/2018/07/24/a-hash-table-re-hash/
+[Alpha Compositing]: https://ciechanow.ski/alpha-compositing/
 
 # [Evanmiller.org](https://www.evanmiller.org/)
 
@@ -117,62 +33,50 @@ resonated particularly well with me, e.g. on nested functions:
 
 [A Taste of Rust]: https://www.evanmiller.org/a-taste-of-rust.html
 
-# [Bartosz Ciechanowski](https://ciechanow.ski/)
-
-## [Alpha Compositing]
-
-The good, bad and ugly of how we discretize colors, and
-color-blending.  With helpful interactive simulations.
-
-[Alpha Compositing]: https://ciechanow.ski/alpha-compositing/
-
-# [Red Hat Developer](https://developers.redhat.com/blog/)
-
-## [10 tips for reviewing code you don't like]
-
-The article could basically be included as-is in a [nonviolent
-communication] textbook and renamed "application to code reviews".
+# [fasterthanli.me](https://fasterthanli.me/)
 
-AFAICT the underlying principle to all these tips is: scrub judgmental
-statements out of your responses, and state your concerns openly.
-Nobody should expect you to hold all the answers; express your
-uncertainty, and let the submitter do the work of convincing you
-(e.g. checking for performance regressions, splitting patch series).
+:::: tags
+- Rust
+- Go
+- Language design
+::::
 
-[10 tips for reviewing code you don't like]: https://developers.redhat.com/blog/2019/07/08/10-tips-for-reviewing-code-you-dont-like/
-[nonviolent communication]: https://en.wikipedia.org/wiki/Nonviolent_Communication
+In-depth explorations of various topics (I mostly read posts covering
+programming language mechanics), told in a dialectic and very
+entertaining style that sustains interest over their Homeric lengths.
 
-# Motherfucking websites
+## [What's in the box?](https://fasterthanli.me/articles/whats-in-the-box)
 
 :::: tags
-- Web design
+- Rust
+- Go
 ::::
 
-Satirical websites fighting [web bloat] with minimalist designs.
-
-- <https://motherfuckingwebsite.com/>  
-  No style at all, content only.
+> The Rust compiler is trying to help us.  "You can't just return a
+> reference to something", it pleads.  "You need to tell me how long
+> the thing that's referenced is will live".
 
-  - <http://bettermotherfuckingwebsite.com/>  
-    Increased line spacing, bigger text, reduced line length.
+> * How does one return different error types without forcing a heap
+>   allocation?
 
-    - <https://evenbettermotherfucking.website/>  
-      Less contrast, better fonts.
+… preferably without having to maintain an ever-shifting enumeration
+of possible error types?
 
-      - <https://thebestmotherfuckingwebsite.co/>  
-        Satire of the satire, to show that it's possible to be fancy
-        and stay lightweight.
+Spoiler: there's no escaping the `enum`, but at least
+[`thiserror`](https://lib.rs/crates/thiserror) lets us focus on *just*
+the enumeration, and generates the boilerplate for the `Display` and
+`From` traits.
 
-    - <https://thebestmotherfucking.website/>  
-      Less contrast, better fonts.
+# [Et tu, Cthulhu](https://hpjansson.org/blag/)
 
-    - <https://bestmotherfucking.website/>  
-      Use fonts the user already have, compress content.
+## [A hash table re-hash]
 
-    - <https://perfectmotherfuckingwebsite.com/>  
-      Think of internationalization.
+A benchmark of hash tables that manages to succinctly explain common
+performance issues and tradeoffs with this data structure, to show
+results across a wide range of implementations, and to provide very
+understandable interepretations for those results.
 
-[web bloat]: https://idlewords.com/talks/website_obesity.htm
+[A hash table re-hash]: https://hpjansson.org/blag/2018/07/24/a-hash-table-re-hash/
 
 # [Joe Duffy's Blog](http://joeduffyblog.com/)
 
@@ -286,6 +190,136 @@ back the stack?
 
 [The Error Model]: http://joeduffyblog.com/2016/02/07/the-error-model/
 
+# [LispCast](https://lispcast.com/category/writing/)
+
+Eric Normand's musings on programming paradigms and their application,
+with a soft spot for functional programming.
+
+## [When in doubt, refactor at the bottom]
+
+Quoting Sandi Metz:
+
+> Duplication is far cheaper than the wrong abstraction.
+
+The point being that blindly following the letter of the DRY law can
+lead developers to add complexity to extracted functions because "it
+almost does what I want; if I could add just one more parameter to
+it…".
+
+Normand and Metz encourage developers to "mechanically" extract small
+pieces of logic; even if they are not re-usable, bundling things
+together and naming them helps make the potential abstractions more
+visible.
+
+## [Programming Paradigms and the Procedural Paradox]
+
+A discussion on our tendency to conflate *paradigms* with their
+*features*; for example, when trying to answer "can this language
+express that paradigm?", we often reduce the question to "does this
+language possess those features?".
+
+Normand wonders whether we do this because the procedural paradigm's
+metaphor (a series of steps that each may contain any number of
+sub-tasks) maps so well to its features (sequential statements,
+subroutines) that it trained us to mix those up.
+
+[When in doubt, refactor at the bottom]: https://lispcast.com/refactor-bottom/
+[Programming Paradigms and the Procedural Paradox]: https://lispcast.com/procedural-paradox/
+
+# Motherfucking websites
+
+:::: tags
+- Web design
+::::
+
+Satirical websites fighting [web bloat] with minimalist designs.
+
+- <https://motherfuckingwebsite.com/>  
+  No style at all, content only.
+
+  - <http://bettermotherfuckingwebsite.com/>  
+    Increased line spacing, bigger text, reduced line length.
+
+    - <https://evenbettermotherfucking.website/>  
+      Less contrast, better fonts.
+
+      - <https://thebestmotherfuckingwebsite.co/>  
+        Satire of the satire, to show that it's possible to be fancy
+        and stay lightweight.
+
+    - <https://thebestmotherfucking.website/>  
+      Less contrast, better fonts.
+
+    - <https://bestmotherfucking.website/>  
+      Use fonts the user already have, compress content.
+
+    - <https://perfectmotherfuckingwebsite.com/>  
+      Think of internationalization.
+
+[web bloat]: https://idlewords.com/talks/website_obesity.htm
+
+# [null program](http://nullprogram.com/index/)
+
+Chris Wellons's in-depth looks into a fairly wide range of programming
+techniques and applications.  The articles often come with
+illustrative code samples, which are always broken down into
+bite-sized chunks that are easy to grok.
+
+Some recurring topics I enjoy reading about:
+
+- GNU/Linux plumbing
+    - [Raw Linux Threads via System Calls]
+    - [Appending to a File from Multiple Processes]
+    - [A Magnetized Needle and a Steady Hand]
+
+- C programming tricks
+    - [Global State: A Tale of Two Bad C APIs]
+    - [C Closures as a Library]
+
+- Software portability
+    - [How to Write Portable C Without Complicating Your Build]
+    - [A Tutorial on Portable Makefiles]
+    - [Test cross-architecture without leaving home]
+
+- Algorithmics
+    - [Inspecting C's qsort Through Animation]
+    - [A Branchless UTF-8 Decoder]
+    - [Render Multimedia in Pure C]
+
+- Emacs Lisp plumbing
+    - [Some Performance Advantages of Lexical Scope]
+    - [What's in an Emacs Lambda]
+
+[Raw Linux Threads via System Calls]: https://nullprogram.com/blog/2015/05/15/
+[Appending to a File from Multiple Processes]: https://nullprogram.com/blog/2016/08/03/
+[A Magnetized Needle and a Steady Hand]: https://nullprogram.com/blog/2016/11/17/
+[Global State: A Tale of Two Bad C APIs]: https://nullprogram.com/blog/2014/10/12/
+[C Closures as a Library]: https://nullprogram.com/blog/2017/01/08/
+[How to Write Portable C Without Complicating Your Build]: https://nullprogram.com/blog/2017/03/30/
+[A Tutorial on Portable Makefiles]: https://nullprogram.com/blog/2017/08/20/
+[Test cross-architecture without leaving home]: https://nullprogram.com/blog/2021/08/21/
+[Inspecting C's qsort Through Animation]: https://nullprogram.com/blog/2016/09/05/
+[A Branchless UTF-8 Decoder]: https://nullprogram.com/blog/2017/10/06/
+[Render Multimedia in Pure C]: https://nullprogram.com/blog/2017/11/03/
+[Some Performance Advantages of Lexical Scope]: https://nullprogram.com/blog/2016/12/22/
+[What's in an Emacs Lambda]: https://nullprogram.com/blog/2017/12/14/
+
+# [Red Hat Developer](https://developers.redhat.com/blog/)
+
+## [10 tips for reviewing code you don't like]
+
+The article could basically be included as-is in a [nonviolent
+communication] textbook and renamed "application to code reviews".
+
+AFAICT the underlying principle to all these tips is: scrub judgmental
+statements out of your responses, and state your concerns openly.
+Nobody should expect you to hold all the answers; express your
+uncertainty, and let the submitter do the work of convincing you
+(e.g. checking for performance regressions, splitting patch series).
+
+[10 tips for reviewing code you don't like]: https://developers.redhat.com/blog/2019/07/08/10-tips-for-reviewing-code-you-dont-like/
+[nonviolent communication]: https://en.wikipedia.org/wiki/Nonviolent_Communication
+
 # [Without boats](https://without.boats/)
 
 ## [Not Explicit]
@@ -324,37 +358,3 @@ and breaking down "explicit" into more precise epithets:
 
 [Not Explicit]: https://without.boats/blog/things-explicit-is-not/
 ["reasoning footprint"]: https://blog.rust-lang.org/2017/03/02/lang-ergonomics.html
-
-# [fasterthanli.me](https://fasterthanli.me/)
-
-:::: tags
-- Rust
-- Go
-- Language design
-::::
-
-In-depth explorations of various topics (I mostly read posts covering
-programming language mechanics), told in a dialectic and very
-entertaining style that sustains interest over their Homeric lengths.
-
-## [What's in the box?](https://fasterthanli.me/articles/whats-in-the-box)
-
-:::: tags
-- Rust
-- Go
-::::
-
-> The Rust compiler is trying to help us.  "You can't just return a
-> reference to something", it pleads.  "You need to tell me how long
-> the thing that's referenced is will live".
-
-> * How does one return different error types without forcing a heap
->   allocation?
-
-… preferably without having to maintain an ever-shifting enumeration
-of possible error types?
-
-Spoiler: there's no escaping the `enum`, but at least
-[`thiserror`](https://lib.rs/crates/thiserror) lets us focus on *just*
-the enumeration, and generates the boilerplate for the `Display` and
-`From` traits.