Actually, I came to comments specifically to praise the inverted bar charts, I've never seen it before, a very intuitive way to communicate lower is better IMHO.
I'd say not really because most common use is to plot metrics like deficits where lower is worse so people may be accustomed to that... thus best practice should indeed be to always label whatever the direction of the chart to make clear what is better or worse.
If you have to express your computation using an "array programming DSL" with things like scan and gather anyways - why not opt to use torch/tensorflow/jax or anything else that targets MLIR? An example of writing a relu using an embedded array DSL is really not helping your case either - that's exactly the problem that these other solutions mentioned above are successfully solving for the past ~15y (starting with theano etc). Not sure what this brings to the table - doing that AoT instead of at runtime?
The goal of this work is to run existing unmodified CPU libraries (which may use core::simd) on the GPU. If you are manually writing ML-shaped workloads, it doesn't add any value over writing with tech like torch/tensorflow/jax which are custom built for those use-cases (except maybe familiarity if you are a CPU programmer).
Oh, at least in the post Soviet tradition of oral exams, you are given plenty of time to think and prepare your argument before you start an actual conversation with the examining professor. And if you need to think more during the exam to answer a tricky question, the professor just shifts to talk to another student who is ready to present their case for the time being. So it is less of a public speaking and more of a conversation where you can take a pause to think through an argument, or a proof, or a problem.
Same. The focus on written exams rated blindly and uniformly at the US higher education system always puzzled me. I guess that's the only way to scale things up when you pay professors and teachers living wages?
Honestly this is the first time I am seeing this kind of work that i genuinely like. Most fractal and other kinds of self repeating results are not that interesting at all to me.
It's low resolution at only 256 x 80, stretched vertically to the screen size.
It's only 16 colors so only 4 bits/pixel.
That comes to 10kb per frame.
A variant of Huffman coding gets it to 3.52kb per frame.
It's at 15 fps and is 12.5 seconds in length.
15 x 12.5 x 3.52kb = 660kb, which fits in a 4mb cartridge.
There is dithering to give the appearance of more colors, and it's done in vertical stripes rather than checkerboards because that compresses better. Then at runtime, every other scanline is offset by 1 pixel, and in opposite directions every other frame, so the dithering blurs back together to give the appearance of many more colors.
How difficult it is to get a perfect beam in practice? Can one manufacture a flat rotman lense like that to introduce sinc phase shifts - this should yield a well behaved very directed beam? What are the practical challenges in doing so?
If AI can find new proofs for well posed math problems, i see no reason why it shouldn't be able to implement a more performant fully featured version of an existing interpreter (eg with JIT and AOT) that emulates python api well and passes all python tests and tests of other projects. It is true that a lot of human effort and thought has been put into squeezing performance out of the existing implementation. It is true that many people have found that getting that last 1% of python test suite to pass turned out to be insurmountably hard. Same is true for math, and yet AI sometimes finds simple solutions that we somehow missed. Maybe there's a simple optimization that was used in an obscure interpreter of a domain specific language that we never heard of. Worth a shot in my mind. If that turns out to be successful, we should ideally find the code that served "as an inspiration" if any.
It might make more practical sense to start from CPython and try to optimize that further though. It even has a "not fully fleshed out" JIT already.
If humans can find (and have been finding for millennia) new proofs for well posted math problems, I see no reason why they shouldn’t be able to implement a more performant fully featured version of an existing interpreter.
Well, so far any gives level of capability has started with (expensive) frontier models, but everyone else, including the cheaper models, usually quickly catches up and the frontier keeps moving forward.
Fable-level capability will most likely be available for pennies soon enough.
