Move some things around

1 files changed, 114 insertions, 0 deletions

diff --git a/reviews/blog-roll.md b/reviews/blog-roll.md
new file mode 100644
index 0000000..a56cc6c
--- /dev/null
+++ b/reviews/blog-roll.md
@@ -0,0 +1,114 @@
+This is a list of blog-ish websites where I found insightful stuff
+that I would like not to forget.
+
+# [LispCast]
+
+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.
+
+[LispCast]: https://lispcast.com/category/writing/
+[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]
+
+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]
+    - [How to Write Portable C Without Complicating Your Build]
+    - [A Tutorial on Portable Makefiles]
+
+- 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]
+
+[null program]: http://nullprogram.com/index/
+[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/
+[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]
+
+[A hash table re-hash]
+:   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.
+
+[Et tu, Cthulhu]: https://hpjansson.org/blag/
+[A hash table re-hash]: https://hpjansson.org/blag/2018/07/24/a-hash-table-re-hash/
+
+# [Evanmiller.org]
+
+I mostly only read the articles dealing with programming languages.
+The down-to-earth commentary made me feel like the author both
+appreciates the thought process that went into the design, and has
+enough hindsight to find where that thought process fell short.
+
+[A Taste of Rust]
+:   An overview of some of the language's features.  Some comments
+    resonated particularly well with me, e.g. on nested functions:
+
+    > With other languages, I’m never quite sure where to put
+    > helper functions.  I’m usually wary of factoring code into
+    > small, “beautiful” functions because I’m afraid they’ll end
+    > up under the couch cushions, or behind the radiator next to
+    > my car keys.  With Rust, I can build up a kind of organic
+    > tree of function definitions, each scoped to the place where
+    > they’re actually going to be used, and promote them up the
+    > tree as they take on the Platonic form of Reusable Code.
+
+[Evanmiller.org]: https://www.evanmiller.org/
+[A Taste of Rust]: https://www.evanmiller.org/a-taste-of-rust.html