skysight-inc/HackerNews huggingface dataset:
Are there really people that eat the same meal, breakfast/lunch/dinner, for the vast majority of their lives?

I don't think anyone would choose that, though I'm sure one could do it if the circumstances demanded it, e.g. due to poverty or being Dr. Mark Watney.

> If your cat is fine with it

How would one know? My cat's options are to:

* Eat what's available

* Starve
The desktop market is both saturated and contracting, and GP gave you the example of ARM taking over successfully: Apple silicon. M1-M4 are all ARM based. The performance is exceptional and the battery life is stellar. They're not just a budget CPU anymore. Further, the growth area of the market, mobile and IoT, are both dominated by ARM at the point Intel would compete with. When Google started to push Chromebooks, they used those same ARM processors. Increasingly, people only have their smartphone as the primary, if not the only, Internet device. People don't want desktops. They want that $300 Chromebook to browse the web and do taxes and that's about it. Now Win11 ARM64 is nearly ready to ship. Microsoft is changing strategy to stay competitive, and that means not sticking to x86.

There are millions of new devices that require processors every year, and if you're NOT making ARM processors then your fab is not making as much money as the competition. Your competition is going to have bigger budgets, and their engineers and fabricators are going to have much better high production experience.

Intel has let themselves fall behind. They've sacrificed the ability to stay competitive in order to stay loyal to their in house and very legacy designs. Intel is trying to sell the same product line that they've had for the past 15 years like the market didn't change, and everyone else has moved on. Now they have this 13th and 14th generation bug/defect, and they're going to look really unappealing.
since we already have some reasons to sign in an enclave, why not just design a cryptographic processor which is highly unoptimized and highly predictable. since the majority of codes benefit immensely from the optimizations, it doesn't seem reasonable to cripple them.
It pulls no punches when it comes to hobby developers.

> Sounds more like a solo endeavor for someone who thinks they’re the hero of a coding saga but is really just a sidekick in their own life

> truly captivating content that’s probably 50% memes and 50% self-reflection on why nobody's using your projects

> Your open issues read like an attempt at social interaction, but we all know it’s just you trying to find a reason for anyone to notice your existence
Divvi Up: privacy-respecting telemetry aggregation
Nowadays debasement and the resulting inflation comes from loans creating cash flow out of thin air. The 20% debasement has turned into the functionally zero percent interest rates. The ritual of bringing coins to the mint for exchange has turned into investments. The feudal lord's turbocharged revenue has turned into the profits of billion dollar corporations.
Well, no... the summary is, you have to think hard in order to use your constraints as effectively as possible or the outcome will suck.
Upgrading from Linux Mint 21.3 to 22: failure and success
Yeah. I'm not sure how transpiling to rust is that much different than using the various standard analysis tools. And back porting things like the counted by attribute.

Also the lowest hanging fruit in C would be adding the ability to box and unbox fat pointers to objects.
> Central Europe also has a

Central Europe out of all places.

> very similar low volume ceramics/optics SME networks

By which you mean - excuse the question - "SME networks" as in "business-networked" mid-size commercial concerns doing low volume production in the electroptical field -or- production networks running optoelectronic hardware at a small scale? Or, both ...
There's no direct translation back and forth between unsafe C to safe Rust tho, and theres infinite memory safe interpretations possible. If you're only interested in a black box executable, where certain tests pass, then I suppose you could just save the C and delete the Rust. But, the Rust has more information (that can't be deduced deterministically from the C). C would first get transpiled to unsafe Rust. Then some intelligence (A.I. or human) would get rid of all the unsafe keywords by making new design decisions that affect how the executable works inside. Each intelligence will do it differently. New edge case tests might give different outputs depending when you transpiled the C. It'd be better to save the Rust and make future changes without worrying if the latest A.I. will make the same design decisions at the prior A.I. each time you compile.
Previous thread from 2021:
https://news.ycombinator.com/item?id=27628101

A lot of advances since then.
I'm not sure you can tell much from ball bearing data but China has strategic reasons to want Russia to fail economically. Basically the still resent Russia taking the lands north of Beijing and Russia being broke would increase their chances of returning some. Already they've been changing some names on the map https://www.kyivpost.com/opinion/13560
Everything AI already runs on x86. Knight's Mill had 72 cores with 244 threads with AVX512, connected to 16gb of 400gb/s local DRAM and up to 384gb of 115gb/s DRAM. Very similar bandwidth to GPUs of the era but with the addition of more DRAM on a second performance tier a little further away from the CPU.

AMD's having a ton of success with Epyc and Threadripper putting up very similar numbers.

The development story for Knight's Mill was a lot simpler than for any GPU. Consequently, I don't think developers were the ones who needed convincing.
You don’t think if the company behind GitHub went all-in on mercurial that might have emerged as the winner? There were plenty of companies using either. Git wasn’t the only distributed game in town. I definitely think GitHub had a lot to do with it.
Also making planes is capital intensive. Ignoring returns is a path to ruin.
This is exactly what I've tried (and failed at) doing! Can I ask how you handle normalization from vendor data when it contains relationships and multilevel nesting? How do you know when to create a new child table, and which ones to create, and their relationships etc. I haven't found a good balance yet.
So you're enumerating a search space of functions, with some constraints to keep the search tractable?

When you do this kind of thing, there are two worst cases:

a) Your constraints are too strong and the search space does not include the target.

