Some programming-related videos I liked

The industry tends to be a little wary about people being too interested in the theoretical aspect of programming/software engineering. The pursuit of highly subjective values such as "beauty" or "purity" is quite different from "getting things done", after all. Nonetheless, I do believe that being exposed to new ideas is a good thing in general, and being willfully against new ideas could be equally detrimental.

I've recently been watching lots of programming-related videos, mostly recorded conference talks, and here are some that I found somewhat interesting/inspiring/helpful.

What Every Programmer Should Know about How CPUs Work by Matt Godbolt

Abstractions are great in that we don't really need to be thinking about how the hardware actually works in order to be able to write programs, even pretty good ones. Unfortunately, most real-life abstractions are leaky to some degree, which means that you can't fully understand or predict behaviors without peeking into what's happening under the hood. This includes knowing how leaky the abstraction is in the first place.

I haven't really thought about things like out-of-order execution or branch prediction since I took a class on computer architectures 13 years ago. This video was a good refresher on the topics. In short, compilers are very good at optimizing, to the point where most of "clever" tricks like making code branchless or manually unrolling loops are futile, but there can exist cases where the bottleneck is in the low-level mechanism.

One concrete example of abstractions hiding the underlying cost mentioned in the video would be that the integer division taking much longer than, say, the addition. This could be not so obvious because most programming languages don't signify the cost of the operation.

Programming's Greatest Mistakes by Mark Rendle

Some of what's covered here is probably well-known, but some others I'd heard about for the first time. The story of number 38 overflowing(!) in a database was unexpected and hilarious. In general I found it entertaining.

The Many Meanings of Event-Driven Architecture by Martin Fowler

We see the notion of events all the time, but what it is exactly could be nebulous. This talk lays out four slightly different notions people call event-driven, and describes what they are and the tradeoffs each of them comes with. I think knowing this is helpful for being more mindful and deliberate about the tradeoffs we choose when we use the "event pattern".

Stop Writing Dead Programs by Jack Rusher

This talk is about the so-called "live coding", which is a practice of working with a system whose code can be modified on-the-fly without recompiling and restarting the program. Whether or how much you can actually do this depends a lot on the particular language or environment you work with, but I found it interesting to think about how I could make iterations faster and less painful by introducing dynamism of varying degrees in the behavior.

Concatenative Programming and Stack-Based Languages by Douglas Creager

I didn't even know that "concatenate programming" is even a thing (regardless of how useful/popular it is). Basically it is writing any program (which is possible because of Turing completeness) that operates somewhat similarly to how one computes an arithmetic expression written in the postfix notation using a stack. It is kind of a "purely point-free" way of writing programs.

I don't think this is something most of us would find useful in practice, but it sheds light on the notion of associativity in composing routines and what they mean for parallelism. It was kind of striking that this "paradigm" makes the set of all programs a monoid under composition in a natural way.