joek1301

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.

https://archive.is/Qyx7j

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 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/

Thanks for the positive feedback! Out of curiosity: what do you use minimax for?

Hi HN! I'm the author of this blog post.

I was stuck in quarantine with COVID, and I became absolutely obsessed with WORDLE. There were a few great technical articles posted here, and I became inspired to write my own WORDLE solver based on Knuth's algorithm for the codebreaking game Mastermind [1].

It's fun to ride the WORDLE trend; it also happens to be a great application for the minimax decision rule.

This is my first blog post, ever! I'm trying to spend a little more time writing and reflecting (on things technical or not). I would be happy to receive feedback if you have anything to say.

[1] https://stackoverflow.com/questions/62430071/donald-knuth-al...

Obviously switching away from Cloud Functions does away with the architectural limitation of processing requests serially, but from my (limited) understanding of Node.js internals, Express applications are single-threaded anyway.

Do you have any idea of where your performance gains are coming from? Is there a lot of async, non-blocking waiting happening in the process of fulfilling requests against your API?

I agree wholeheartedly. "Best practices" suggested by AWS, GCP are to architect these services with one function per endpoint, with API gateway handling the routing. Sounds good but if you need reasonable tail-end response latencies in the event of a cold start, you need to forget all about the serverless abstraction and go back to a single container with all of your functionality.

On the other hand I can see the appeal of one instance, one request. I don't know if the answer is to enable (optional) request parallelism or to optimize cold start times down further, but OP's requirements feel like they are way too modest to basically force them out of the serverless paradigm.

I just popped open DevTools on an SPA I made using create-react-app with default settings. Sure enough the minified production JavaScript uses shortened variable names. This is default configuration for Webpack, which is pretty widely used throughout (and outside) the React ecosystem.

Interestingly you can still view the unminified source, since create-react-app generates source maps by default.

do you have any advice for "bootstrapping" your SSB experience as a new user? The original post inspired me to go download Patchwork and join a public pub, but I'm having difficulty finding real interesting conversations to join in on.

I think Scott Alexander’s piece on slippery slopes and Schelling fences [1] does a nice job delineating between good- and bad-faith slippery slope arguments.

“Slippery slopes legitimately exist wherever a policy not only affects the world directly, but affects people's willingness or ability to oppose future policies.”

[1] https://www.lesswrong.com/posts/Kbm6QnJv9dgWsPHQP/schelling-...

Yet another similar story. A side project of mine was building a rudimentary neural network whose weights were optimized via a genetic algorithm. The goal was operating top-down, 2D self-driving cars.

The cars' "fitness" function rewarded cars for driving along the course and punished them for crashing into walls. But evidently this function punished a little too severely: the most successful cars would just drive in tight circles and never make progress on the course. But they were sure to avoid walls. :)