Computer, Enhance!

Horizontal Operations

2026-10-21T22:23:39+00:00

--:--

Paid episode

The full episode is only available to paid subscribers of Computer, Enhance!

We can employ our knowledge of shuffles and permutes to make horizontal operations out of the vertical ones provided by SIMD instruction sets.

Oct 21, 2026

∙ Paid

This is the twenty-first video in Part 5 of the Performance-Aware Programming series. Please see the Table of Contents to quickly navigate through the rest of the course as it is updated, and the code repository for downloadable code listings.

SIMD Unpacks

2026-10-14T20:58:25+00:00

In addition to permutes and shuffles, “unpacks” can be used to rearrange data as long as the rearrangement conforms to a very specific pattern.

Oct 14, 2026

∙ Paid

This is the twentieth video in Part 5 of the Performance-Aware Programming series. Please see the Table of Contents to quickly navigate through the rest of the course as it is updated, and the code repository for downloadable code listings.

The full video is for paid subscribers

Already a paid subscriber? Sign in

Programming Courses

A series of courses on programming topics.

SIMD Shuffles

2026-10-07T18:57:47+00:00

SIMD works seamlessly when everything is vertical. Once we want to operate horizontally, we enter the esoteric world of shuffles and permutes.

Oct 07, 2026

∙ Paid

This is the nineteenth video in Part 5 of the Performance-Aware Programming series. Please see the Table of Contents to quickly navigate through the rest of the course as it is updated, and the code repository for downloadable code listings.

The full video is for paid subscribers

Already a paid subscriber? Sign in

Programming Courses

A series of courses on programming topics.

Q&A #88 (2026-10-02)

2026-10-02T22:35:17+00:00

In each Q&A video, I answer questions from the comments on the previous Q&A video, which can be from any part of the course.

As an additional note, for those who are interested in the Loop Stream Detector from question #6 and don’t mind doing some additional reading, there is a security exploit called GADGETSPINNER you might want to look at. The writeup is helpful for learning about the particulars if, like me, you don’t have an Intel CPU with an LSD to play around with yourself. Of potential interest for people focused on optimization are the LSD’s dependence on the branches staying the same each iteration, as well as the total uop size of loop that it can handle.

The questions addressed in this video are:

[00:02] “Some time ago you were investigating some hardware for low level programming (Raspberry Pi, Beagle Board). Do you have any suggestions for someone who wants to try some old school game development with this kind of limited hardware? (Emulating old systems doesn’t really do it for me)”
[02:42] “For some time now I am banging my head against the wall regarding timesteps, framepacing and vsync. I think I understand the gist of how it works in general (frame queues, presentation modes, composition, etc.), but when I try concrete implementations there’s always some kind of catch to work around, which makes it wonky. Like GetFrameStatistics works pretty well, but breaks on multi monitor setups. Manual timing and waiting seems to be too inprecise over time and gives weird results with vsync. What would be the (imaginary, magic) api call needed, to get a metric which solves this once and for all?”
[19:38] “Has the situation regarding the 30 million line problem improved by now? More specifically, I wanted to know. If it’s feasible for someone to make their own mini os for their own mini game that can run on multiple pcs (only targetting modern hardware but also supporting gpu rendering for newer amd cards).”
[23:59] “Hi, more on memory mapped files: the impression I got from the course is that they’re quite bad at nearly everything - you don’t have a lot of control over page faults and when / how io happens. But many fast databases, say lmdb, uses memory mapped files and have excellent performance. Could you maybe explain a little bit more nuance on that side, such as where they have a big advantage and should be used? Or maybe you believe that lmdb authors could have achieved similar performance with less effort?”
[30:02] “I hear people usually say ‘nah, everything been written before us anyway’ or something like that, meaning that you can’t really write anything new, just rebuild/repackage/reinvent the wheel. and you clearly have a different view here. so could you please describe in more details why you think differently (or thought, if something changed)”
[35:52] “I just tried running SpacingLoop with Rocket Lake on uops.info, and I noticed that it shows LSD instead of DSB. I looked it up and found that LSD means Loop Stream Detector. Could you explain how it works?”
[40:25] “A question about those masked instructions: we can save some instructions and work by instead of separately computing two values and then recombining them we just do different computations on the same register with different masks: first computation touches a subset, second computation touches a subset. But doesn’t it create a serial chain? Now hardware can’t run both versions in parallel, which may be more efficient for longer chains, but has to do each operation after another? Or is it that smart that it tracks serial dependencies based on masks instead of registers?”
[48:43] “Tim Davis (sparse matrix algorithms) pointed out that modern machines that rely heavily on caches are actually very similar to theoretical turing machines that have to pay the cost of a navigating head.