b) The search space includes the target but it is too large to search in polynomial time.

How are you dealing with those?

To clarify, the happy case is when your search target is easy to find, i.e. when the search space is small and includes the target. But that happens... rarely (because program search spaces are large).
McDonnell St Louis ( what's now Boeing defence arm ) was a very different operating unit to Douglas Long Beach where the airliners were built.

McD remained an engineering-driven unit whereas Douglas was constantly stymied by accountancy from the early 70s onwards. Douglas lapsed from defence after Ed Heinemann stepped down as chief designer, they had nothing to offer after the A-4.

Boeing Defence is still riding on the solid engineering of the McD F-15 and -18 of that era. Plus the AH-64 from another engineering-driven company, Hughes, and the CH-47 from Vertol. Note the distinct lack of Boeing design origins.
Still 100x better than cross-compiling C
It's indeed used:

Definition of macro:
https://sourceware.org/git/?p=glibc.git;a=blob;f=include/lib...

Use:
https://sourceware.org/git/?p=glibc.git;a=blob;f=string/memm...

For a bunch of other places -fno-builtin-* seems to be used.
VTOL VR by Boundless Dynamics
It’s really not the same thing. Your complaint is about Apple’s complex framework API management, not about the compiler optimization/undefined behavior.

Swift frameworks sometimes blur the line the way I think you mean by being able to be back-deployed to earlier OS releases through embedding in your binary. Apple’s documentation is poor (and has been since the NeXT takeover in 1997), but, again, that’s not a compiler issue as such.
These titles never do it for me. I like the concept of sketching out how much power sam has, but he's not going to be "powerful" and you shouldn't be afraid either. No point in being afraid of something you have no control over
If you have a router then install a firmware to it or a package to it that allows you to route certain clients on the network into a VPN.
> I assume it's because the actual read-write head itself must among the most expensive parts to manufacture,

Ehh a modern HDD is a marvel of precision manufacturing and engineering.

> rather than a bar fixed in place that spans entire radius of the writable surface, with an addressable strip of r/w heads that runs the length of it.

Your bigger challenge is getting a set of read/write heads that are across the platter able to maintain a consistent height/etc.

The closest I'm aware of, are the Connor 'Chinook' drives [0] that had two actuators, one on each side of the drive.

Broadly speaking, I'd ask if multiple heads too close throw off decades of head design experience...

[0] - https://en.wikipedia.org/wiki/Conner_Peripherals#/media/File...
I believe the work from this group suggests about 25 years, but that's probably still a preliminary number.
I should think you could do this with fingerprinting the photo similar to how music is fingerprinted for things like Shazam or MusicBrainz. I used to work for MusicIP, which I believe developed the fingerprinting system MusicBrainz is using.
William Byrd is the creator of miniKanren btw. And an HN user.
Donut still uses WebRTC though, which like I said, I still need TURN for and I can prove it. I still have a really hard time believing that only 20% of "users" (what users where? everyone in the world?) need it, as like I said, almost every residential US user needs it at the least.
At least Mint 22 uses the older Ubuntu installer so it doesn't suffer from https://bugs.launchpad.net/ubuntu-desktop-provision/+bug/205...
> It just seems like there's very few of them because there's been such massive growth

I am somewhat drawn to this explanation simply because represents a kind of statistical blind spot for most people.

I think the default unconscious expectation is that the workplace should represent general population demographics, but the number of people who're still programming now after 40 years is hard-limited by the number of people who were already programming in 1984.

I'm not saying ageism doesn't exist in the industry, but it isn't as bleak as a naive glance around the office might suggest.
My intuition tells me you will quickly run out of memory on anything that isn't just a small function. Your state space will just be so big that your super positions will become too large.
But do you actually need that? Like, really?

If you absolutely do need it, then in addition to "name" you can also add a field "hasName". If you feel fancy, you can even do that in a code generator.
> Visual Studio has an unofficial command line option to help identify certain classes of IFNDR

I'm sure there's a good reason why this is hard, but I'm a little surprised that this isn't caught by static analysis. Sure enough, I can't get MSVC Code Analysis to complain about the example with different inline functions.
Happy to see this made it to the front page. I submitted it because I'm hoping someone here will be able to understand it well enough to explain its significance. Is this Big News or a parlor trick? If it really is an example of an uncomputable physical process, that would seem to me to be earth-shattering, and yet this result does not appear to have made a splash. It is based on a construction of J. Myhill of a continuous recursive (and hence computable) function whose derivative is not computable. The proof is non-constructive, and it assumes the existence of a partially decidable set called A which somehow (this is the part I don't quite understand) results in a computable function despite the fact that its derivative can't be computable because that would imply A is decidable. Any clues would be much appreciated.

