MurphyA/hacker-news huggingface dataset:
by icegreentea2 | 2025-12-30 04:45:31+00:00
Depending of your flavor of how the rapture is supposed to work, there is supposed to be a 7 year period of tribulations between the rapture (when X population get pulled up to heaven), and the actual second coming of Jesus. That 7 year period is generally expected to be very challenging to Christians.

Within the Left Behind book series... by the end of the first book (of like 10+), they've already revealed who the Anti-Christ is going to be, and foreshadowed the broad outline of his plans (use the UN and the forces of neoliberalism to do his bidding), and he has already basically mind controlled all the world leaders in attendance, and by the end of the second book, the Anti-Christ has managed to trigger WW3.
by shepherdjerred | 2025-12-30 04:48:30+00:00
For personal projects, I have found it to be transformative. I've always struggled with perfection and doing the "boring parts". AI has allowed me to add lots of little nice-to-have features and focus less on the code.

I'm lucky enough that my workplace also uses Cursor + Claude Code, so my experience directly transfers. I most often use Cursor for day-to-day work. Claude has been great as a research assistant when analyzing how data flows between multiple repos. As an example I'm writing a design doc for a new feature and Claude has been helping me with the investigation. My workflow is more or less to say: "here are my repos, here is the DB schema, here are previous design docs, now how does system X work, what would happen if I did Y, etc."

AI is still fallible so you _do_ of course have to do lots of checking and validation which can be boring, but much easier if you add a prompt like "support every claim you make with a concrete reference".

When it comes to implementation, I generally give it smaller, more concrete pieces to work with. e.g. for a personal project I would say something like "here is everything I want to do, make a plan, do part 1, then do part 2, example: https://github.com/shepherdjerred/scout-for-lol/tree/227e784...)

At work, I tend to give it PR-sized units of work. e.g. something very well-scoped and defined. My workflow is: prompt, make a PR on GitHub, add comments on GitHub, tell Cursor "I left comments on your PR, address them", repeat. Essentially I treat AI as a coworker submitting code to me.

I don't really know that I can quantify the productive gain.. I can say that I am _much_ more motivated in the last few months because AI removes so much friction. I think it's backed up by my commit history since June/July which is when I started using Cursor heavily: https://github.com/shepherdjerred
by kevinday | 2025-12-30 04:49:33+00:00
Yeah, I had an issue where Claude was convinced that a sqlite database was corrupt and kept wanting to delete it. It wasn't corrupt, the code using it was just failing to parse the data it was retrieving from it correctly.

I kept telling it to debug the problem, and that I had confirmed that database file was not the problem. It kept trying to rm the file after it noticed the code would recreate it (although with no data, just an empty db). I thought we got past this debate until I wasn't paying enough attention and it added an "rm db.sqlite" line into the Makefile and ran it, since I gave it permission to run "make" and didn't even consider it would edit the Makefile to get around my instructions.
by cloudwaddie | 2025-12-30 04:49:47+00:00
Hi HN!

I'm a student developer, and I'm excited to share my tool. I have recently updated it with numerous new features (e.g. the new local vault and OTP ownership proof), and I'd appreciate your feedback and any questions you may have. I'll try to answer every question, but I apologise if I miss one.

Thank you!
by ramoz | 2025-12-30 04:51:36+00:00
The more concerning algorithms at play are how they are post-trained. And the then concern of reward hacking. Which is what he was getting at.
https://en.wikipedia.org/wiki/Reward_hacking

100% - we really shouldn't anthropomorphize. But the current models are capable of being trained in a way to steer agentic behavior from reasoned token generation.
by iliketrains | 2025-12-30 04:52:15+00:00
Sure, we could use Burst to speed up some strategic parts, but that would not help with the core of the game.

To give some context, things are very complex in our game, we have fully dynamic terrain with terrain physics (land-slides), advanced path-finding of hundreds of vehicles (each entity has its own width and height clearance), trains, conveyors and pipes carrying tens or even hundreds of thousands of individual products, machines, rockets, ships, automated logistics, etc. There is no one thing that could be bursted to get 3x gain. At this point, we'd have to rewrite the entire game in C++.