I thought that was another instance of John Backus delaying the compiler technology besides him ignoring the SSA construction from Hoar. as he famously wrote ‘Can programming be liberated from Von Neumann style’. Which turns out not to be a style but a much more grounded method. and funny enough that SSA is just the recovery of functional benefits within this overarching method. I would be very happy if I can hear your thoughts around that, even if just to point out that I am hallucinating.”
[51:35] “In light of recent videos on removing predication, I’d like to ask about the conditional move instruction. Is this something that’s considered a good thing, if you can’t remove predication otherwise?”

Nested SIMD Predicates

2026-09-23T19:29:51+00:00

Before moving on, it’s worth looking at how we would handle more complex predicates than the ones present in the haversine loop.

Sep 23, 2026

∙ Paid

This is the eighteenth video in Part 5 of the Performance-Aware Programming series. Please see the Table of Contents to quickly navigate through the rest of the course as it is updated, and the code repository for downloadable code listings.

The full video is for paid subscribers

Already a paid subscriber? Sign in

Programming Courses

A series of courses on programming topics.

SIMD Mask Registers

2026-09-14T18:33:37+00:00

Playback speed

Share post at current time

0:00

Paid episode

The full episode is only available to paid subscribers of Computer, Enhance!

Although CPUs that support them are still relatively rare by percentage of installed base, mask registers are a powerful feature of modern SIMD hardware well worth understanding.

Sep 14, 2026

∙ Paid

This is the seventeenth video in Part 5 of the Performance-Aware Programming series. Please see the Table of Contents to quickly navigate through the rest of the course as it is updated, and the code repository for downloadable code listings.

What Is AI Doing to Math?

2026-09-10T16:01:59+00:00

Over the course of 2026, AI has advanced from being a mathematician’s assistant to, in some cases, doing the majority of the work behind important new discoveries. What does this mean for formal mathematics as a discipline?

In this episode of Wading Through AI, Demetri walks Casey through three recent high-profile results made possible by the use of AI, and discusses the potential impact of this new level of automation on the field going forward.

As always, the art for the thumbnail, podcast cover, and banner of Wading Through AI were all hand-drawn by Anna Rettberg in her signature style. We do not currently use generative AI here at Molly Rocket .

High-Performance Database Architecture

2026-09-09T16:03:33+00:00

The conventional wisdom holds that you wouldn’t use an ACID-style, traditional database for holding the runtime state of a real-time application. Certainly you could use one on the backend to hold persistent state, or to handle financial transactions, but you wouldn’t expect an ACID database to be employed as the primary way you’d do something like complete world state management for a videogame.

But does that actually have to be the case, or is that an antiquated notion of what a database can do? I sat down with Tyler Cloutier from the SpacetimeDB team to talk about that specific question.

520 Pages Per Hour

2026-09-08T16:02:41+00:00

Plumbing the depths of computer history for The Big OOPs and The Root of the Root of All Evil consistently proved to be deeply rewarding. Of course, given the limited time budget for preparation, whenever it came time to make the slides, it was a daunting task to create coherent presentations from such large volumes of material. But putting the stress of that aside, spending time with so many enlightening historical artifacts was an otherwise wonderful experience that completely changed the way I think about the history of programming.

I wanted to share this part of the process in some way, so I originally planned to record myself scrolling through the papers I used in The Big OOPs. I figured I could comment on each paper as I paged through them, and then edit that into a series of videos to post here. My goal was to do all of the papers that were used in the talk - a subset of everything I had read, but still a large number of papers.

However, when I tried doing this, the result was completely unworkable. Going through even asubset of just the Bjarne Stroustrup papers by themselves yielded over eight hours of recorded material. Editing aggressively might have cut it to four at best.