[UPDATE] Let me put this more succinctly: how is it possible that there can be a continuous computable function whose derivative is uncomputable? What exactly is it about this function that makes numerical differentiation fail?

[UPDATE2] Here is a link to the Myhill paper for easy reference.

https://projecteuclid.org/download/pdf_1/euclid.mmj/10290006...

It's remarkably short, only two pages.
Very interesting. I always see the two techniques as complementary.
Even if Apple were to defeat the geofencing trick, it's trivial to hide behavior:

1. Make an API call to your server with the build number of the app.

2. Have that API response control whether the "secret" features are available.

3. Only enable each build's secret features once it's passed review.

4. Profit?

No dynamic/interpreted code required.

And there are sufficient variations on this that I would guess it's reducible to the halting problem and thus undecidable.
Why did the call fail? What failed with your implementation/the code?
No, I am not okay with compulsion... you're asking me at which point has the government given enough gifts to justify authoritarianism. And I'm telling you, I don't accept your authoritarianism, and there may be a path forward that doesn't require it.
> The collapse time is estimated between 2037-2064 (10-90% CI) with a mean of 2050 and the probability of an AMOC collapse before the year 2050 is estimated to be 59 +/- 17%.

So apparently the “mean” is different from the 50% point. Would that be the median? And wouldn’t that be the more interesting point?
Hi LightMachine. I can't read Haskel (?). In this screenshot:

https://x.com/VictorTaelin/status/1819208143638831404/photo/...

What's the highlighted program (?) on line 1875997?
This paper is not unremarkable. It's actually quite a surprising result. The only question is whether it's earth-shattering, or just a parlor trick. My money is on parlor-trick, but I don't understand the math well enough to be confident of that. I posted this here hoping to find someone who could shed some light on this question.
Performance is the main one. Another is not having to use a browser or program in JavaScript.
Last time I checked, she wasn't including `Cache-Control` header in the responses. That means a well-behaved client would be doing heuristic caching.

Quoting from https://developer.mozilla.org/en-US/docs/Web/HTTP/Caching#de...

> As mentioned above, the default behavior for caching (that is, for a response without Cache-Control) is not simply "don't cache" but implicit caching according to so-called "heuristic caching".

And then, quoting from https://developer.mozilla.org/en-US/docs/Web/HTTP/Caching#he...

> How long to reuse is up to the implementation, but the specification recommends about 10% [...] of the time after storing.

So assuming I'm reading this correctly, if she still hasn't added `Cache-Control` headers to the feed responses, and her last post was (for example) 24 hours ago, that means a well-behaved client will check the feed again in 2.4h from now, and then again 2.64h after that, and then 2.9h after that, and so on.

If the last feed update was 1 hour ago, and no `Cache-Control` header is present, a well-behaved client would cache the response for 6 minutes (10% of 1 hour).

Quoting the next paragraph (right after my last quote):

> Heuristic caching is a workaround that came before Cache-Control support became widely adopted, and basically all responses should explicitly specify a Cache-Control header.

So a possibility is that Unread RSS Reader might be detecting the lack of `Cache-Control` (which means Rachel is not bothering to follow caching recommendations), which then might be causing Unread RSS Reader to be doing heuristic caching as per the recommendations mentioned above, and the problem is just that Rachel doesn't like this heuristic caching but also doesn't want to include `Cache-Control` in her responses.

And if I'm understanding all this correctly, the `If-Modified-Since` and `If-None-Match` headers have nothing to do with request rate (what she's complaining about), they are only used to let the server decide if it should return a full response or if a 304 is enough.
The 8Tb WD SMR drives I have use a 40gb chunk of the surface for non-SMR reads and writes as a buffer. Altering anything in an SMR track requires copying the data from that track and tracks near it into the buffer, then laying them back down into the SMR region sequentially. Like erasing a flash block before writing. Unfortunately, this means that the drive's performance takes a dump from 200mb/s down to 300kb/s if you do enough transfers to fill the 40gb buffer, or attempt multiple transfers at once.
> keep the laptops in boxes with desiccants to keep them dry

