MurphyA/hacker-news huggingface dataset:
by rmunn | 2025-09-22 14:22:44+00:00
This is just one example of how metrics can distort things, of course. Someone in management said "We want 100% documentation coverage of every method," so the staff dutifully wasted everyone's time by writing "setDefaultOptions: sets the default options". It's the kind of thing an LLM could have done better, and if you know my opinion of LLM's, you'll know that's damning with faint praise.

My own bete noire here is MSDN. It's full of overloads like "Foo(string parameter, FooOptions options) - actually useful documentation. Foo(string parameter) - does Foo with default options." But to find out what the default options actually are, you have to find another page, probably the FooOptions constructor. I wanted the default options to be mentioned on the "Foo(string parameter)" page, and they so rarely are. (A few pages are better, thankfully).
by losvedir | 2025-09-22 14:23:21+00:00
The guy you're responding to is an aerospace expert, iirc.

Anyway, the balloon would be relatively stable. The atmosphere gets increasingly dense as you go towards the surface, while the balloon has a particular density which is more than the wispy far atmosphere and less than the dense low atmosphere. Therefore, if you were to drop it at the top, it would fall (while it's more heavy) then approach the altitude where it's equally dense, and start bobbing around there, until it settles at its equilibrium.

Picture a glass cylinder of water and oil. It's cleanly separated with the denser water on the bottom and oil on top. Then drop an ice cube in. It will sink through the oil and then float, in the middle of the cylinder, on the water.
by raincole | 2025-09-22 14:23:32+00:00
> offline-pretend-posted

It's a far, far more complicated mental model than simply posting it. It'd be a huge barrier for normal users (even tech-savvy users, I'd say). People want to post it online and that's it. No one wants an app what requires its users to be aware of syncing state constantly unless they really have no choice. We pretend we can step on gas instead of mixing the gas with air and ignite it with a spark plug until we need to change the damn plug.
by eagleal | 2025-09-22 14:23:38+00:00
> prospects for the working class disappeared when you moved manufacturing to China

I think the prospects of the working class died with the crisis signaling the end of the USSR and by extension communist/socialist circles. After all it was the only counter-balance that instilled a baseline fear of violent uprising from the workers class in the heart of the wealthy class.

And in a way the final nail came with the free reign liberal policies that followed with Thatcher e Reagan, not so much about offshoring in itself.
by allemagne | 2025-09-22 14:23:39+00:00
Let's ignore the headline itself for a moment and try to take the rest of the article at face value.

The idea that is being plainly communicated here is that there's a single system of symbols that is so well-understood that it gets passed along to human populations in Siberia that then cross the Bering strait as well as the isthmus of Panama, and these populations over this period maintain this system with such fidelity that they're recognizable as descending from the SAME system of symbols that entirely separate populations in Europe and Southern Africa are also using.

I don't think an alternative intepretation is reasonable to take away from the "Consistent doodles" infographic or the phrasing like "early humans as far back as 40,000 years ago also developed a system of signs that is remarkably consistent across and between continents".

This is either earth-shaking news that demands an entirely new understanding of human heritage, or it's very obvious pseudo-science.
by simiones | 2025-09-22 14:23:45+00:00
This is true in the sense that such a proof can't have "implementation bugs". But it can very much still have "specification bugs", where the formal specification doesn't actually match the fuzzy intention of whoever asked for the work.

For a very simplistic example, say I ask for a trusted program that can add up all of my expenses. The person who writes the spec than defines this as `add_expenses xs = reduce - xs`. They then prove that write a program that matches this specification. The program will be "bug free" in the sense that it will perfectly match this spec. But it will certainly not be what I asked for - so from my point of view, it would be an extremely buggy program.

For a more subtle example, consider encryption algorithms. It's generally fairly easy to specify the encryption scheme, and then check that a program implements that exact algorithm. And yet, it's very likely that a program built only to such a spec will actually leak secrets through various side-channels in practice (either key-dependent timing or even key-dependent CPU usage, and others). Again, it would be fair both to say that the implementation is bug-free (it perfectly matches the spec) and that it is deeply buggy (it doesn't actually protect your secrets).
by Workaccount2 | 2025-09-22 14:24:02+00:00
https://www.youtube.com/watch?v=cxDd3Whl_9s

I also don't want to give the impression that I watched this one video and know ride around on a high horse.

My company has a nuclear division, and while I am not part of it, I am totally aware of the struggles they have.
by marginalia_nu | 2025-09-22 14:24:04+00:00
If you want local-first, conflict resolution is something you're unlikely to be able to avoid. The other option is to say "whoops" and arbitrarily throw away a change when there is a conflict due to a spotty wifi or some such.

Fortunately, a lot of what chafes with git are UX issues more than anything else. Its abstractions are leaky, and its default settings are outright bad. It's very much a tool built by and for kernel developers with all that entails.

The principle itself has a lot of redeemable qualities, and could be applied to other similar syncing problems without most of the sharp edges that come with the particular implementation seen in git.
by jlarocco | 2025-09-22 14:24:34+00:00
As a user the simple answer is that I'll always use a regular application instead of a "local-first" web app when I have the ability.

"Local-first apps" are the worst of everything - crappy, dumbed down web UI; phoning home, telemetry, and other privacy violations; forced upgrades; closed source, etc.

At work, I don't have a choice, so it's Google Docs or Office 365 or whatever. And in that context it actually makes sense to have data stored on some server somewhere because it's not really my data but the company's. But at home I'll always choose the strictly offline application and share my data and files some other way.
by skydhash | 2025-09-22 14:24:37+00:00
The difference is merely how this thing works vs how this thing is used. And the glue factor between the two is ops.

Between the developer and the user, there should be the maintainer role. Someone that took a software and make it run on a specific system. That requires familiarity with the system internal and build systems.

This is why packages managers like in linux distributions are a great solution. A working solution is often just a command away. App stores could be good too, if not for the gatekeeping effects.
by simonask | 2025-09-22 14:25:01+00:00
It varies somewhat by continent, but living very far from the ocean is what’s new. Humans have historically had by far the densest population near shores - river deltas, archipelagos, and so on.

The notion that “seeing the ocean” was a very special thing to most people in history is unlikely. To a Hungarian peasant or a Mongol shepherd, sure, but there were far more people along the Mediterranean coast, the Pearl River delta, and so on.

The reason is very simple: Ocean = free food.
by thw_9a83c | 2025-09-22 14:25:03+00:00
The small ones that you can run on a MacBook are quite useless for programming. Once you have access to a state-of-the-art model, it's difficult to accept any downgrade. That's why I think AI-driven programming will always rely on data centers and the best models.

> if Anthropic is down, there is still Google, OpenAI, Mistral, Deepseek and so on

No company is going to pay for subscriptions to all of them. Either way, we'll see a new layer of fragility caused by overdependence on AI. Surely, though, we will adapt by learning from every major event related to this.
by sokoloff | 2025-09-22 14:25:07+00:00
I have two teenagers. They sometimes have a completely warped view of how hard things are or that other people have probably thought the same things that they’re just now able to think.

(This is completely understandable and “normal” IMO.)

But it leads them to sometimes think that they’ve made a breakthrough and not sharing it would be selfish.

I think people online can see other people filing insightful bug reports, having that activity be viewed positively, misdiagnose the thought they have as being insightful, and file a bug report based on that.

At its core, I think it’s a mild version of narcissism or self-centeredness / lack of perspective.
by zimpenfish | 2025-09-22 14:26:09+00:00
> e.g. if somepackage.Bar suddenly gets a member with same name as one of your URL members?

I think nothing happens there. Your fields "win" on depth and you'd have to access their field with `thing.Bar.Conflicted` (whereas yours would be `thing.Conflicted`).

It could only be a problem if someone embeds both `somepackage.Bar` and `mypackage.Cheese` into `T` with a shared field `X` but then you can't access `T.X` without a runtime error of "ambiguous selector".
by kragen | 2025-09-22 14:26:10+00:00
Most languages don't have an explicit stack, and even their implicit stack is only for subroutine calls. If you're not making subroutine calls, your compiled code might not access the stack at all. So, for example, here's the strlcpy function from OpenBSD, lightly edited:

size_t strlcpy (char *dst, const char *src, size_t siz) { register char *d = dst; register const char *s = src; register size_t n = siz; if (n != 0 && --n != 0) { do { if ((*d++ = *s++) == 0) break; } while (--n != 0); } if (n == 0) { if (siz != 0) *d = '\0'; while (*s++) ; } return(s - src - 1); }

GCC 12.2.0 compiles this to the following 18 ARM instructions, with -mcpu=cortex-a53 -Os -S:

.text .align 2 .global strlcpy .syntax unified .arm .type strlcpy, %function strlcpy: @ args = 0, pretend = 0, frame = 0 @ frame_needed = 0, uses_anonymous_args = 0 @ link register save eliminated. mov r3, r1 cmp r2, #0 beq .L6 .L14: subs r2, r2, #1 beq .L3 ldrb ip, [r3], #1 @ zero_extendqisi2 strb ip, [r0], #1 cmp ip, #0 bne .L14 .L4: sub r0, r3, r1 sub r0, r0, #1 bx lr .L3: mov r2, #0 strb r2, [r0] .L6: ldrb r2, [r3], #1 @ zero_extendqisi2 cmp r2, #0 bne .L6 b .L4 .size strlcpy, .-strlcpy

If you're not familiar with ARM assembly, I'll tell you that nothing in this entire function uses the stack at all, which is possible because strlcpy doesn't call any other functions (it's a so-called "leaf subroutine", also known as a "leaf function") and because ARM, like most RISCs, puts the subroutine return address in a register (lr) instead of on the stack like amd64, or in the called subroutine like the PDP-8, which doesn't have a stack at all. And the calling convention puts arguments and return values in registers as well. So the function can just move data around between memory and registers and decrement its loop counter and increment its pointers without ever touching the stack.

FORTRAN up to FORTRAN 77 didn't support recursion, including indirect recursion, so that you could implement it without a stack.

By contrast, in Forth, instead of registers you use the operand stack. For loop counters you use the return stack. Sometimes you can use the operand stack instead of variables as well, although I think it's usually a better idea to use variables, especially when you're starting to learn Forth—it's much easier for beginners to get into trouble by trying too hard to use the stack instead of variables than to get into trouble by trying too hard to use variables instead of the stack.
by crote | 2025-09-22 14:26:18+00:00
Yeah, I feel like for most applications the online part acts more like a backup than an interactive sync. How often do you really work on the same file on different devices? And if you do so, how often do you want to continue working on an old version rather than first forcing a sync of the latest revision? After all, without a sync you can't continue your work but only edit completely unrelated parts...

I think most real-world applications fall under either "has to be done online", or "if there are conflicts, keep both files and let the user figure it out". Trying to automatically merge two independent edits can quickly turn into a massive mess, and I really don't want apps to do that automagically for me without giving me git-like tooling to fix the inevitable nightmare.
by _fat_santa | 2025-09-22 14:26:18+00:00
IMO one of the things that makes HN so special is the "culture" here. Having been on here since 2018, most folks here are acutely aware of the issues that other sites like Reddit have and we all collectively work to preserve this space so it doesn't become like the other places.

If I see a meme on Reddit I would probably upvote it, but if I see that exact same meme on here I would downvote and probably report it too. That decision comes from a place of wanting to preserve this space and I'm sure many other folks on here would very much agree.
by MathMonkeyMan | 2025-09-22 14:26:21+00:00
The free software evangelist in me says "because local-first gives more to the user of the software," which will tend not to happen when the user is not in control of the software.

Realistically the reason is probably that it's easier to make changes if you assume everything is phoning home to the mother ship for everything.

Also, an unrelated nit: "Why Local-First Apps Haven’t Become Popular?" is not a question. "Why Local-First Apps Haven’t Become Popular" is a noun phrase, and "Why Haven't Local-First Apps Become Popular?" is a question. You wouldn't say "How to ask question?" but instead "How do you ask a question?"
by bluGill | 2025-09-22 14:26:43+00:00
Nearly everything I do is on a shared computer.

At work: I write code, which is in version control. I write design documents (that nobody reads), and put them on a shared computer. I write presentations (you would better off sleeping through them...) and put them on a share computer. Often the above are edited by others.

Even at home, my grocery list is shared with my wife. I look up recipes online from a shared computer. My music (that I ripped from CDs) is shared with everyone else in the house. When I play a game I wish my saved games were shared with other game systems (I haven't had time since I had kids, more than 10 years ago). When I take notes about my kid's music lessons they are shared with my wife and kids...
by jordanb | 2025-09-22 14:26:47+00:00
I feel like git set back mainstream acceptance of copy-and-merge workflows possibly forever.

The merge workflow is not inherently complicated or convoluted. It's just that git is.

When dvcses came out there were three contendors: darcs, mercurial and git.

I evaluated all three and found darcs was the most intuitive but it was very slow. Git was a confused mess, and hg was a great compromise between fast and having a simple and intuitive merge model.

I became a big hg advocate but I eventually lost that battle and had to become a git expert. I spent a few years being the guy who could untangle the mess when a junior messed up a rebase merge then did a push --force to upstream.

Now I think I'm too git-brained to think about the problem with a clear head anymore, but I think it's a failure mostly attributable to git that dvcs has never found any uptake outside of software development and the fact that we as developers see dvcs as a "solved problem" outside more tooling around git is a failure of imagination.
by hashtag-til | 2025-09-22 14:26:51+00:00
I'd say that people take everything as if it was gamified. So the motivation would be just to boast about "raised 1 gazillion security reports in open-source project such as curl, etc. etc.".

AI just make these idiots faster these days, because the only cost for them to is typing "inspect `curl` code base and generate me some security reports".
by paldepind2 | 2025-09-22 14:27:43+00:00
> Local-first was the first kind of app. Way up into the 2000s, you'd use your local excel/word/etc, and the sync mechanism was calling your file annual_accounts_final_v3_amend_v5_final(3).xls

To be precise, these apps where not local-_first_, they where local-_only_. Local-first implies that the app first and foremost works locally, but also that it, secondly, is capable of working online and non-locally (usually with some syncing mechanism).
by magic_hamster | 2025-09-22 14:27:49+00:00
You are a beginner for a short time. Once you get your bearings you will beg for more resources beyond a beginner tutorial.

A serious framework, language or any other tool geared towards production, has to be supported by docs, tutorials and (where possible) a community of people actually deploying this stuff, possibly at scale.

I wonder if we'll see another post next year when OP realizes there's virtually no content for the Shoobahooba Snarfus ecosystem beyond some 'get started' guides.
by FuckButtons | 2025-09-22 14:28:14+00:00
I can’t think of any examples from history of nations which have had dictatorships take over from democratic systems and then had things improve without revolution or war as an impetus for change. I would be very happy for someone to point out one, but it seems to me that the rot of which trump is a symptom will likely take a significant blood letting to correct, if indeed it is to be corrected.
by satiated_grue | 2025-09-22 14:28:50+00:00
MCP is still available from Unisys, which was formed by the "merger" of Burroughs and Sperry Univac.

It was first released in 1961 - is there any other software, particularly an OS, still in production after that long?

https://en.wikipedia.org/wiki/Burroughs_MCP
by kalleboo | 2025-09-22 14:28:50+00:00
As someone who lives in Japan and has a lot of experience with earthquakes, the magnitude tells you not a lot, the depth and location/geology can easily change it from something you don't even feel to something quite big.

This is why I use every chance I can to espouse a scale like Japanese Shindo which actually measures the surface shaking (what matters to civilians) rather than the Magnitude scale that just measures the energy of the earthquake (more interesting to seismologists). Japanese news always focuses on the maximum observed Shindo which immediately tells you had bad it felt/affected people living nearby.

https://en.wikipedia.org/wiki/Japan_Meteorological_Agency_se...
by tensility | 2025-09-22 14:28:57+00:00
I sincerely hope that the attempt to obscure your identity in the resume wan't intended to be serious, A.C. The fact that you left all your former employers' names other than the current one made you a trivial single-hit search on LinkedIn, for whatever it's worth. If you were serious with your attempt at operational privacy, tighten up your information hiding because you're an easy match right now. If you weren't serious, I'd suggest removing the obfuscation altogether. Best of luck.
by lapcat | 2025-09-22 14:28:58+00:00
> There's so many times where one of the first comments are something like "I work in the industry, and the base assumptions of this article are incorrect"

There are so many times where the top comments are totally full of crap, including and especially from people who work in the industry. It's a large industry with countless subspecialties. What reason do you have to trust a comment over an article? If you're going to be skeptical, be skeptical of both, but be especially skeptical of some cursory dismissal of a work that obviously took significant time, effort, and expertise.

I'd love for these commenters to write their own articles and see what's it like to be commented on.
by Archit3ch | 2025-09-22 14:29:43+00:00
Yes, I process per-buffer, same as on CPU.

You need to find parallelism somewhere to make it worth it. This can be multiple independent channels/voices, one large simulation, one high quality simulation, a large neural network, solving PDEs, voxel simulation (https://www.youtube.com/watch?v=1bS7sHyfi58), additive synthesis, a multitude of FFTs...
by TimorousBestie | 2025-09-22 14:29:55+00:00
> The study has some limitations. The analysis identifies a strong association between party control and funding levels, but it cannot definitively prove a cause-and-effect relationship. The 40-year period studied offers limited instances of shifts in political control, which can make it difficult to isolate the precise impact of any single factor. The authors also caution that their findings are historical and may not predict future trends, especially given recent shifts in political rhetoric around science. They note that the observed historical support from Republicans is not a guarantee of future funding priorities.

Understatement of the year.

It’s hard to figure out who is the audience for this study. A hypothetical high-information voter can’t use this study to conclude “If I value science funding, I should vote for Republicans.” A low-or-middle information voter doesn’t care.

Possibly make-work for graduate students?

> Northwestern University’s Kellogg School of Management

They’re an MBA school, they don’t even have a political science department, what is this?
by John2022 | 2025-09-22 14:30:16+00:00
But nowhere (at least in the first couple of levels) does it refer to the slope of the mountain - it says the task is to find "the path of the sled".

But even ignoring that, nowhere does it define the relationship between t and x. What I assume they mean but don't say is that x=t. That's arbitrary.

Also I assume you mean the path of the sled is (t, f(t)) where f is the function defining the slope. If the path of the sled had a value of (x,y) it would be stationary :)
by ForHackernews | 2025-09-22 14:30:30+00:00
> Omarchy 3.0 was released just last week with faster installation and increased Macbook compatibility, so if you’ve been Linux-curious for a while now, we encourage you to try it out!

"If you're curious about trying Linux, why not install this obscure mouseless tiling TUI distro to guarantee you'll never attempt to use Linux again!"
by ModernMech | 2025-09-22 14:30:31+00:00
100% it would have. One of the main things the LiDAR system does is establish a "ground plane", which is the surface on which the car is expected to drive. Any hole or protrusions in that plane stick out like a sore thumb to a LiDAR system, you'll be able to see it in the raw data without much of a feature detector, so detecting them and reacting is fast and reliable.

Contrast with Tesla's "vision-only" system, which uses binocular disparity along with AI to detect obstacles, including the ground plane. It doesn't have as good a range, so with a low- profile object like this it probably didn't even see it before it was too late. Which seems to me a theme for Tesla autonomy.
by jez | 2025-09-22 14:31:00+00:00
Various apps already do this, if you find yourself reading lots of PDFs on phones. For example I use PDF Expert on iOS to do this. It’s not perfect—depending on the quality of the PDF there might be weird artifacts in the reflowed text (e.g., “ff” ligatures getting mapped to the Unicode ligature character “Latin Small Ligature Ff (U+FB00)” which breaks copy/paste/search).

But for PDFs which are really hard to read on a phone otherwise, it’s really a nice investment.