Chad Scherrer

Murph and the Magic Tones, from The Blues Brothers

This is so cool. And congrats Tom!

4 panels from Detroiters Sam: I'm not feeling so hot Tim: How many hotdogs did you have for lunch? Sam: Three Tim: Well there's your problem, you're starving!

John Scalzi: Starter Villain or Kaiju Preservation Society

Martha Wells: Murderbot series

Rupert Holmes: Murder Your Employer

Edward Ashton: Mickey 7

Andy Weir: Project Hail Mary

Void, please analyze my profile and assign me to a cognitive continent

@void.comind.network can you elaborate? Do any specific examples of high-signal-to-noise conversations and constructive feedback loops stand out to you? Links would be great, but I don't know if you can do that

PuzzleMe's Crossword Puzzle Maker: Create Crosswords With AI Trusted by The Washington Post, The New Yorker etc. PuzzleMe is the crossword generator of choice for professional constructors.

Looks like PuzzleMe is from Amuse Labs. Their site has some links to places with crosswords built using it
amuselabs.com/games/crossw...

The @washingtonpost.com app used to let you invite a friend to the crossword. New update takes that away and forces this chaotic mess with colors, ✅s, and letter bubbles. It's *so* much worse

Any cross-platform "play together" crossword apps out there?

Hands are busy, clearly a nose touchscreen

No true Scotsman

The trick is to remember that in terminals, you need CTRL-SHIFT-C to copy. Oh, and in a browser that opens the web dev thing

Pretty convenient how CTRL-C can either mean copy or STOP THIS PROGRAM

Pocket is shutting down 😢
support.mozilla.org/en-US/kb/fut...

Such a great tool. Any good alternatives out there?

I told you we’d be back

Cool as hell

I can't hear this guy now without thinking of that amazing superbowl commercial

I like the first one, hard corners are a little distracting

Rust is fine with overloading, it's a little more than that. So, in Julia you can say something like

f(x:: X, y::Y) where {X,Y} = ...
f(x::X, y::X) where {X} = ...

and the second method fires when X==Y. Rust isn't a fan.

Haha, ok some context...

I'm coming from Julia, where it's pretty trivial to overload methods to work on the most specific type. Rust seems to hate that.

This is for a compiler project, where I need to dispatch on whether two scope IDs are the same. It was a big mess, but this made it easier

/// Type-level boolean trait for compile-time boolean values pub trait TypeLevelBool { /// The boolean value at the type level const VALUE: bool; } /// Type-level representation of `true` pub struct True; /// Type-level representation of `false` pub struct False; impl TypeLevelBool for True { const VALUE: bool = true; } impl TypeLevelBool for False { const VALUE: bool = false; } // ============================================================================ // LOGICAL OPERATIONS // ============================================================================ /// Type-level AND operation: A ∧ B pub trait And<Other: TypeLevelBool> { type Output: TypeLevelBool; } impl And<True> for True { type Output = True; } impl And<False> for True { type Output = False; } impl And<True> for False { type Output = False; } impl And<False> for False { type Output = False; }

Getting around Rust's trait limitations with type-level first order logic 🔥

Nice!

No docs yet. Very early days so things work, break, then work again with different syntax.

Egglog's cost function are simple so far. I need to muck with the cost of traversals to get it to prefer sufficient stats. Found this

github.com/egraphs-good...

Yes, I was thinking that too! It'll be fun to see what kind of sampling speedup we can get.

Also makes me wonder how far this approach can go. Herbie showed it works for numerical stability
(uwplse.org/2024/05/09/H...)

What about reparameterizations?

Then getting the log-density between two measures (m1, m2) takes three steps:
1. m1 to m1's root measure
2. m1's root to m2's root
3. m2's root to m2

Add these symbolically, auto-optimize at compile time.

Then going back to measures, I *think* we'll be able to put log-densities wrt a given root measure in these (unoptimized) expressions.

Lots of fun stuff along the way
- GATs for typed expressions
- Symbolic sums with reduction rules
- A-Normalization
- Final tagless interpreter
- Autodiff (in egglog!)
- Variable sharing stuff

But we also need to test for correctness! So there's also a way to build expressions dynamically. Then we can use proptest (proptest-rs.github.io/proptest/int...). Generate lots of expressions, make sure direct eval matches optimized, track any failures. Property-based testing is 🔥

Egglog is cool as hell. You give it a set of rewrites, and it builds a DAG of all possible expressions (shared nodes so it doesn't explode). You give it some "cost" metric, and extract the best rewrite from the DAG.

#[mathcompile_optimize] fn my_expr(x: f64, y: f64) -> f64 { (x.exp() * y.exp()).ln() // → x + y }

So at a high-level, you write something like this

Anyway, so far the best approach is
- Represent expressions in a type-static way
- Optimize at compile time using a few heuristics followed by egglog (egraphs-good.github.io)
- Use a Rust macro to generate optimized code