Such a simple solution. Have a special low-humidity environment.-
Uber tried to do this, they geofenced Cupertino for a feature so it wouldn't appear during app review
When I was still in college studying Computer Science (~2001) I got a part time job at a Medical Claims clearing house doing VB and Java programming. My task was to re-write in Java the ancient and archaic system which would read in medical claims that were uploaded by providers and then translate them into the one of several formats, depending on which insurance provider we were sending them to. The inputs were big batches of data in one of two formats, "ASC X12"¹ or "NSF"² and the outputs were some ideocyncratic version of those two, or a 3rd option which was just ascii text, layed out (monospace) such that it would line up when you dump the file directly to a printer loaded with the pre-printed UB-92³ forms.

None of this is particularly interesting, unless you have a fascination with archaic file formats and/or an interest in historical and highly idiosyncratic government bureaucracy.

The really interesting (horrifying) thing about the job, though, was the state of the VB6 code which I was asked to translate into well structured and performant Java. There were some really hilarious and nightmare inducing subroutines like "BunchOfIfs" and "BigSelect", each of these monsters were several thousand lines long and consisted of exactly what you'd expect. Huge branching structures with absolutely no reasonable organization or design. I'm not even exaggerating to say it was just the accumulated cruft of 10 years of dirty hacks tacked on by the cheapest coders they could find where the only standards were if it works it ships. Literally the worst procedural code you can imagine with zero factorization, modularization, plenty of duplicated code copied and pasted then modified to do something slightly different than the 3 other versions of similar code elsewhere in the project.

Somehow, after a year of part-time work (20 hours a week, between classes) I managed to produce a working system to translate claims from any one of the weird formats into any other one of the weird formats, including 5 or 6 variants of said formats, each one which violated the spec in a unique way in order to satisfy the strange requirements of some particular insurance company. The Java version was less than 10% the size (lines of code) of the old system, ran 30x faster and produced correct output.

Still to this day it's objectively the most difficult, painstaking, excruciating, but also probably the best, most impressive work I've done. And it's the least I've ever been paid for writing code.

Oh and I forgot to mention, nothing was in source control and there were several variants of the codebase that had been modified slightly to do a similar but different task and then just continued to drift away from the codebase it was copied from.

1. https://en.wikipedia.org/wiki/ASC_X12
2. https://manuals.momed.com/edb_pdf/NSF%20(National%20Standard...
3. https://owcprx.dol.gov/static/UB-92.pdf
If you do Kotlin, the TODO() function is very useful.
> What should the compiler emit here?

It should emit an instruction to access memory location some_array + i.

That's all most people that complain about optimizations on undefined behavior want. Sometimes there are questions that are hard to answer, but in a situation like this, the answer is "Try it and hope it doesn't corrupt memory." The behavior that's not wanted is for the compiler to wildly change behavior on purpose when something is undefined. For example, the compiler could optimize

if(foo) {
misbehaving_code();
return puppies;
} else {
delete_data();
}

into

delete_data();
Same here. I wrote a little multitree-based TUI with vim-adjacent key bindings for exactly this purpose, since I find it generalises to all complex projects, software-related or not (and who can resist any excuse to write a TUI?), but a simple markdown file is just as good, really, and for software means you can keep it in the repo directly adjacent to other project docs.
> Big News

The paper is from May 2022. Don't you have the answer to whether it's big news? Whether the news is big is (usually) apparent/assessed when it is new.
The article does mention that this is a complication particular to SMR drives, but I was thinking about this not necessarily as a means of reaching higher density storage, but more reliable and perhaps higher performance solutions that would fall somewhere between the compromises of an SSD and a mechanical drive.

It also seems possible that instead of a single super high density strip of heads which may be impossible to manufacture, that instead a series of much lower density array strips could be mounted in n ranks, each rank offset from the predecessor by n/(distance between heads in each strip).

I assume this is not an insurmountable engineering, but that someone has already had this idea or something similar to it, and after running the numbers found it doesn't deliver enough of an advantage over the conventional design to be worth exploring further.
If you were not aware of this then you might reflect on the part of my comment that he doesn’t bring up: how good/bad are use-case dependent. Every program optimizes for a use case, sometimes pessimizing for others (e.g. an n^2 algo that’s worthwhile because it is believed to only be called on tiny vectors).

IMHO he was overgenerous on the optimization improvement of compilers. Often an optimization will make a difference in a tiny fraction of a percent. The value comes from how often that optimization can be applied, and how lots of optimizations can in aggregate make a bigger improvement just as a sand dune is made of tiny grains of sand.
It is unremarkable - it has 5 citations since May 2022. I have papers with more cites from this year.

Edit: it's a parlor trick because they invent a decision procedure (bounds on maxima) and then prove something based on that premise:

> It will be shown that non-computability of the first derivative is not detectable by a Turing machine for two concrete examples

I wonder if they rigged the game hmmm. In general people do this kind of thing all the time to get published (build both a technique and a foil for their technique) and it's always a weak paper.