So what's the reason we use C#? Productivity, ease of debugging and testing, and resilience to bugs (e.g. null dereference won't kill the program). Messing with C++ or even burst would cost us more time and to be honest, the game would possibly not even exist at that point.

Could you share some details about your custom thread pool that got 3x speedup? What was the speedup from? It is highly unlikely that a custom thread pool would have any significant impact on the benchmark in our case. As you can see from Figure 3, threaded tasks run for about 25% of the total time and even with Mono, all tasks are reasonably well balanced between threads. Threads utilization is surely over 90% (there is always slight inefficiency towards the end as threads are finishing up, but that's 100's of ms). An "oracle" thread pool could speed tings up by 10% of 25%, so that is not it.

Vectorization could help too but majority of the code is not easily vectorizable. It's all kinds of workloads, loading data, deserialization, initialization of entities, map generation, precomputation of various things. I highly doubt that automatic vectorization from code generated by IL2CPP would bring more than 20% speedup here. The speedup from burst would mostly come from elimination of inefficient code generated by Mono's JIT, not from vectorization.

For now, we are accepting the Mono tax to be more productive. But I am hoping that Unity will deliver on the CoreCLR dream. In the meantime, my post was meant raise awareness and stir up some discussion, like this one, which is great. I've read lots of interesting thoughts in this comments section.
by dannyw | 2025-12-30 04:52:34+00:00
Yeah. Where piracy really hurts is when games get cracked and released before the official release date. That actually devastates sales; unlike a teenager with no money pirating a game (who they can’t afford to buy anyway).

There used to be (maybe still is?) a period where a small number of publishers had DRM for the first few weeks, and removed it once it was cracked.
by artigent | 2025-12-30 04:52:45+00:00
Just a quick note: This is an independent project and is not affiliated with the official Clang or clangd projects.

This project is by no means a replacement for the clangd language server used in IDEs. Instead, it is designed to complement it by enabling LLMs to perform deep architectural analysis. While clangd handles real-time coding assistance, this tool focuses on high-level reasoning, such as mapping project workflows, tracing complex call paths, and understanding system-wide architecture.
by ggm | 2025-12-30 04:55:48+00:00
Interesting to see where the UX leads. The gov.uk design principles are amazing and they respond to feedback. If this exercise makes visible changes of benefit, it would be great for open government.