At a loss for what to do, I took a page from the modern TikTok playbook and tried going through the Stroustrup papers again, this time challenging myself to talk as fast as humanly possible. Anna then did an editing pass on it to remove the pauses in between phrases 1 .

The result is arguably the most-ridiculous-100%-serious video I have ever made, but it does “successfully” walk through over 520 pages of historical material in only one hour of runtime! Whether or not it’s actually useful in relaying the “feel” of going through a large volume of material or not… well, you all will have to be judge of that!

For those of you who like doing follow-up reading, I have included a linked bibliography below that lists all the materials shown, in order of their first appearance in the video:

Is AI a Good Research Assistant?

2026-09-02T19:41:44+00:00

Recently, I gave a talk called The Root of the Root of All Evil. Like The Big OOPs, it was a research-intensive talk, so Demetri and I decided it might serve as a good spot test for how well the frontier models do on historical research.

In this episode of Wading Through AI, Demetri runs the major models on a query designed to reproduce the top-level research necessary for my talk. We evaluate how well they did, and speculate on the usefulness of current AIs for this kind of research.

Demetri has provided a download of the research reports on his website. If you’d like to check them out yourself, you can download them here .

SIMD Masking

2026-08-31T20:51:15+00:00

Playback speed

Share post at current time

0:00

Paid episode

The full episode is only available to paid subscribers of Computer, Enhance!

Once we execute both sides of an if/else, we need some way of merging the results.

Aug 31, 2026

∙ Paid

This is the sixteenth video in Part 5 of the Performance-Aware Programming series. Please see the Table of Contents to quickly navigate through the rest of the course as it is updated, and the code repository for downloadable code listings.

Programming Courses

A series of courses on programming topics.

The Root of the Root of All Evil

2026-08-26T03:00:49+00:00

Following in the footsteps of last year’s The Big OOPs , I once again decided to do a research-intensive talk for this year’s Better Software Conference . Last time, my starting point was Ivan Sutherland’s Sketchpad. This time, it’s the phrase, “premature optimization is the root of all evil.”

When people bring up this phrase, they typically want to debate its proper application, use it to argue a point, or divine which legendary computer science figure originated it. In this new talk, The Root of the Root of All Evil, I do none of those things.

Instead, I try to give as complete a picture as I can of the specific circumstances that lead to the phrase being coined 1 . The more research I did on the historical figures involved, the more I came to believe that you can’t really grasp all the subtleties of the original meaning without knowing each of their stories: you’ll either read too much into the phrase, or too little, and miss the subtle understanding necessary to apply it properly.

So, if you’ve ever wondered what “premature optimization is the root of all evil” really means - or wondered why a prominent programmer would have said it - I hope you’ll join me for one more journey back into computer science history to search for The Root of the Root of All Evil!

Nearly all of the photographs used in the talk came from Brian Randell’s fantastic NATO conference history pages . They are credited to both Randell and his contemporary, Robert McClure. Randell actually appears briefly in the talk proper - he is Dijkstra’s primary interlocutor in the inciting incident for GOTO Considered Harmful.

Unfortunately, at the time I am writing these credits, the server hosting Brian’s page seems to be experience SSL certificate issues. It is a wonderful page, with rare historical photographs, so hopefully this will be resolved soon! If it isn’t, you can try accessing a backup version of the page at the internet archive .

For the remaining photos: The pictures of Donald Knuth’s books were taken by Héctor García-Molina , and are available to download directly from Donald Knuth’s web site . The picture of Donald Knuth himself, as well as the photograph of his long-time collaborator Robert Floyd, appear in many places on the internet, and in books, but never with attribution. If anyone knows the original sources of these two photographs, I would be grateful if you could let me know so I can properly credit the photographer(s) here!

As you might imagine, to prepare a talk like this I read through a large volume of historical material. My research directory for The Root has over 200 documents in it! From those sprawling thousands of pages, only a select few excerpts make it onto actual slides.

Each quotation slide bears a footer saying where it came from. If you’d like to read the document behind a slide in more detail, I’ve included a hyperlinked list below to help you find them. Where possible, I have linked to a publicly available version of the material if it appears to have been legitimately posted (ie., not pirated).

In the order in which each appears in the talk, the excerpts are from:

