joek1301

k-anonymity [1] by hand!

[1]: https://en.wikipedia.org/wiki/K-anonymity

> Let’s say for moral reasons you choose to link none of LLVM’s libraries (thanks for caring about your users!)

For what moral reasons would I avoid linking LLVM? I’m not familiar.

I would think hyperscalers stand to benefit the most from optimizing wear!

I know they aren't the point of the article, but the photos are absolutely breathtaking.

> One hypothetical approach I could imagine, is that a dependency major-version release of a package can ship with AST-rewriting-algorithm code migrations

Jane Street has something similar called a "tree smash" [1]. When someone makes a breaking change to their internal dialect of OCaml, they also push a commit updating the entire company monorepo.

It's not explicitly stated whether such migrations happen via AST rewrites, but one can imagine leveraging the existing compiler infrastructure to do that.

[1]: https://signalsandthreads.com/future-of-programming/#3535

I actually wasn't aware of this either.

Z3 is fine with it--its job is to find any satisfying model. The possible outcomes are "the puzzle is solvable and here's a solution" or "the puzzle isn't solvable."

I also was inspired to play around with Z3 after reading a Hillel Wayne article.

I used it to solve the new NYT game, Pips: https://kerrigan.dev/blog/nyt-pips

Related: https://brooker.co.za/blog/2024/06/04/scale.html

Normally this kind of thing would be absolutely ripe for abuse, but with the guardrails in place for the mainstream SOTA models, it might actually be okay. Maybe I'll be proven wrong.

I clicked your link, saw DP, and tabbed away to try and solve it myself first. (I also forgot to sample without replacement and wound up with $2.86.)

Delightful read!

It defines a new infix data constructor. So if `it` and `ct` are values of type `ITerm` and `CTerm` respectively, `it :@: ct` is a value of type `ITerm`. (It could have been written with using a prefix operator like `ITerm`'s other data constructors.)

Does the distinction between sharing VA mappings and copying buffers to/from kernel matter from a security perspective? (I assume it does, but I don't know why.)

See "The Global Chubby Planned Outage" on this page:

https://sre.google/sre-book/service-level-objectives/

The FAQ suggests a MacOS port is “underway:”

https://www.steadymouse.com/faq/

Spotify shuffle is indeed not (uniformly) random, as confirmed by this blog post[1]. The post is eight years old, so it is highly possible the algorithm has changed.

[1]: https://engineering.atspotify.com/2014/02/how-to-shuffle-son...

Could you elaborate / share resources on "downfall of the Java sandbox as a security boundary"? Sounds interesting.

One more down the dev-to-woodworking pipeline [1].

[1]: https://github.com/docker/cli/issues/267#issuecomment-695149...

Also, in many cases, implementation details like cache locality mean that asymptotically inferior algorithms can in practice outperform those with a lower theoretical runtime complexity.

The original WORDLE also used minified JavaScript, but there are some resources on reverse engineering it, if all you're interested is learning how the words are picked [1].

[1]: https://reichel.dev/blog/reverse-engineering-wordle.html

I guess I was kind of asking for this, but I just spoiled the next two days of Wordle for myself clicking on your link. Oh, the woes of being a trigger happy link follower

As an aside, there was an interesting recent episode of the AWS FM podcast where a guest was rendering dynamic HTML from Lambda functions and seemed incredibly satisfied with the results. (Unfortunately the recent episodes lack transcripts and I cannot easily verify, but I think it was Episode 17 with Brian LeRoux.) This is a use case I haven't seen get a lot of love, but it is at least similar in premise to HTML Over the Wire [1].

[1]: https://hotwired.dev/