You’re playing chess. You see that you have a forced mate in several moves. You’ve already won, but it will happen in 2, or 5, or 10 moves.
(This isn't how chess mate-finding works.)
Readit Newsanematode commented on US Job Market Visualizer karpathy.ai/jobs/... · Posted by u/andygcook
> Every line deliberate. Crafted like poetry. Human-authored entirely.
This is perhaps overly generous to pure-human authorship. These days, when I write code I like to think I know what it does. I still wouldn't call most of it "crafted like poetry". When I was just learning though, I wrote plenty of code 100% without AI (in fairness, it didn't exist) that I had little understanding of, and it was only "deliberate" in that I deliberately cajoled it into passing the tests.
Or put differently: don't conflate human authorship with quality; people can write garbage without needing AI help.
Indeed. I like to call this form of code organic slop, and it predates the LLM era.
Time travel debugging is soooo cool and I wish it was more widespread (of course I'm aware it's very difficult to implement and has unavoidable overhead). Imagine if an automated error report from a user of your app included not only a stack trace (or whatever have you), but the execution steps leading up to the error.
anematode commented on BitNet: Inference framework for 1-bit LLMs github.com/microsoft/BitN... · Posted by u/redm
Assuming 2 bit per values (first bit is sign and second bit is value).
actv = A[_:1] & B[_:1]
sign = A[_:0] ^ B[_:0]
dot = pop_count(actv & !sign) - pop_count(actv & sign)
It can probably be made more efficient by taking a column-first format.
Since we are in CPU land, we mostly deal with dot products that match the cache size, I don't assume we have a tiled matmul instruction which is unlikely to support this weird 1-bit format.
Haven't looked closely, but on modern x86 CPUs it might be possible to do much better with the gf2affineqb instructions, which let us do 8x8 bit matrix multiplications efficiently. Not sure how you'd handle the 2-bit part, of course.
anematode commented on Faster asin() was hiding in plain sight 16bpp.net/blog/post/faste... · Posted by u/def-pri-pub
And similarly, entire generations of programmers were never taught Horner's scheme. You can see it in the article, where they write stuff like
A * x * x * x * x * x * x + B * x * x * x * x + C * x * x + D
instead of the faster
tmp = x * x;
((A * tmp + B) * tmp + C) * tmp + D
Yep, good stuff. Another nice trick to extract more ILP is to split it into even/odd exponents and then recombine at the end (not sure if this has a name). This also makes it amenable to SLP vectorization (although I doubt the compiler will do this nicely on its own). For example something like
typedef double v2d __attribute__ ((vector_size (16)));
v2d packed = { x, x };
packed = fma(packed, As, Bs);
packed = fma(packed, Cs, Ds);
// ...
return x * packed[0] + packed[1]
Actually one project I was thinking of doing was creating SLP vectorized versions of libm functions. Since plenty of programs spend a lot of time in libm calling single inputs, but the implementation is usually a bunch of scalar instructions.
None of what I listed was in any way specific to "content creators". They're not the only ones who participate in video calls or take photos.
And on the platforms that have a NPU with a usable programming model and good vendor support, the NPU absolutely does get used for those tasks. More fragmented platforms like Windows PCs are least likely to make good use of their NPUs, but it's still common to see laptop OEMs shipping the right software components to get some of those tasks running on the NPU. (And Microsoft does still seem to want to promote that; their AI PC branding efforts aren't pure marketing BS.)
The issue is that the consumer strongly associates "AI" with LLMs specifically. The fact that machine learning is used to blur your background in a video call, for example, is irrelevant to the consumer and isn't thought of as AI.
anematode commented on An Interactive Intro to CRDTs (2023) jakelazaroff.com/words/an... · Posted by u/evakhoury
Heh. Find how to grant permissions/ acquire lock in git. You can not. That is fundamental to distributed systems.
Downside: harder to think about it all.
Upside: a rocket may hit the datacenter.
From what I remember about Figma, it can be proclaimed CRDT. Google Docs got their sync algorithm before CRDT was even known (yep, I remember those days!).
Of course. But typical, live collaborative software doesn't need to be (and shouldn't be) decentralized. In such software it's annoying to not be able to (even speculatively) acquire unique access to an object. I'd be very surprised if Google Docs used CRDTs now.
anematode commented on An Interactive Intro to CRDTs (2023) jakelazaroff.com/words/an... · Posted by u/evakhoury
Enjoyed the article! As someone who's worked on bits of collaborative software (and is currently helping build one at work), I'd caution people from using CRDTs in general. A central server is the right tool for the job in most cases; there are certain things that are difficult to handle with CRDTs, like permissions and acquiring locks on objects.
Edit: I had an excerpt here which I completely misread. Sorry.
This is the most fundamental argument that they are not, directly, an intelligence. They are not ever storing new information on a meaningful timescale. However, if you viewed them on some really large macro time scale where now LLMs are injecting information into the universe and the re-ingesting that maybe in some very philosophical way they are a /very/ slow oscillating intelligence right now. And as we narrow that gap (maybe with a totally new non-LLM paradigm) perhaps that is ultimately what gen AI becomes. Or some new insight that lets the models update themselves in some fundamental way without the insanely expensive training costs they have now.
But they're not "slow"! Unlike biological thinking, which has a speed limit, you can accelerate these chains of thought by orders of magnitude.