I always find interesting how several math domains have similarities and bridges between them. Here it's about the ties between polynomials multiplications and convolution sums.

Interesting initiative to have DNS servers compliant with GDPR, respecting your privacy and with the filtering you need. Now the real question is how long it'll live by its mission.

I don't think I'm ready to give up just yet... Still, I recognise myself so much in this piece it feels like I could have written it (alas I don't write as well).

A long but important report in my opinion. Reading the executive summary is a must. This gives a good overview of the AI industrial complex and the type of society it's leading us into. The report algo gives a political agenda to put us on a better path.

Somehow this is funny that it works at all. With the advent of SPIR-V we're clearly seeing more experiments in the shading languages space.

This is a funny way to point out people jumping on LLMs for tasks where it doesn't make sense.

Interesting little experiment. It's clearly making progress for smaller tasks. The output is still a bit random and often duplicates code though.

Early days for this project but the idea is interesting. I could clearly things I'd want to automate that way.

We already had reproducibility issues in science. With such models which allow to produce hundreds of "novel" results in one paper, how can we properly keep up in checking all the produced data is correct? This is a real challenge.

Due to how errors are handled in Rust, designing them is a real concern. Several approaches are presented here, using wrapper types is likely the better trade off.

Not strictly about Rust, still is shows how to approach the conversation about your dependencies. It also gives good ideas on how to try to reduce them.

A good reminder that the complexity of tests should be as low as possible.

Interesting post about the options for error handling in Rust. It highlights the tradeoffs to keep in mind when creating structured errors.

It's a very good idea to help C++ developers pickup Rust.

Nice illustration on how you can hunt down complexity in your codebases. It is obviously a slow process but comes with nice benefits.

Interesting research to determine how models relate to each other. This becomes especially important as the use of synthetic data increases.

A good reminder that it is sometimes better to use lookup tables.

Worth trying indeed. I'd love to see at least some of that widely adopted.

Indeed feels bad when there are so many problems in the example of LLM based completion you put on the front page of your website...

Interesting comparison between C++ and Rust for a given algorithm. The differences are mostly what you would expect, it's nice to confirm them.