ACM Computing Surveys, Volume 6, No. 4
Structured Programming with go to Statements
The Errors of TeX (paid access only)
EWD196 - The Structure of the “THE”-Multiprogramming System
Edsger Wybe Dijkstra - His Life, Work and Legacy (paid access only)
An Interview with Edsger W. Dijkstra
EWD215 - A Case against the GO TO Statement
Go To Statement Considered Harmful
EWD1308 - What led to “Notes on Structured Programming”
EWD245 - On Useful Structuring
EWD340 - The Humble Programmer
Datamation - October 1968 (original scan preserved thanks to Bitsavers )
Datamation - December 1968 (original scan preserved thanks to Bitsavers )
EWD227 - Stepwise Program Construction
A Review of “Structured Programming”
NATO Software Engineering Conference 1968 Report (at the Internet Archive, since Brian Randell’s page is currently down)
EWD249 - Notes on Structured Programming
EWD209 - A Constructive Approach to the Problem of Program Correctness
The Emperor’s Old Clothes
Efficient Production of Large Programs
A Contribution to the Development of ALGOL
Record Handling
Oral History of Sir Antony Hoare
Structured Programming
Oral History of Donald Knuth
Research in the Computer Science Department (1969)
Notes on Avoiding “go to” Statements (paid access only)
The IBM System/360 Model 91 (paid access only)
Optimal Measurement Points for Program Frequency Counts (paid access only)
An Empirical Study of FORTRAN Programs (paid access only)
The Execution Time Profile As A Programming Tool (a few months after I bought mine on eBay, somebody uploaded it to the Internet Archive! But it wasn’t me, I swear.)
An Interview with Charles Antony Richard Hoare
The Debugging of Computer Programs (paid access only - only appears in the Q&A)

I realize these days it’s a hard sell to convince people to spend time reading historical documents. Why not just have an AI do it for you?

Personally, I find the literal act of going through the documents to be the most valuable part of the experience. The primary reason for this is that an overall sense of the material is what matters more than any particular fact, and it’s not possible to get that without spending a considerable amount of time immersed in the historical record.

But a secondary reason is that it’s impossible to know beforehand all the facts you might want to look for. Every time I go spelunking in computer science history, I always happen upon dozens of fascinating artifacts that I was never specifically looking for. It might be Doug Ross’s invention (and use) of fat structs in the 1950s, Bjarne Stroustrup doing “Dependency Injection” in 1979 (more on that later), or, this latest time, finding Sir Charles Antony Richard Hoare proposing what appears to be static single-assignment form… in 1965!

SSA - a mainstay of compiler construction still used in today’s most popular backends - was supposedly developed in the 1980s at IBM. Though I’ve never done any research into that claim (or its history), while doing research for The Root, I stumbled upon the following passage in an unpublished IFIP proposal of Hoare’s :

The coversheet and most relevant page from Hoare's IFIP 1965 proposal

Firstly, the program is transformed into an identically equivalent program from which all inner blocks have been removed, and in which no identifier occurs more than once on the left hand side of an assignment statement. The satisfaction of these conditions is made possible by the absence of go to statements, conditional statements, and for statements from the language of the translation routines. The next stage is to rearrange [the] sequence of the statements of the program in such a way that every variable occurs on the left hand side of an assignment before its first occurrence on the right hand side. This can be done by the same topological sorting algorithm that is widely used in PERT programs.

Hoare proposes the SSA-like transformation for the exact same reason as it was eventually developed (and for which it is still used to this day): as an internal representation structure for multi-pass compilers.

So why did the world have to wait another 15 years for compiler authors to develop SSA proper? According to the handwritten note added to the proposal’s coversheet by Hoare in 1998:

As a result of negative comments of Naur at the congress, I never wrote this up for publication. He said writing a nine-pass compiler was easy.

The “Naur”, in this case, is Peter Naur , whose name you may recognize from the term “ Backus-Naur Form ”, which is used ubiquitously to refer to a notation style for defining programming language syntax.

I hope you enjoy The Root of the Root of All Evil. As with The Big OOPs, I once again learned a tremendous amount about the history of computing while preparing it. But, also like The Big OOPs, I came away with the inescapable feeling that I’d only just scratched the surface.

