Interesting articles and books, either because I like what they have to say or because I want to investigate them more!

• Ted Kaminski's Archive

  Ted Kaminski

  I think I might have heard of this archive initially from https://matklad.github.io/2023/08/06/fantastic-learning-resources.html#Software-Architecture.

  I especially like https://www.tedinski.com/2018/08/28/using-data-to-mutate-state.html. It seems to be the article I keep thinking about, especially when implementing or trying to debug a complex feature at work. As an example at my job, families fill out a form which sends a webhook to our system. Our system processes it to create a set of related records across internal and external repositories. It’s tough to tell which resources and which systems will get affected except by tracing through the code. This makes me think it would be really nice to have a bill of resources as the main output of this process.

• Building a Rust service with Nix

  fasterthanlime

  The article series that finally pushed me to try Nix for my local development. If that interests you, start with 9. Learning Nix from the bottom up, but I think it’s worth it to read the series in order. I don’t yet generate Docker images through Nix (the one time I tried I ran into deployment issues), but using Nix is great for local development! (Except for when I’m a version behind on MacOS and it seems like the rest of the Nix world has moved forward.)

  The one difference I would point out is I prefer using flakey-profile to install general (ie, not project specific) tools:

  https://github.com/prestontw/my-flakey-profile/blob/main/flake.nix#L20-L56

  This comes from Flakes aren’t real and cannot hurt you: a guide to using Nix flakes the non-flake way by Jade.

• Zero To Production In Rust

  Luca Palmieri

  An awesome book, especially if you haven’t set up a server yourself before. I really like its focus on testing and how it walks through the majority of what you need to get started with backend web server development, including authentication and authorization, logging, and, again, testing.

  One companion piece to this is Notes on Luca Palmieri’s Zero to Production in Rust by Chris Allen. I agree with a couple of the recommendations in this link (using docker-compose, diesel), so I held onto it. It might be worth reviewing the recommendations in this article as you finish up chapters in Zero to Production in Rust.

• technicalities: "not rocket science" (the story of monotone and bors)

  graydon2

  Hopefully CI/CD processes become good enough at some point that the learnings from this article is common knowledge, but we aren’t there yet! It seems like we are moving closer there as a community---Github even has support for a merge queue now! For a detailed view of differences and how bors is superior, matklad has a detailed comparison: https://matklad.github.io/2023/06/18/GitHub-merge-queue.html.

• Hypermedia Systems

  Carson Gross, Adam Stepinski, Deniz Akşimşek

  The HTMX book! I had only ever used React apps for front-end before, so this whole exploration was eye-opening.

  Related readings:

  • https://max.engineer/server-informed-ui,
  • https://htmx.org/essays/splitting-your-apis/, and
  • https://htmx.org/essays/locality-of-behaviour/.

  It’s not all sunshine and rainbows, though. While working through this book, I found HTMX to be stringly-typed and ran into some issues re-creating intermediary screens. React Andy’s like to say that view = f(state), but with HTMX I found the expression to be more like

  view = f(initial server state) + backend snippet substitution + backend snippet substitution + ...

  It wasn’t so bad that I couldn’t finish the book, though. I worked through the non-mobile sections of this book in https://github.com/prestontw/rust-htmx-contacts-app. However, I did have to add a fair amount of infrastructure to make working in HTMX less stringly-typed for my taste. I created my first declarative Rust macro as part of this project which would generate id names for using actions in forms as well as generate deserialization header methods so I could easily tell whether a request came from an interaction on the page (like in
  https://github.com/prestontw/rust-htmx-contacts-app/blob/61a42bfc3ba3f483548c59063aa18ba91bfe7fa9/src/html_views.rs#L143-L148), in which case we would only need to send down an HTML snippet instead of the whole page.

  These concerns were mirrored in https://www.youtube.com/watch?v=mt1ZCai1G-I by Web Dev Cody. He calls it “no type safety” instead of “stringly typed”, and mentions the substitution issue in https://youtu.be/mt1ZCai1G-I?si=xUl5SrsfXPuY3YpN&t=1015. I was thinking of combining HTMX and Alpine.js to try to get closer to the view = f(state) ideal, but Datastar’s MergeSignals functionality might be what I’m looking for without as much manual connection… Eventually, I want to write a blog post on this.

• Dan Luu's Archive

  Dan Luu

  I really like Dan Luu’s writing---I’ve definitely gone down the rabbit hole reading his blog. Here are a couple of his articles that I think about frequently:

  • Normalization of deviance: I think about this article when someone onboards. I try to pay attention to weak signals. But, people who are onboarding have to balance learning something new with “Oh, this is different so it’s an issue.”

  • Why is it so hard to buy things that work well?: I like to think of this article as its URL: “nothing works.” This is an article I think of every time I try to integrate with a service at work, especially when the integration doesn’t work exactly as I would like it to.

• Software Friction

  Hillel Wayne

  A quick article on the difference between theory and reality as it pertains to software and the pain points that arise due to that mismatch. I like the list of ways to reduce software friction, but I wish there were more concrete examples.

• Object-Oriented Programming is Bad

  Brian Will

  This video boils down to the following argument:

  • OOP was created as a way to manage shared mutable state
  • It does this by segregating state into separate objects (encapsulation)
  • If you really want to reduce shared mutable state, though, you need to organize your call/composition graph into a tree
  • This is painful to do in the face of changing requirements and dependencies and large scale development
  • Therefore, use procedural code instead.

  I strongly agree with the video’s point about parameterizing dependencies and state. Some other resources in a similar vein:

  • https://www.destroyallsoftware.com/talks/boundaries
  • https://www.youtube.com/watch?v=J1f5b4vcxCQ
  • https://www.tedinski.com/2018/08/28/using-data-to-mutate-state.html