Micah Johnston

the thing is basically all interesting art happens when the next token isnt predicted by the previous ones

and then, here are some sources I've encountered about "CSM scrolling", which seems more closely related to your original question:
- d3cw3dd2w32x2b.cloudfront.net/wp-content/u...
- advances.realtimerendering.com/s2012/insomn...

there's a somewhat related post on the dev blog for The Witness, which in turn references an article from ShaderX 6 ("Stable Rendering of Cascaded Shadow Maps"): the-witness.net/news/2010/03...

it's not about caching so much as achieving stability under camera motion, but there's some overlap

Screenshot of a Twitter post: Drone is not real music. Anyone can play one note for a long time, look [holds down organ note to prove point but I instantly become entirely entranced by the sustained oneness and experience of completely pure sensuality, I forget Im pissed and just stand there in eternal peace]

JEAN-LUC I HAVE A QUESTION
IT IS A BOUT DE SOUFFLE
SHOULD I TAKE IT OUT OF DE OVEN

Tame Things I Hate About Shrew

I can recommend getting a baguette on your way to the office and gnawing on it throughout your work day

Sure, yeah; what I'm pointing out is that even if the model can't losslessly reproduce a given string on zero-temperature sampling or whatever, if it's able to predict the string any better than chance, you can build a lossless compressor on top of it using entropy coding schemes

You can use an LLM to implement a lossless compressor for arbitrary text, see e.g.: bellard.org/nncp/

The encoder and decoder share the same predictive model, so the encoder can spend fewer bits on more predictable symbols and more bits on less predictable ones

Pre-Pooping Your Pants With Rust - Faultlore

In fact, if the T inside an Rc<T> *needs* to have its Drop implementation called to avoid UB, that itself is an unsound API for T to have. That was the original subject of the leakpocalypse, and is why the original JoinGuard API for scoped threads was removed from std (faultlore.com/blah/everyon...)

It doesn't need to be dropped in order to invalidate the &mut T, though. &mut T doesn't implement Drop in the first place. Putting an &mut T inside a MaybeUninit or ManuallyDrop is a similar situation

They might still "coexist" in the sense that the bit pattern for the &mut T might still sit around in a register or on the stack somewhere, which is essentially the same situation as having the bit pattern for an &mut T sitting around in a leaked, inaccessible Rc cycle

*nate dogg voice* my infant and me had to coregulate

Cracking open a cool red dwarf star with the boys

This post perfectly encapsulates my experience with so much of the discourse around Rust

Whole Foods is a store where you can find
1. Plant-based imitations of many animal products
2. Products that are typically plant-based or vegetarian but have bones in them for no reason

“Whole Foods shoppers” is a funny intersection of target markets. Like there’s a granola brand I’ve been getting, and almost every one of their products says “vegan” on the front, except the other day I picked up a box of their instant oatmeal and it had bovine collagen in the ingredients

a search for `<'a`, no results found

then again, i also keep things very simple, and lots of folks try to make things more complicated

crazy the degree to which web devs have just deliberately destroyed basic browser functionality. I wanted to copy the name of an artist to the clipboard from the spotify web client (because it contained chinese characters I didn't know how to type) and I fully had to open developer tools

κp(x, x′) is a new “Steinalized” positive definite kernel

S T E I N A L I Z E D

which one are you

this is a true story

once, at a coffee shop, I asked the barista if the music playing over the speakers was by oval. she gave me a free drink and said “here’s your 94diskount”

K N U C T A T S

of course there are ways to get around this with some overhead and/or boilerplate, like just cloning the Rc and then coercing it by value, or defining another trait and implementing it for Rc<T> where T: ?Trait. but it's annoying

however, in theory it should be totally possible to coerce &Rc<T> to a different type, &for<T: Trait> Rc<T> (i.e. a reference-with-vptr to an Rc), if only it were possible to express that type in the first place.

e.g.: Rc<T> coerces to Rc<dyn Trait>, and &T coerces to &dyn Trait, but &Rc<T> doesn't coerce to &Rc<dyn Trait>.

with explicit quantifiers, &Rc<dyn Trait> would be spelled &Rc<for<T: Trait> T> (i.e. a reference to an Rc-with-vptr), and it makes sense that you can't perform that coercion.

getting frustrated by the fact that rust doesn't have explicit quantifiers for existentials, which makes it impossible to express certain distinctions when it comes to unsized types.

YouTube video by Burt Sampson (El Burto) I Am A Cuck-Tim Heidecker

e.g. this song goes harder in 2025 than I could ever have predicted in 2016 www.youtube.com/watch?v=zorJ...