I’m not sure if I’ll do another one of these talks in the future. They’re extremely stressful to prepare, because the volume of information you’re trying to streamline is immense - far larger than any other kind of talk I’ve ever given. There is always more research you could do, and nagging questions whose answers might exist in some obscure document you just haven’t yet found. I am typically making slides right up until the moment I give the talk, and I never get the chance to do a proper rehearsal beforehand.

But I doubt I’ll ever stop nosing around in computer science history. There’s so much great stuff, I’m sure I’ll never exhaust it. As an industry, sadly, it feels like we’ve forgotten far more than we’ve retained.

On that note, since this is the one-year anniversary of The Big OOPs, I’ve also prepared a special hour-long, members-only video where I do my best to show what it’s like to read through the historical materials used to prepare these two unusual talks. It attempts to condense an over-500-page slice of Big OOPs research into one hour, which of course requires my best impression of the latest TikTok “fast talking” style. For all you OOP fans out there, it also includes the aforementioned finding that Stroustrup proposed dependency injection in the late seventies.

I will be posting that video here as a follow-up, so if you’d like to be notified when it’s live, please check out our subscription options:

Until next time, have fun programming everyone, and I’ll see you on the Internet.

— Casey

Regardless of who coined it, since some - including at times its most likely originator, Donald Knuth - have attributed it to others.

Q&A #87 (2026-08-25)

2026-08-25T20:14:29+00:00

In each Q&A video, I answer questions from the comments on the previous Q&A video, which can be from any part of the course.

The questions addressed in this video are:

[00:03] “Would you agree or disagree that, early abstraction is the root of all evil? I find once I stopped doing that I can come up with much better quality abstractions.”
[03:07] “I have trouble quantifying how much memory/cache layout actually matters for real-world performance, in contrast to something like SIMD where the 8x speedup is predictable, intuitive and easy to measure … ‘Fit in cache’ is one of the most common phrases in performance circles but at the same time fat structs are often recommended. Anton Mikhailov’s modeler benchmark found no substantial difference until structs exceeded ~1KB … For something like the ~100x gap between Visual Studio and RAD Debugger, how much of that actually comes from cache/allocation patterns specifically, versus general algorithmic/architectural overhead—unnecessary work, abstraction layers, etc.? I keep hearing ‘CPUs have improved by orders of magnitude while memory hasn’t’ and ‘Performance nowadays is mostly about memory/cache” but dont see how that matches my observations above.”
[17:22] “I would love to practice all the concepts from this course. Any tips what kind of game / genre would naturally force me to write performant code? I wanna make something 2D since iam making it alone and Iam not good at modeling.”
[22:24] “Do you think there is harm in learning standard data structures standard implementation? or would it be best to wait until the end of this course to be armed with maximum knowledge for how to properly implement them on real hardware to get real speed wins?”
[27:54] “What do you think of the Steam Machine specs?”
[28:02] “You’ve mentioned many times that you think AI companies are doing things in an unethical way by not compensating the original content creators explicitly for training, even if they pay to acquire access to the content. For an AI company to get on your “good side,” would they need to make models that are only based on completely open or non-copyrighted works and/or explicitly pay for AI training rights for copyrighted works?”
[37:25] “You said you’ve personally never seen an heap data structure used in the video game programming industry. I thought video games often need to compute shortest paths, and the main algorithm for that, Dijkstra’s algorithm, is usually implemented with an heap. Am I mistaken in thinking video games often compute shortest paths ? Or is it that you use other algorithms which don’t require heap ? If so, which algorithms are often used in video games ?”
[40:02] “When a CPU experiences an L1 cache miss but an L2 cache hit, does the data get copied into L1 before the CPU core uses it, or can the core read the data directly from L2?”
[43:12] “Can you comment on the Cyclomatic Complexity metric (and maybe complexity analysis in general)?”
[44:37] “What do you think would be a good project to apply performance aware programming to? I've seen the video editor Blick releasing recently and it looks super fast, are there other type of software that have a large gap in their performance and that someone could fix?”
[51:02] "One of the things I’ve noticed in my own programming, as well as my coworkers, and dev logs on YouTube is that when people self evaluate their code solving a particular problem. There doesn’t seem to be much grounding on what actually worked, and what didn’t. Particularly with my own work, I tend to have rose tinted glasses about what I did, but then a few months later I start running into the limitations and edge cases and I’m no longer happy with it. Have you found this to be true with your own software projects? And do you have any advice or metrics to use to try to help evaluate the code early and get rid of the rose tinted glasses?”
[53:00] “From the ‘Three Steps from Scalar to SIMD’ video: what is the difference between ‘Reduce’ and ‘Recode’?”
[54:14] “I’m not really getting why the ‘Reservoir Sampling’ is better than caching all valid elements in an array and just doing a single random generation for the index. I get that probably the random-next function is just a bunch of adds muls mods or even xors (unless you use a Mersenne Twister or something). But if the list is short enough, and assuming the isValid predicate is simple, even the simpler RNGs can’t be faster than just a bunch of movs of indices or pointers pushed to the stack or copied into an array in a reserved page-aligned heap, and then one-shoting the index after.”