How about related ideas like a signed ledger over requests and responses to congress through a HSM timestamped transaction log, so that questions and answers cannot be repudiated post fact? Put reps "on the record" (note: this doesn't mean block chain)
by jmyeet | 2025-12-30 04:56:23+00:00
A game that (IMHO) handled this really well was Assassin's Creek Odyssey.

Athens takes up a huge part of the map but is on the same scale. Of course it's still a fraction of the size that the ancient Athens would've been but it's still impressive.

The real issue here is time scales. Nobody wants to spend an IRL week riding between towns so those distances get compressed for the sake of storytelling. This problem haunts pretty much every game genre. Take the Civilization games where a unit is moving 1-5 spaces per turn and a turn is 1-20 years. the WW2 time scale is about 6 turns. If you ever played Civ1 on the Earth map, Europe is also about 12 squares so the European theater of WW2 cmes down to a couple of riflemen or modern infrantry and 1-2 Armor units smacking into each other if you get stuck on the time and distance scales.

Books, comics, TV shows, movies, etc don't have this problem because they don't have a constant scale (24 notwithstanding). And the goal is to tell a story. Even in an open world open ended game, you're telling a story.

I miss the old D&D turn-based games, even including the later more graphical entries like Eye of the Beholder. It was kinda funny to duck into a room and camp for 200 hours to heal and recover.

You just don't worry about these scale issues if you're immersed. That's what I learned.
by Intralexical | 2025-12-30 04:57:45+00:00
`zpaq add archive.zpaq new.mbox -fragment 0 -method 3` is great for this. It splits the input into fragments averaging 1024 bytes in size [0], which catches up to ~90% of redundancy. The remaining ~10% is packed and compressed into 64MB (max) blocks that are added to the .zpaq.

The resulting artifact is a single .zpaq file on disk. This file is only ever appended to, never overwritten, so it plays nice with Restic's own chunked deduplication. Plus it won't flood the filesystem and it suffers less small files overhead than TFA's solution.

Granted I suspect TFA splitting on the e-mail headers may be chunking more efficiently. Though, unless I skimmed the linked GitHub too fast, it looks like TFA's solution also doesn't use any solid compression to exploit redundancy across chunks. And I trust zpaq as a general purpose tool more than a one-off just for a single use case. The code does look clean, though, nice work.

[0] Average fragment size is 1024*2^N. If the most of the data is attachments that don't change, you can probably use a higher `-fragment N` to have less overhead keeping track of hashes. `-method 3` is a good middle ground for backups. `-m5` gets crazy high compression ratios, but also crazy slow speed. Old versions of ingested files are shadowed by default; use `-all` when you want to list/extract them.
by conductr | 2025-12-30 05:00:56+00:00
If it requires an expert engineer/dishwasher to keep the flow running perfectly, the human is the bottleneck in the process. This sounds a lot more like the past before AI to me. What AI does is just give you enough dishes that they don’t need to be washed at all during dinner service. Just let them pile up dirty or throw them away and get new dishes tomorrow it’s so immaterial to replace that washing them doesn’t always make sense. But if for some reason you do want to reuse them, then, it washes and dries them for you too. You just look over things at the end and make sure they pass your quality standards. If they left some muck on a plate or lipstick on a cup, just tell it not to let that happen again and it won’t. So even your QC work gets easier over time. The labor needed to deal with dirty dishes is drastically reduced in any case.
by viraptor | 2025-12-30 05:01:40+00:00
I'm not sure who generates random code without a goal or checking if it works afterwards. Smells like a straw man. Normally you set the rules, you know how to validate if the result works, and you may even generate tests that keep that state. If I got completely random results rather than what I expect, I wouldn't be using that system - but it's correct and helpful almost every time. What you describe is just not how people work with LLMs in practice.
by morgan814 | 2025-12-30 05:02:18+00:00
I somewhat begrudgingly switched to ControlD after years with NextDNS.

The NextDNS web UI is flippin fast and very simple. Feels more akin to HN. ControlD’s is slow and feels so heavy. Maybe more like new Reddit.

ControlD offers Hagezi’s TIF list and allows custom lists to be set. NextDNS’s built-in TIF is very opaque. This was really the deciding factor for me. Unfortunately.
by bccdee | 2025-12-30 05:02:22+00:00
Ok but you understand that the fundamental nature of LLMs amplifies errors, right? A hallucination is, by definition, a series of tokens which is plausible enough to be indistinguishable from fact to the model. If you ask an LLM to explain its own hallucinations to you, it will gladly do so, and do it in a way that makes them seem utterly natural. If you ask an LLM to explain its motivations for having done something, it will extemporize whichever motivation feels the most plausible in the moment you're asking it.

LLMs can be handy, but they're not trustworthy. "Own and be responsible for the code you commit" is an impossible ideal to uphold if you never actually sit down and internalize the code in your code base. No "summaries," no "explanations."
by schuylerlarson | 2025-12-30 05:02:23+00:00
Completely agree. Look at some videos on YouTube. 20,000 comments on brand new videos sometimes. A lot of good people are commenting on the internet. The problem is that the trust in public institutions is at an all time low, and that is leading to much more doom and gloom and those of us who are from the 2000s can feel the difference in the comment sections.
by AndrewKemendo | 2025-12-30 05:02:24+00:00
If anyone wants to know why the human race is doomed it’s because of precisely what this article describes:

Individual property owners having no desire to be part of a unified community in order to address an externality caused by a corporation exporting pollution.

That’s it. You can’t fix that which means independent human organizations can’t form that aren’t focused around direct financial benefit to the individual.
by wolvoleo | 2025-12-30 05:02:51+00:00
Outlook online (I have M365 business basic) search sucks just as much. It finds really recent emails and ones from years ago but nothing in between for some reason.

The desktop outlook (the real one, not the 'new' one which is just the web version) is much better of course as it searches locally but it's only on windows. And thunderbird doesn't work great with M365.

But anyway my point is even supposedly premium services screw this up.
by iliketrains | 2025-12-30 05:02:57+00:00
Re serialization: We have custom binary serialization that essentially dumps the game state into a binary stream. No allocations, no copies, no conversions. Our saves can be big, >100 MB uncompressed, so there is no room for waste.

The big advantage is that it reads data directly from game's classes, so there is no boilerplate needed, no prorobufs, no schema. And it supports versioning, adding or removing members mostly without limitations.

I think it's a cool system, maybe I should write a blog post about it :)
by inkyoto | 2025-12-30 05:04:48+00:00
> […] 2GB maximum offsets in the .text section

… on the x86 ISA because it encodes the 32-bit jump/call offset directly in the opcode.

Whilst most RISC architecture do allow PC-relative branches, the offset is relatively small as 32-bit opcodes do not have enough room to squeeze a large offset in.

«Long» jumps and calls are indirect branches / calls done via registers where the entirety of 64 bits is available (address alignment rules apply in RISC architectures). The target address has to be loaded / calculated beforehand, though. Available in RISC and x86 64-bit architectures.
by krackers | 2025-12-30 05:05:22+00:00
Hm I did notice this bit "list of up to the last 50 targets you've done (so you don't get duplicate targets too frequently)" which seems to invalidate some of the methodology. If the target is never among the last 50 you've done that skews sample space a bit. The fact that this needs to be done also seems to imply the set of images is not that large...

And this is worsened by the fact that the LLM-based auto scoring explicitly uses the last 10 as decoy targets

>When you submit a session, the system collects your last 10 targets (including the current target) to create a pool of possible matches. A multimodal AI agent is presented with your complete session (including all drawings, text, and data) along with all 10 targets from the pool. The agent is instructed to analyze and rank the targets based on how well they match the session content.

The protocol otherwise seems good, but the specific carveouts here would seem to bias results.

The source for the judging is at https://github.com/Social-RV/comparative-judging which is the part which would need to be studied carefully. At first glance, it exposes raw filenames to the LLM which might bias things. The ranking logic also seems a bit sketchy, it does some tournament-style elimination thing which I haven't analyzed thoroughly but if decoys are eliminated in an earlier round it could bias things compared to just asking the LLM to order the 10 images based on similarity in a single-pass which is obviously unbiased.
by tombert | 2025-12-30 05:05:47+00:00
Something I just started doing yesterday, and I'm hoping it catches on, is that I've been writing the spec for what I want in TLA+/PlusCal at a pretty high level, and then I tell Codex implement exactly to the spec. I tell it to not deviate from the spec at all, and be as uncreative as possible.

Since it sticks pretty close to the spec and since TLA+ is about modifying state, the code it generates is pretty ugly, but ugly-and-correct code beats beautiful code that's not verified.

It's not perfect; something that naively adheres to a spec is rarely optimized, and I've had to go in and replace stuff with Tokio or Mio or optimize a loop because the resulting code is too slow to be useful, and sometimes the code is just too ugly for me to put up with so I need to rewrite it, but the amount of time to do that is generally considerably lower than if I were doing the translation myself entirely.

The reason I started doing this: the stuff I've been experimenting with lately has been lock-free data structures, and I guess what I am doing is novel enough that Codex does not really appear to generate what I want; it will still use locks and lock files and when I complain it will do the traditional "You're absolutely right", and then proceed to do everything with locks anyway.

In a sense, this is close to the ideal case that I actually wanted: I can focus on the high-level mathey logic while I let my metaphorical AI intern deal with the minutia of actually writing the code. Not that I don't derive any enjoyment out of writing Rust or something, but the code is mostly an implementation detail to me. This way, I'm kind of what I'm supposed to be doing, which is "formally specify first, write code second".
by wolvoleo | 2025-12-30 05:06:56+00:00
Totally agree. I swap phones a lot and it's a nightmare with eSIM. For example I sometimes use an old phone when I go hiking or to a big festival. Better to have that stolen or broken. Some providers even charge money every time you swap.

Also, if I would drop my phone and break it I can simply remove the SIM and stick it in a backup phone. Can't do that with an esim either without the carrier cooperating.

Luckily all my current used phones still have two sim slots. It's something I select for but I'm sure eventually it will become harder.

Sure for a one month travel SIM it's super handy but I don't want it for my main number.
by mikepurvis | 2025-12-30 05:07:23+00:00
Sure, but when you speak of Arc Raiders selling 7M copies by late November, basically all of those were at $70-80 because the game just came out.

Maybe I'm not contributing meaningfully to the dialogue, but talking about total sales across a 5 year lifespan means you're necessarily including all those packrat users who picked it up on deep discount and haven't even booted it up once (or, like me, played two hours and in that initial window wasn't especially grabbed by the story, characters, or progression systems that the game was wanting me to engage with). It's different when something really pops off on release and sells all those copies in the first few months.
by cloudflare728 | 2025-12-30 05:08:17+00:00
I had no idea how it would end up. It was first time using AI IDE. I had only used chatgpt.com and claude.ai for small changes before. I continued it for the experiment. I thought AI write too many tests, I will judge based on test passing. I agree, it was bad expectation + no experience with AI IDE + bad software engineering.
by nutanc | 2025-12-30 05:09:06+00:00
Got pissed off with too many ARR manipulations and AI startups announcing revenue numbers manipulations(best day * 365 as ARR etc). These startups are not only messing up the AI ecosystem with the non standard numbers, they are also messing up the SaaS ecosystem by co opting the SaaS metrics. Now SaaS startups are supposed to show the same scale though the AI startups have also not achieved that scale. So here is what I propose, the AI startups should use their own new vocabulary. Since everyone is vibe coding, I suggest VRR, Vibe Revenue Run-rate :)

