LaurieWired

My CppCon Keynote, “The Address is Not The Place” is now up on YouTube!

It’s not often that we get new tiers added to the memory hierarchy of computing, but it sure is fun! You can certainly get ahead of the curve by thinking about the programmatic challenges this will cause (and possibilities it will open up!) in the (very) near future.

Hope this talk gets more people thinking about the concept of object “wherency”, and especially what that mental model could look like in various languages.

I wrote my demonstrator as a C++26 native implementation; curious to see what others will come up with. Not just limited to C++ either; this concept is easily extended to many other (including runtime!) languages.

when I was a kid I wanted to make my signature a picture, like a cat or something

my mom told me that was a bad idea 😢

UX latency is the most frustrating (lack of) advancement in computing over the last ~50 years.

IBM, way back in the 80s, found that user productivity shot up *exponentially* as system response time dropped. The "Doherty Threshold" was defined as ~400 milliseconds; the maximum amount of tolerable UX latency before interrupting user flow state.

It's unbelievable how many modern operating systems (*cough* win11) violate this threshold constantly.

Literally all you need to do as a Dev is pay attention. Add a "Doherty Threshold" to your test suite. There's so many different profiling tools, and especially with how good models are, really no excuse. Sure, some stalls are unavoidable, but that's when you pull out other UX tricks to at least give the illusion of responsiveness.

Crazy how much vintage computing hardware feels immeasurably more responsive despite having thousands of times less overall performance.

how it feels to be an eva pilot

My ACCU On Sea Conference Talk, “CallMeMaybe: Building Modern Runtime Reflection via C++26” is now on YouTube!

Upcoming native static reflection in C++26 opens the door to new dynamic reflection capabilities.

Using C++26 static reflection, it’s possible to build a type-safe runtime reflection registry without manual registration, with attention to binary size and invocation overhead!

Static Reflection is pretty cool. Runtime Reflection is *really* cool!