The Pit of Success

2026-08-19T17:24:18+00:00

Most of the material I make for Computer Enhance focuses on the programming side of software performance. What about the institutional side? How do you raise awareness of performance concerns inside an organization? At what stages of a project is a performance expert most useful? When did software development lose its emphasis on performance in the first place?

In this interview with Rico Mariani 1 , we talk about precisely these questions. He spent much of his career at Microsoft trying to fix performance problems, both directly and indirectly. While working on the C# CLR, he coined the term “pit of success” to express the need for platform developers to design APIs such that non-experts will create software that performs well by default.

Rico walks me through that episode, and many more, in this hour-and-a-half interview.

If you’re interested in software performance, you’ve come to the right place. Computer Enhance is a giant archive of performance programming materials, with more added every week. Check out our free and paid subscription options here:

In addition to following him on X, Rico also posts about performance from time to time on medium . You can also find him on LinkedIn .

The Pattern Behind x64 CMPPS/PD Immediates

2026-08-18T23:21:28+00:00

While I can’t say it matters for any practical purpose, I have more-than-once wondered how Intel came up with this table:

Table 1-2 from the CMPPD entry in Volume 2, Chapter 3 of the Intel 64 and IA-32 Architectures Software Developer’s Manual

The meaning of these immediate values is straightforward enough if you understand the cmpps and cmppd instructions. First, you pick one of eight different comparisons: equal, less-than, less-than-or-equal, always false, not equal, greater-than-or-equal, greater-than, and always true. Then, you pick whether or not you want the comparison to be signaling 1 . Finally, you pick whether you want NaN’s to pass through as true values or false values (called “unordered” vs. “ordered” comparisons in this context).

Once you’ve made those three decisions, you combine them together and you pick the immediate value that corresponds to your choice. Eight possible comparisons, times two for signaling-or-not, times another two for ordered-or-not, equals thirty-two different values. Great! That’s exactly how many are in the table. Everything checks out.

But how did Intel choose which combination of immediate bits mapped to which combination of choices? Naively, one might think that a bit would be set whenever the comparison is signaling. Another might be set if the comparison is unordered. And so on.

To some extent, this does seem to be true. 0H, 8H, 10H, and 18H code for the four different possible equals comparisons. This would imply that the 4th and 5th bits must code for ordering and signaling, respectively, right?

Well, 0H, where the 4th bit is unset, is an ordered equals. 8H, where the 4th bit is set, is an unordered equals. So the 4th bit must code for an unordered comparison.

Except wait - 4H, which does not have the 4th bit set, is an unordered not-equals. CH, which does have the 4th bit set, is the ordered version! So the bit seems to code for the opposite in this case.

This kind of pattern continues whenever you look at the values. You can find something like a relationship between bits, but never quite what you would expect.

Recently, I asked The Internet if anyone knew what was actually going on here. While it unfortunately rewards my lazy behavior, I am delighted to report that Pete Cawley worked out what was likely going on, and wrote it up:

It’s a quick read, and covers the entire immediate encoding. So, if you’re like me and are curious as to how these sorts of things end up the way they do, I highly recommend you head over to Pete’s writeup and check it out!

Which, unless you’ve unmasked them yourself, usually won’t signal either way, since NaN exceptions are masked out by default on the most x64-based OSes.

SIMD Predicates

2026-08-17T19:58:27+00:00

