Gervais Principle strikes again.
561 karma · joined February 22, 2019
As others said, the killer app is XCode. Even if you can technically get it to run, you'll still need the full support and test flows of a native solution, so you might as well follow the proper path and use a Mac.
I can get Visual Studio to run in Parallels today. I still test with a real Windows machine.
Out of those, Julia is the only one that combines Multiple Dispatch and native code, both important for numerics.
Technically true, since it supports NVIDIA and AMD.
But we have a different definition of portability, if I cannot bring a Metal device and expect it to work.
> Web distribution, which is available only in the EU
I assume this settles it, since it was always possible to web-distribute desktop apps outside the EU.
License-wise, Mojo reminds me of paid Borland compilers that were in vogue before I was born. Even if it's open-sourced, what incentive does Qualcomm have to maintain a happy path for Metal deployment? Mojo might actually be the best way to program Apple GPUs (on a technical level) and it would still lose due to politics.
Sure, if you want the latest and almost* greatest. You can pick up an M1 Max 64GB for ~1k.
* I guess 128GB also exists
It's used in audio processing. But large DAW sessions need something beefier than both tested devices (Macbook Neo, XPS).
They do in audio processing. ;)
> Something to note is that quantum algorithms are never purely quantum. There is a tonne of classical processing needed to get inputs ready, post-process outputs, and even construct and represent the quantum circuits themselves.
2. Did you face any problems for the 'surrounding' areas by JAX imposing the limitation of pure functions?
# Traditional Let over Lambda
counter = let x = 100
() -> x += 1
end
counter() # 101
# Pandoric Macro
captured_x_ref = Core.getfield(counter, :x)
println("The hidden state is: ", captured_x_ref.contents) # Outputs: 101Same here, but in Julia instead. Sometimes I drop down to LLVM intrinsics (e.g. to force lop3.lut on GPUs).
However, it's pretty good at regurgitating textbook answers (classic Google...). This makes it an asset for circuit design. Try one of my real queries with Gemini Pro:
"Create a differential current splitter that splits a bias current Ib into a positive current Ipos = Ib/2 + ky*Vy and a negative current Ineg = Ib/2 - ky*Vy where Vy = Vy+ - Vy- is a differential voltage input Y."
Although as mentioned plenty of times, the largest wins tend to come from laying out your data correctly, or switching to a different algorithm. And heuristics. ;)
Portable SIMD is (perma?) nightly.
Requires 'unsafe' everywhere.
To skip bounds-checking, you typically need to switch your writing style from loops to iterators.
No JIT, so you need multiversioning and/or target-cpu=native. Since Rust doesn't bring a compiler, you need to predict all your target architectures in advance.
Cannot inspect @code_llvm/@code_native at the function level like Julia, you need to compile the entire app.
Prioritizes Floating-Point strictness over --ffast-math. It's a genuine win for safety, but that's overkill in some domains (e.g. graphics, games, audio).
The Q4_K_M is 75GB. I'm exactly at 64GB, and I wouldn't quantize it further. Instead, do partial weight residency and stream the rest from SSD.