ismailmaj

Typically for matrix multiplications there is a wide range of algorithms you could use to compute it, on one extreme end you could use numerically stable summation and the other extreme you could have tiled matmul with FP8, the industry trend seems to go further away from numerical stable algorithms without much quality drop it seems. My claim is probably unfair since it ignores the scale you gain from the speed/precision tradeoff, so I assumed numerical stability is not that beneficial compared to something precision heavy like physics simulation in HPC.

The way I explained it to myself in the past why so much of the CUDA algorithms don't care much about numerical stability is that the error is a form of regularization (i.e. less overfitting over the data) in deep learning.

There should be a “both” option, I often found both answers acceptable but sometimes I strictly preferred one and those get sadly watered down.

Went over my last conversations with Gemini 2.5 and asked the same things to GPT-5 with thinking on, the latter was consistently worse both in content and form.

I wouldn't have guessed Gemini to win the AI race in 2025 but here we are.

The global io trick would totally be valid if you’re writing an application (i.e. not a library) and don’t have use of two different implementations of io

I really like potion craft, it really hits the optimization part of my brain without feeling grindy or stressful.

The gaming loop is about using the right subpaths using resources to reach a destination while avoiding obstacles, and slowly improving your resources options and quantity, at the end of the game it looks a bit like the traveling salesman problem. Also liked this series on YouTube: https://youtu.be/d_JfzuJzUFE?si=pifLxMFo4itOihdK

It's mostly in the west of Paris i.e. 8th, 15th and 16th districts, the other districts not so much if at all.

Do you know if it was actual videos or some simpler inputs like game state and user inputs? I’d be impressed if it was the former at that time.

I can see this pivoting into YouTube 2.0

It's fairly rare to see people consistently find glitches across games, only distorsion2 comes to mind.

Parquet is only a mess if you try to mutate it, usually you consider them as immutable and have the data stored across many files.

Also batched-row access is negligible given the compression benefits you get with the columnar format, which is probably why it's still king in ML; I think given what I'm seeing in the industry and recent trends (e.g. Velox).

It is probably not worth the complexity currently but considering they are using small local CPU models for OCR like tesseract, if they add the support of reading files on the web then I wouldn't be so sure of the CPU bound aspect.

20% is a harsh figure but it could be a good entry point to figure out the unknown unknowns and go in depth once you have the relevant keywords using more reliable sources.

Thanks for the link, not much familiar with CockroachDB but I worked on a similar system that wanted to provide strong consistency when reading from many databases, some of which where Spanner but not all of them.

Eventually the system implemented something similar to "find transaction timestamp at execution time" + optimistic locking, as the article states you lose global linearizability and have to do some re-reads for writes.

What I missed the most from Spanner compared to the system above is that its tricky to do client-side transaction chaining where there are many clients and the order is important.

Right but it's not magic as you cannot predict networking delays.

The max clock skew also has to pick between A and C, in underestimates you lose serializability, in overestimates you pay in write latency.

In case of mutation either the replicas will be out of sync (so no C), or you'll need to synchronously mutate the replicas (so bad A due to latency).

CRDT is really only useful when inconsistencies could be acceptable in some situations and so it depends on the application.

For something that is trying to solve the general problem of consistent single ground-truth log, you can't really do much better than Spanner.

How does it compare to partially fine-tuning the model by freezing most of the network beside the last few layers?

For cache locality, if the layout is more wide instead of deep, you can avoid many cache misses.

I saw some professors share the least about their tests to make sure we truly understand the material, sounds to me like a real-life usage of a train/test split. It’s not far fetched to think they employed this technique because teaching to the test didn’t work well by itself.

It would be nice if the puzzles natively supported C++ CUDA.

What would be the benefit of using ZML instead of relying on StableHLO/PJRT? Because the cost of porting models is for sure high.

I might have missed it in the article but I'm not sure why the prefix is stored for strings that can't be inlined.

A new rule could be to make a neutral roll prevent the enemy to play that square for one turn (unless it's the last square).

This was very important with classical machine learning, now with deep learning, feature engineering became useless as the model can learn the relevant features by itself.

However, having a quality and diverse dataset is more important now than ever.

I was excited to try HDR on Plasma 6 but it currently only works with AMD GPUs, not Nvidia.

Could it be Mistral Large? This beats GPT-4 on my personal test.

That's exactly what Tomorrow Corporation uses for their hand written game engine and compiler: https://www.youtube.com/watch?v=72y2EC5fkcE

What about higher order library functions, since calling a green function from a red context is bad and we have no way to guarantee that a function is blue and not green, does this mean the function needs to be unsafe? It would be nice if the conversion from red to green would be done implicitly by the language where there is no ambient executor available, but I'm not sure what would be the implications for intra-task concurrency.

The function could accept an universal reference instead of an rvalue reference, this avoids the dance the caller has to do to pass a copy.

IMO it's hard to beat pass by value considering both performance and cognitive load.