rphln

Flamegraphs are a really lovely tool for visualizing trees. Slightly related anecdote:

A while ago I was experimenting with interactive exploration of (huge) Monte Carlo Tree Search trees. Inspired by file system visualization tools, my first attempts were also tree maps and sunburst graphs, but I ran into the same problems as in the article.

I tried flamegraphs next with the following setup:

- The number of visits in each node maps to the width and order of each bar (i.e., the most visited node was first and was the largest)

- The expected value maps to the color of each bar.

And then it was a perfect fit: it's easy to see what's going on in each branch at the first levels, and the deeper levels can be explored through drilling down.

The app asks you to move the camera or change your expression throughout the verification.

I'm not familiar with how it works on the implementation side. A ML conference that I attended had a presenter working on this area and beating AI impersonation was their #1 priority (along with other trivial approaches).

For what it's worth, this might also be just a security theater from the banks, though.

Can't speak about this one in particular, but the face scans for banking that I know of also includes liveness checks to avoid AI impersonation (and presumably dead bodies).

Mixing them should be relatively common when denoting intervals, as in "(a, b]" or "[a, b)", so that'd be one cause for being unbalanced. But even so, the math on their usage still doesn't add up.

> with the S and Q in Portuguese

Guilty as charged. Pronouncing letters and numbers in English requires an active mental effort for me, so that happens if I'm not paying attention. I guess it's because they don't really register as another language, even with context. My inner monologue also does letters and numbers in Portuguese, which doesn't help either.

There's already `ls --hyperlink` for clickable results, but that depends on your terminal supporting the URL escape sequence.

Would've been perfect had you said jndex.

Bummer, I had no idea about that. But I guess that, at least for turn-based games, it wouldn't be super annoying if you manage to split the logic (F#) from the UI glue (C#), right?

(I never got around to that point though, I usually start making games as libraries and then get nerd sniped into reading about game theory for the AI before I make them playable for humans.)

I think it'd be interesting to compare against F#, especially since Godot already has first-class support for .NET. When the bindings get fully fleshed out, what will OCaml bring to the table to warrant the extra hoops for the user that has no prior preferences for either languages?

Often I wish that:

    enum Auth { Guest, User(u32), Bot(u32) }

was just syntactic sugar for

    struct Auth::Guest;
    struct Auth::User(u32);
    struct Auth::Bot(u32);

    type Auth = Auth::Guest | Auth::User | Auth::Bot;

where `|` denotes an anonymous union. Using enums feel very clunky when you start needing to work with subsets of them.

Somehow the paper they mention completely flew under my radar when I was researching MCTS. Surely it's gonna be a lot of fun to give this modification a spin on my next opportunity.

Building and (most importantly) programming one of those was a pipe dream back when I used to browse Let's Make Robots a bunch of years ago.

Sadly nowadays I just can't get into these projects that'd need me to spend money and would just sit on a drawer until the ends of the time after completed.