Readit NewsThe most interesting part, IMO, is the "SRAM with EEPROM backup" chip. It allows you to persistently save the clock hands' positions every time they're moved, without burning through the limited write endurance of a plain old EEPROM. And it costs less than $1 in single quantities. That's a useful product to know about.
That said, I think the framing of "CCC vs GCC" is wrong. GCC has had thousands of engineer-years poured into it. The actually impressive thing is that an LLM produced a compiler at all that handles enough of C to compile non-trivial programs. Even a terrible one. Five years ago that would've been unthinkable.
The goalpost everyone should be watching isn't "can it match GCC" — it's whether the next iteration closes that 158,000x gap to, say, 100x. If it does, that tells you something real about the trajectory.
It says that a nested query does a large number of iterations through the SQLite bytecode evaluator. And it claims that each iteration is 4x slower, with an additional 2-3x penalty from "cache pressure". (There seems to be no explanation of where those numbers came from. Given that the blog post is largely AI-generated, I don't know whether I can trust them not to be hallucinated.)
But making each iteration 12x slower should only make the whole program 12x slower, not 158,000x slower.
Such a huge slowdown strongly suggests that CCC's generated code is doing something asymptotically slower than GCC's generated code, which in turn suggests a miscompilation.
I notice that the test script doesn't seem to perform any kind of correctness testing on the compiled code, other than not crashing. I would find this much more interesting if it tried to run SQLite's extensive test suite.
This is a big difference because there are all kinds of other factors besides energy capacity that can affect the efficiency of the whole system, and therefore affect range.
Most notably, air is about 28% denser at -40°C than at 25°C, so drag is about 28% higher. So you would expect roughly 28% less range at high speeds even if the battery has no capacity loss whatsoever.
As someone else mentioned, climate control also consumes a lot more power when it has to maintain a larger temperature difference between inside and outside.
Not a mathematician and obviously you guys understand this better than I do. One thing I can't understand is how they're going to judge if a solution was AI written or human written. I mean, a human could also potentially solve the problem and pass it off as AI? You might say why would a human want to do that? Normal mathematicians might not want to do that. But mathematicians hired by Anthropic or OpenAI might want to do that to pass it off as AI achievements?
Of course a math expert could solve the problems themselves and lie by saying that an AI model did it. In the same way, somebody with enough money could secretly film a movie and then claim that it was made by AI. That's outside the scope of what this paper is trying to address.
The point is not to score models based on how many of the problems they can solve. The point is to look at the models' responses and see how good they are at tackling the problem. And that's why the authors say that ideally, people solving these problems with AI would post complete chat transcripts (or the equivalent) so that readers can assess how much of the intellectual contribution actually came from AI.
What you're describing would probably have been equally possible with Postgres from 20 years ago, running on an average desktop PC from 20 years ago. (Or maybe even with SQLite from 20 years ago, for that matter.)
Don't get me wrong, Postgres has gotten a lot better since 2006. But most of the improvements have been in terms of more advanced query functionality, or optimizations for those advanced queries, or administration/operational features (e.g. replication, backups, security).
They were kept to preserve a record of their having been uploaded, and to not create a legal risk for third parties who might be relying on the Commons page as their way to provide attribution.
The original proposal was to keep the image pages with the metadata, but delete the image files. That turned out to have some technical hurdles, so instead the images were overwritten with versions containing big ugly attribution messages, to discourage their use.
It's probably true that without a chance of conviction, standard protocol dictates that public resources should not be expended on reopening the investigation. But I was also heavily distracted while reading the article, scanning optimistically for the happy (under the circumstances) ending where justice is served. I certainly don't think there is "no benefit to anybody".
> “I don’t know what happened in that house, on that night, but I do know that someone gave this baby crushed Tylenol-3,” likely mixed in breast milk or formula. “That’s the only way these numbers make sense.”
Does no one care that this is potentially a murder case?
The scientific case about infant opioid poisoning in general is a separate issue, of course. But assigning blame in this particular case doesn't have any bearing on that.
I believe the point is that it's much easier to create a plausible justification than an accurate justification. So simply requiring that the system produce some kind of explanation doesn't help, unless there are rigorous controls to make sure it's accurate.
Basically, the scattering process that "remove" blue from the spectrum also removes green, albeit to a lesser extent. There are some greenish and yellowish wavelengths in the sunset sky, but they're dominated by red, so the overall color appears red or orange.
In order for the sky to look noticeably green, there would have to be something that scattered reds and blues, without significantly absorbing green.
If you try to interpolate between sky-blue and orange using graphics software, the result depends on what "color space" you're using. If your software interpolates based on hue, you might see green (or purple) in the middle. But that's not physically realistic.
A realistic model is to interpolate each wavelength of the continuous spectrum separately. Interpolating in RGB color space is a crude approximation to this. And if you try the experiment, you'll see that the midpoint between sky-blue and orange is a kind of muddy brown, not green.