Playback speed

Share post at current time

0:00

Paid episode

The full episode is only available to paid subscribers of Computer, Enhance!

Although counterintuitive at first, using purpose-built comparison instructions we can easily translate if/else branches into SIMD code.

Aug 17, 2026

∙ Paid

This is the fifteenth video in Part 5 of the Performance-Aware Programming series. Please see the Table of Contents to quickly navigate through the rest of the course as it is updated, and the code repository for downloadable code listings.

Branchless Absolute Value

2026-08-10T19:29:46+00:00

Playback speed

Share post at current time

0:00

Paid episode

The full episode is only available to paid subscribers of Computer, Enhance!

Some operations are uniform enough that, even though we might ordinarily think of them as using a predicate, they can nonetheless be done by direct manipulation of the underlying bit pattern.

Aug 10, 2026

∙ Paid

This is the fourteenth video in Part 5 of the Performance-Aware Programming series. Please see the Table of Contents to quickly navigate through the rest of the course as it is updated, and the code repository for downloadable code listings.

What New Jobs?

2026-08-05T18:23:23+00:00

Appeals to prior technological revolutions are often used to assuage fears that AI will lead to widespread unemployment. Yes, you may lose your job because of AI, but eventually you'll get a different job in a new field created by the resulting technological progress - or so the argument goes.

In this episode of

Wading Through AI, Demetri and Casey discuss whether this argument holds water, or if it's just wishful thinking unjustified by direct historical analogy.

Three Steps from Scalar to SIMD

2026-08-03T17:35:21+00:00

Playback speed

Share post at current time

0:00

Paid episode

The full episode is only available to paid subscribers of Computer, Enhance!

When we want to change the interior of a loop (with complex control flow) from processing one thing to processing several at a time, it's best to tackle the problem in three sequential steps.

Aug 03, 2026

∙ Paid

This is the thirteenth video in Part 5 of the Performance-Aware Programming series. Please see the Table of Contents to quickly navigate through the rest of the course as it is updated, and the code repository for downloadable code listings.

Why AI Companies Need Scale

2026-07-02T17:51:38+00:00

AI companies seem fixated on scaling. From massive marketing budgets to supply-chain-altering datacenter plans, the drive to scale appears to be more urgent and aggressive than in any tech boom that came before.

In this episode of Wading Through AI, Demetri walks Casey through the list of factors that make scaling a necessity for companies competing to be the AI providers of the future.

Let's Decode the Mystery Bytes!

2026-06-22T17:48:57+00:00

Last month, I posted Let’s Answer Ray’s Question! - a video where we looked at the memory behavior of two different compilations of the same program. I ended that video by saying that if you could read assembly language (like you can if you did Part I of the Performance Aware Programmingcourse !), you could go much further and determine even more specifics.

In this video, we do exactly that. Using disassembly, memory view, and heap debugging, we zero in on exactly who is setting the magic eight bytes we saw next to Ray’s allocations in the first video - and we figure the convoluted way those bytes are encoded.

If you’d like to be emailed when the third and final video is posted, you can subscribe your email address to either our free or paid tiers using the button below.

Will AI End the Open Internet?

2026-06-16T16:06:08+00:00

With previously open source projects going closed, and artists increasingly concerned about posting their work online, is AI reversing the internet’s long-established trend toward openness?

In this sixth episode of Wading Through AI, Demetri and I consider the possibility that AI could substantially diminish, or even eventually end, the norms of the open internet.

Q&A #86 (2026-06-10)

2026-06-10T16:00:39+00:00

In each Q&A video, I answer questions from the comments on the previous Q&A video, which can be from any part of the course.

For those wondering what the name of the audio API was that made me go “I can’t believe I am forgetting the acronym” in the middle of this video, it was ASIO .

The questions addressed in this video are:

