From 8cfe656fbb312398244d6f0e820d4f179db3cfc7 Mon Sep 17 00:00:00 2001 From: Kévin Le Gouguec Date: Thu, 11 Jul 2019 18:10:53 +0200 Subject: Move some things around --- reviews/blog-roll.md | 114 +++++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 114 insertions(+) create mode 100644 reviews/blog-roll.md (limited to 'reviews/blog-roll.md') 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 -- cgit v1.2.3