I have even provided a formula(all scientific and all) and also provided a checklist for the VCs.
by MaskRay | 2025-12-30 05:09:06+00:00
Note, sections without the SHF_ALLOC flag, such as `.debug_*` sections, do not contribute to the relocation distance pressure.
Many 10+GiB binaries (likely due to not using split DWARF) might have much smaller code+data and not even close to the limit.

However, Google, Meta, and ByteDance have encountered x86-64 relocation distance issue with their huge C++ server binaries.
To my knowledge industry users in other domains haven't run into this problem.

To address this, Google adopted the medium code model approximately two years ago for its sanitizer and PGO instrumentation builds.
CUDA fat binaries also caused problems. I suggest that linker script `INSERT BEFORE/AFTER` for orphan sections (https://reviews.llvm.org/D74375 ) served as a key mitigation.

I hope that a range extension thunk ABI, similar to AArch64/Power, is defined for the x86-64 psABI.
It is better than the current long branch pessimization we have with -mcmodel=large.

---

It seems that nobody has run into this .eh_frame_hdr implementation limitation yet

* `.eh_frame_hdr -> .text`: GNU ld and ld.lld only support 32-bit offsets (`table_enc = DW_EH_PE_datarel | DW_EH_PE_sdata4;`) as of Dec 2025.
by badc0ffee | 2025-12-30 05:10:50+00:00
I'm (barely) under 50, but I kind of hate it. I have no idea how to handle the un-threaded flood of messages, and much prefer something like Reddit, message boards, or even FB groups. I felt the same way about IRC back in the day and never got into it.

I use Slack at work, but at least there I have a workable plan: no notifications for most channels, read or at least skim all messages in every channel by EOD, don't read it outside of business hours unless I get a DM. Also, absolutely never join the chatty #random type channels.
by BrenBarn | 2025-12-30 05:11:11+00:00
That seems to be a third-party library that claims to add Qt Widgets support to QML, but it's hard to see from those examples how exactly it works. It still seems to be using a QML-style layout framework. What I'm saying is I would want to have an app that is entirely Qt Widgets, with the same behavior as if I had written it in code, but using a declarative language to specify as much of that information as possible. (Also I'd want to be able use it from Python with PyQt/PySide, not just C++. :-)