[00:02] “The D language actually has this because of Uniform Function Call Syntax. You could have a struct like … and have the rest of the code be none the wiser (even code like foo.x = 7). I think C# has stuff like this too. Is this what you’d be hoping for? If so, I’m surprised - I’d have guessed you usually don’t prefer implicit magic like this happening on things that don’t look like function calls.”
[04:37] “Could someone remind me what the ‘warm’ criteria was?”
[06:00] “I have a question about managing intrusive thoughts while writing code. When thoughts come up about edge cases, performance, reliability, or decisions that may need to be revisited later, how do you decide whether to address them immediately or set them aside? I’m finding it difficult to iterate quickly because I often get pulled into these concerns before I’ve built a working v0. I’ve tried writing TODOs in the code and keeping separate notes, but neither approach has worked well for me.”
[15:47] “I now have a question about wasapi (I believe you now use wasapi but if I’m wrong then you can ignore this question). I’m writing the sound system for my codebase and had my wav parser ready, mixer chugging along, sat back to enjoy a song but then found out that changing the system volume causes these pops.... I know that changing the volume of a sound wave causes the discontinuity which manifests itself as audio popping but in this case where it’s not an internal volume I have control over I don’t know how to fix these. It seems to me as if windows just immediately applied the new volume and my futile attempt of trying to bypass windows’ volume logic didn’t work since they seem to first clamp my samples and then multiply by the volume... I tried some wasapi gist examples and they all had this same issue. Have you had this problem and fixed it in your own code and could you share your knowledge if you have?”
[25:07] “I formed my question about heaps slightly misleading. It wasn’t about a memory heap, but a data structure, like in the heap sort. In the video together with Primeagen regarding code interviews you commented that heaps are quite slow. So I was wondering, what should you use instead, when the need arises?”
[33:27] “I’m working on a project that uses a cortex-m7, a fairly fast 32-bit embedded core. It has some fancy pipeline features of big boy desktop chips, like a branch predictor, and the ability to dual issue many instructions, but doesn’t have a RAT (it’s not “out-of-order” at least as far as I know). Do I understand correctly that in CPUs without a RAT, any two adjacent instructions that use the same register are effectively serially dependent? Is this how it used to work in the desktop world back in the day?”
[40:53] “This question relates to Part 5: Dependency Chain Stalls and In-order Interleaving. From these results, I would expect 12-way interleaving to maintain peak throughput regardless of chain length (4 FMAs/cycle * 3 cycles = 12 FMAs in flight needed to cover the latency). However, that’s not what I observe. With 12-way interleaving, throughput decreases from ~3.6 to ~3.0 FMAs/cycle as the chain length grows. I need a minimum of 16-way interleaving for throughput to stay flat at ~3.8 FMAs/cycle. My conclusion is that the CPU can’t sustain the 3-cycle latency when the FMA execution ports are saturated, resulting in an effective latency of 4 cycles under load. This would explain why I need 4 * 4 = 16 chains to obtain a flat throughput curve. I think you’ve hinted at this in some of your videos. Would you kindly explain why this happens? Thanks!”

Intuitive Random Selection (with Marc LeBlanc)

2026-06-09T17:19:31+00:00

Suppose you want to pick a random element from a set that is difficult to iterate. Perhaps the candidate elements are embedded in a spatial hierarchy, and only determined by a complex predicate.

One obvious way to solve this problem is to first build a “filtered” array of all the candidate elements, then pick a random index into that array. This always works, and is fair (assuming the RNG is fair) — but it requires reserving space for a potentially-large array, and uses up bandwidth and cache space each time a random selection is made.

A non-obvious-but-common alternative is to use a statistical method where random numbers are chosen during the initial iteration to continuously “retain or replace” a running selection. The random numbers must be carefully constructed, and typically require a modulus on each step. Proof of the fairness of the method is not obvious, and requires knowledge of the relevant underlying math.

In short, while it works, and is likely more efficient than the array method, it has drawbacks.

Inspired by the way you might write such a query in SQL, Marc “Mahk” LeBlanc shared with me a new arrayless picking method that has none of these drawbacks. It’s very similar to the statistical methods version, but without any of the drawbacks.

In this video, Mahk presents the algorithm in a series of steps, starting from a “worst” random selector, and ending with his new one.

Will AI Make Me Worse?

2026-06-04T19:34:18+00:00

As people integrate more and more AI into their daily work, will the quality of the work they produce suffer? Will their own skills degrade as a result of relying on AI? Will there be negative psychological effects in the shift from doing work directly to doing it indirectly through AI prompting?

In this episode, Demetri and I explore these issues as we consider the broad question many people are asking themselves: “Will AI make me worse?”