Inline blog-roll links

To make the next commit easier.

1 files changed, 8 insertions, 16 deletions

diff --git a/reviews/blog-roll.md b/reviews/blog-roll.md
index 9ac77ff..1fed21a 100644
--- a/reviews/blog-roll.md
+++ b/reviews/blog-roll.md
@@ -1,7 +1,7 @@
 This is a list of blog-ish websites where I found insightful stuff
 that I would like not to forget.
 
-# [LispCast]
+# [LispCast](https://lispcast.com/category/writing/)
 
 Eric Normand's musings on programming paradigms and their application,
 with a soft spot for functional programming.
@@ -34,11 +34,10 @@ 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]
+# [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
@@ -70,7 +69,6 @@ Some recurring topics I enjoy reading about:
     - [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/
@@ -85,7 +83,7 @@ Some recurring topics I enjoy reading about:
 [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]
+# [Et tu, Cthulhu](https://hpjansson.org/blag/)
 
 ## [A hash table re-hash]
 
@@ -94,10 +92,9 @@ 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]
+# [Evanmiller.org](https://www.evanmiller.org/)
 
 I mostly only read the articles dealing with programming languages.
 The down-to-earth commentary made me feel like the author both
@@ -118,20 +115,18 @@ resonated particularly well with me, e.g. on nested functions:
 > 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
 
-# [Bartosz Ciechanowski]
+# [Bartosz Ciechanowski](https://ciechanow.ski/)
 
 ## [Alpha Compositing]
 
 The good, bad and ugly of how we discretize colors, and
 color-blending.  With helpful interactive simulations.
 
-[Bartosz Ciechanowski]: https://ciechanow.ski/
 [Alpha Compositing]: https://ciechanow.ski/alpha-compositing/
 
-# [Red Hat Developer]
+# [Red Hat Developer](https://developers.redhat.com/blog/)
 
 ## [10 tips for reviewing code you don't like]
 
@@ -144,7 +139,6 @@ 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).
 
-[Red Hat Developer]: https://developers.redhat.com/blog/
 [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
 
@@ -180,7 +174,7 @@ Satirical websites fighting [web bloat] with minimalist designs.
 
 [web bloat]: https://idlewords.com/talks/website_obesity.htm
 
-# [Joe Duffy's Blog]
+# [Joe Duffy's Blog](http://joeduffyblog.com/)
 
 ## [The Error Model]
 
@@ -290,10 +284,9 @@ waters somewhat with "aborts" which kind of look like `longjmp`s to
 me?  Except it runs the code in `catch` blocks it finds while crawling
 back the stack?
 
-[Joe Duffy's Blog]: http://joeduffyblog.com/
 [The Error Model]: http://joeduffyblog.com/2016/02/07/the-error-model/
 
-# [Without boats]
+# [Without boats](https://without.boats/)
 
 ## [Not Explicit]
 
@@ -329,7 +322,6 @@ and breaking down "explicit" into more precise epithets:
     around to figure it out.  `?` is local to the very line where the
     early return happens.
 
-[Without boats]: https://without.boats/
 [Not Explicit]: https://without.boats/blog/things-explicit-is-not/
 ["reasoning footprint"]: https://blog.rust-lang.org/2017/03/02/lang-ergonomics.html