Sure, but that’s assuming you need a higher rate than is already used for brightness. That’s a question I think can only be determined experimentally by putting real human eyes on it, although I think you could do the experiment with traditional RGB LEDs. But the other question is whether the wavelength tuning can be changed at the same rate as intensity.
This is actually something I find hard to resist in myself as an aging software engineer on HN. When I was young, articles would describe “obvious” things in excruciating detail, and I’d be grateful, because they were often things I didn’t know.
Now when I see articles about things I find obvious on the front page — particularly if they’re topics I’ve seen hit the front page before (which, mind you, means “any time in the last 15 years or so”) — I have to resist an annoyed gut reaction. The fact that knowledge and skills seem obvious and boring once internalized is a kind of terrible quirk of the human condition.
The other person who replied may have already cleared this up for you, but the two conditions you listed mean very different things. The first means “if the next node is not adjacent in memory”, while the second means “if there is no next node.
I feel like there are a number of data structures that you might initially set up (or load in) in some preferred contiguous order, which will still remain largely contiguous after modification, so that you get a good tradeoff between cheap operations and fast traversal. You’d then have the option to do partial defragmentation at convenient times, without having to have a convoluted hybrid data structure. But it’s definitely something you’d do in specific critical cases after a lot of analysis.
I think a more practical example might have been to have a mostly contiguous list with a few discontinuous nodes inserted randomly in the middle. That’s more like a real case, and exercises the advantages of linked lists over simple arrays, but should still perform well, since there would only be a few value speculation misses.
It’s interesting to me that the final assembly-trick-free version almost no longer looks like a hack.
If you commented the inner loop with something like “// Linear scan for adjacent nodes”, the reader gets an OK, if incomplete, intuition for why it’s faster. Even if you don’t know the exact CPU details, if you’re aware that flat arrays usually loop faster than contiguous linked lists, the nested loop immediately reads as a kind of “hybrid mode”.
Nitpicking, but I’d say that it’s a valid question with a trivial answer. A problem is just a set of question/answer pairs. “P?=NP” is just a decision problem with a single instance, and all decision problems with finite instances are decidable in constant time.
Consider this rephrasing of the question: “Let X be an NP-complete problem. Can X be solved in polynomial time?” This is a problem with an infinite number of instances, all of which reduce to “P?=NP”, so we know that this problem can be decided in constant time.
I think this is one of the things that makes the undecidability of the halting problem hard to grok. You want to say “there are certain machines so complicated that it’s impossible for a machine to tell whether they halt or not.” But between the trivial programs “return true” and “return false”, one of them gives the correct answer for any machine and input you throw at them.
You want to object “but those programs don’t know anything about Turing machines. They don’t count!” But that’s not what decidability is about. You might want to think something like “ok, but figuring out which of those programs gives the right answer is undecidable,” but again, no, that has a defined true or false answer too. The problem can only become undecidable once it’s extended to an infinite set of machine/input combinations.
Not to get too bogged down in semantics, but in my mind, there’s a pretty big difference between an alpha and a prototype. A prototype just has to prove out your basic approach, and you don’t put it in the hands of end users, early adopter or not. An alpha is a lot more work, and while it’s expected to be buggy and missing some features, it should be substantially representative of the final product.
There is a separate interesting question of whether you could exploit the nonlinearity of a network of non-ideal resistors in practice. Given that tom7 was able to use floating point inaccuracy as a source of nonlinearity for ML, I’m guessing the answer is probably “yes, but now your system is incredibly sensitive to stuff like ambient temperature”.
It’s been a long time since I worked with C, but my recollection was that a) strict aliasing allows for optimizations that are actually worthwhile, and b) it’s really easy to type pun in a defined way using unions anyway.
The bulleted list of what constitutes “ideal” is missing one of the most important types of questions: questions that aren’t answered by the knowledge set, but which seem like they should/might be.
This is where RAG systems consistently fall down. The end user, by definition, doesn’t know what you’ve got in your data. They won’t ask questions carefully cherry-picked from it. They’ll ask questions they need to know the answer to, and more often than you think, those answers won’t be in your data. You absolutely must know how your system behaves when they do that.
It’s well understood in the field. It’s not well understood by laymen. This is not a problem that people working in the field need to address in their literature.
Does every thread about this topic have to have someone quibbling about the word “hallucination”, which is already an established term of art with a well understood meaning? It’s getting exhausting.
You don’t really even need a transpiler. Require is basically just a function which loads a file, wraps it in some boilerplate, and evals it. You could just rip that runtime code out of node and provide it as a compatibility library.
I wonder if you could do this with multiple alignment training passes, where you extract the refusal direction each time, and suppress it in future training passes.
We’re just arguing anecdotes at this point, but I’ve known a lot of left wing activists, and I have never met one who only cared about a narrow set of issues. In fact, the more typical failure mode is wanting to fight on so many fronts at once that they seem to struggle to focus.
It seems like you (and the author of this pretty blatant propaganda) are assuming the very strange and unfounded premise that most activists believe that there is exactly one problem with the world worth solving.
Of course activists move onto the next problem once the problem they’ve been focusing on is solved. Similarly, I brush my teeth once I get out of the shower. I haven’t “moved the goalposts”; I’m just attending to the next priority.
Seems like you could do something similar, combined with an exclusive scan, to rapidly find all the (potential) tag offsets in an HTML file on the GPU. I doubt that would be worthwhile in a browser due to the overhead of simply talking to the GPU, but it seems like it could be a useful trick if you have gigabytes of HTML to scan.
I think it’s worth noting that when this post was written, the reddit/HN style of threaded conversations was really new, and other contemporary implementations of threading were truly awful.
I think this is a really important part of simplified explanations. You can get pretty far explaining things to people based on the questions that come to them naturally, but eventually you’ll hit a point where understanding requires asking a very long series of the right questions. At these points you have to be willing to say “to go further in this direction, we have to cover several dozen hours of background material” rather than trying to find an immediate practical connection that doesn’t exist.
Interesting that if they had just grabbed microseconds at launch, kept it statically, and mixed that in with their seed, they would have made it far harder to guess. An even better choice would be to also time the microseconds of a few disk writes at launch or grab entropy from network latency, but even one simple timing value would have made these seed prediction attacks impractical at the time.
I wonder how much effective entropy randomart really has. More specifically, I wonder how hard it would be to model “looks the same” and brute force a “collision” that most people would recognize as the same ascii image.
Yeah, this is something I’ve found that it’s important to explain early to users when building an LLM-based product. They need to know that testing the solution out is useful if they share the results back with you. Otherwise, people tend to think they’re helping just by exercising the product so that it can learn from them.
The wild thing is that they’re apparently from different etymologies. “Authorization” comes from “auctor” in Latin, meaning “leader” or “author”, whereas “authentication” originally comes from the Greek “auto” meaning “self”. There probably was some cross influence that brought them into line though.
I would argue that “scripting” has to do with what you, as the programmer, do to deploy your code, and not what happens under the hood. If you can deploy by shipping a single source code file, that’s a script. If there’s a build step, that’s not a script. Whether the underlying system compiles it, interprets it, sends it to MTurk for a human to evaluate by hand, or whatever doesn’t matter.
That reopens the page, but it doesn’t correctly preserve state. Browsers will typically try to restore things like input values, but all JS state is lost, which means most cases where you had actual work to restore don’t work.