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 # [Bartosz Ciechanowski] [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] [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). [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